simplify

Author: clabby

actor/README.md

@@ -75,7 +75,7 @@ At minimum, you provide:
 - `type Args`: startup payload (`()` when unused)
 - `type Snapshot`: cheap clone used for concurrent read-only handlers
 - `snapshot(...)`
-- `on_readonly(...)`
+- `on_read_only(...)`
 - `on_read_write(...)`
 
 ### Minimal actor example
@@ -108,7 +108,7 @@ impl<E: Spawner> Actor<E> for Counter {
         self.total
     }
 
-    async fn on_readonly(
+    async fn on_read_only(
         _context: E,
         snapshot: Self::Snapshot,
         message: CounterMailboxReadOnlyMessage,
@@ -153,7 +153,7 @@ runner.start(|context| async move {
 - read-only ingress runs concurrently on snapshots
 - read-write ingress runs serially on actor state
 - read-write handling is fenced behind read-only work dispatched before the write arrived
-- returning `Err` from `on_readonly` or `on_read_write` is fatal but `on_shutdown` is still called after draining in-flight reads
+- returning `Err` from `on_read_only` or `on_read_write` is fatal but `on_shutdown` is still called after draining in-flight reads
 
 `subscribe` detail:
 
@@ -200,7 +200,7 @@ impl<E: Spawner + Clock> Actor<E> for ExternalActor {
         self.value
     }
 
-    async fn on_readonly(
+    async fn on_read_only(
         _context: E,
         snapshot: Self::Snapshot,
         message: ExternalMailboxReadOnlyMessage,

actor/macros/src/ingress/mod.rs

@@ -678,12 +678,14 @@ pub(crate) fn expand(input: TokenStream) -> TokenStream {
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
     let names = GenericParamNames::from_generics(&generics);
 
-    let readonly_variants = items
+    let readonly_variants: Vec<_> = items
         .iter()
-        .filter_map(|item| emit_readonly_variant(item, &actor));
-    let read_write_variants = items
+        .filter_map(|item| emit_readonly_variant(item, &actor))
+        .collect();
+    let read_write_variants: Vec<_> = items
         .iter()
-        .filter_map(|item| emit_read_write_variant(item, &actor));
+        .filter_map(|item| emit_read_write_variant(item, &actor))
+        .collect();
     let wrappers = items.iter().map(|item| {
         let ctx = WrapperEmitCtx {
             actor: &actor,
@@ -707,13 +709,51 @@ pub(crate) fn expand(input: TokenStream) -> TokenStream {
         MailboxKind::Unbounded => quote!(#actor::mailbox::UnboundedMailbox<#ingress #ty_generics>),
     };
 
+    let phantom_variant = if generics.params.is_empty() {
+        quote!()
+    } else {
+        let phantom_args: Vec<_> = generics
+            .params
+            .iter()
+            .map(|p| match p {
+                GenericParam::Type(tp) => {
+                    let ident = &tp.ident;
+                    quote!(#ident)
+                }
+                GenericParam::Lifetime(lp) => {
+                    let lt = &lp.lifetime;
+                    quote!(&#lt ())
+                }
+                GenericParam::Const(_) => quote!(()),
+            })
+            .collect();
+        quote! {
+            #[doc(hidden)]
+            _Phantom(::core::marker::PhantomData<(#(#phantom_args),*)>),
+        }
+    };
+
+    let empty = quote!();
+    let readonly_phantom = if readonly_variants.is_empty() {
+        &phantom_variant
+    } else {
+        &empty
+    };
+    let read_write_phantom = if read_write_variants.is_empty() {
+        &phantom_variant
+    } else {
+        &empty
+    };
+
     quote! {
         pub enum #readonly_ingress #generics #where_clause {
             #(#readonly_variants)*
+            #readonly_phantom
         }
 
         pub enum #read_write_ingress #generics #where_clause {
             #(#read_write_variants)*
+            #read_write_phantom
         }
 
         pub enum #ingress #generics #where_clause {

actor/src/lib.rs

@@ -30,14 +30,14 @@ stability_scope!(ALPHA {
     /// 1. `on_startup` once (receives [`Actor::Args`] data).
     /// 2. Per iteration: `preprocess`, then race lanes against
     ///    `on_external` for one event. If a message is received (`Some`),
-    ///    dispatch to `on_readonly` (concurrent) or `on_read_write` (serial),
+    ///    dispatch to `on_read_only` (concurrent) or `on_read_write` (serial),
     ///    then `postprocess`. If the source
     ///    yields `None` (lane closed or `on_external` exhaustion), skip
     ///    directly to `on_shutdown`.
     /// 3. `on_shutdown` once, on graceful exit (runtime stop, lane closure,
     ///    or `on_external` returning `None`).
     ///
-    /// Returning `Err` from `on_readonly` or `on_read_write` is fatal: the error is logged,
+    /// Returning `Err` from `on_read_only` or `on_read_write` is fatal: the error is logged,
     /// remaining in-flight reads are drained, and then `on_shutdown` is called
     /// before the loop exits.
     pub trait Actor<E>: Send + 'static {
@@ -54,7 +54,7 @@ stability_scope!(ALPHA {
         /// `<MailboxName>Message`.
         type Ingress: IntoIngressEnvelope;
 
-        /// Fatal error type returned by [`Actor::on_readonly`] and [`Actor::on_read_write`].
+        /// Fatal error type returned by [`Actor::on_read_only`] and [`Actor::on_read_write`].
         ///
         /// Returning `Err` from read/write handlers logs the error and stops the
         /// actor.
@@ -89,7 +89,7 @@ stability_scope!(ALPHA {
         ///
         /// Called on: runtime shutdown signal, lane closure,
         /// [`Actor::on_external`] returning `None`, or after a fatal handler
-        /// error from [`Actor::on_readonly`] or [`Actor::on_read_write`].
+        /// error from [`Actor::on_read_only`] or [`Actor::on_read_write`].
         fn on_shutdown(
             &mut self,
             _context: &mut E,
@@ -114,7 +114,7 @@ stability_scope!(ALPHA {
         /// Create a snapshot for handling read-only ingress concurrently.
         ///
         /// The service loop captures this snapshot when a read-only message is
-        /// admitted, then executes [`Actor::on_readonly`] in a spawned task.
+        /// admitted, then executes [`Actor::on_read_only`] in a spawned task.
         ///
         /// This must be cheap to create. Prefer `Arc`-backed structures or
         /// `Copy` types. Avoid deep cloning large data structures, as
@@ -131,11 +131,13 @@ stability_scope!(ALPHA {
         /// Returning `Err` is fatal: the service loop logs the error, drains
         /// remaining in-flight reads, and then calls [`Actor::on_shutdown`]
         /// before exiting.
-        fn on_readonly(
-            context: E,
-            snapshot: Self::Snapshot,
-            message: <Self::Ingress as IntoIngressEnvelope>::ReadOnlyIngress,
-        ) -> impl Future<Output = Result<(), Self::Error>> + Send;
+        fn on_read_only(
+            _context: E,
+            _snapshot: Self::Snapshot,
+            _message: <Self::Ingress as IntoIngressEnvelope>::ReadOnlyIngress,
+        ) -> impl Future<Output = Result<(), Self::Error>> + Send {
+            futures::future::pending()
+        }
 
         /// Handle one ingress message that may mutate actor state.
         ///
@@ -148,10 +150,12 @@ stability_scope!(ALPHA {
         /// before exiting.
         fn on_read_write(
             &mut self,
-            context: &mut E,
-            args: &mut Self::Args,
-            message: <Self::Ingress as IntoIngressEnvelope>::ReadWriteIngress,
-        ) -> impl Future<Output = Result<(), Self::Error>> + Send;
+            _context: &mut E,
+            _args: &mut Self::Args,
+            _message: <Self::Ingress as IntoIngressEnvelope>::ReadWriteIngress,
+        ) -> impl Future<Output = Result<(), Self::Error>> + Send {
+            futures::future::pending()
+        }
 
         /// Poll external per-iteration sources and map them to ingress.
         ///

actor/src/service/builder.rs

@@ -63,7 +63,7 @@ where
 /// # Behavioral Semantics
 ///
 /// - At most one event is dispatched per iteration.
-/// - Returning `Err` from [`Actor::on_readonly`] or [`Actor::on_read_write`]
+/// - Returning `Err` from [`Actor::on_read_only`] or [`Actor::on_read_write`]
 ///   is fatal: the error is logged, remaining in-flight reads are drained,
 ///   and then [`Actor::on_shutdown`] is called before the loop exits.
 /// - A lane closing (`None`) or [`Actor::on_external`] returning `None`