Struct Handle 

pub struct Handle<A> { /* private fields */ }

A clonable handle to schedule actions onto an actor of type A.

Use Handle::channel to create a (Handle<A>, mpsc::Receiver<Action<A>>) pair, then build your actor with the receiver and spawn its run loop. The handle may be cloned and used concurrently from many tasks/threads.

Implementations

impl<A> Handle<A>

where A: Send + 'static,

pub fn channel(capacity: usize) -> (Self, Receiver<Action<A>>)

Create a new actor handle and mailbox receiver with the given capacity.

Returns the (Handle<A>, mpsc::Receiver<Action<A>>) pair. Pass the receiver to your actor and spawn its run loop like this:

let (handle, rx) = Handle::<MyActor>::channel(128);
let actor = MyActor { /* ... */ rx };
tokio::spawn(async move { let _ = actor.run().await; });

pub async fn call<R, F>(&self, f: F) -> Result<R>

where F: for<'a> FnOnce(&'a mut A) -> ActorFut<'a, Result<R>> + Send + 'static, R: Send + 'static,

Schedule an action to run on the actor and await its result.

• f is a closure that receives &mut A and returns a boxed future yielding anyhow::Result<R>. Use the act! and act_ok! macros to write these concisely.
• If the actor panics while processing the action, the panic is caught and returned as an anyhow::Error with the call site location.
• If the actor task has stopped, an error is returned.

Trait Implementations

impl<A> Clone for Handle<A>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A: Debug> Debug for Handle<A>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.