Struct PreparedActor 

pub struct PreparedActor<A: Actor> { /* private fields */ }

A PreparedActor represents an actor that has been initialized and is ready to be either run in the current task or spawned into a new task.

The PreparedActor provides access to the actor’s ActorRef for interacting with the actor before it starts running. It allows for flexible execution, either by running the actor synchronously in the current task or spawning it in a separate task or thread.

Implementations

impl<A: Actor> PreparedActor<A>

pub fn new( (mailbox_tx, mailbox_rx): (MailboxSender<A>, MailboxReceiver<A>), ) -> Self

Creates a new prepared actor with a specific mailbox configuration, allowing access to its ActorRef before spawning.

This function allows you to explicitly specify a mailbox when preparing an actor. Use this when you need custom mailbox behavior or capacity.

This is typically created though Actor::prepare and Actor::prepare_with_mailbox.

pub fn actor_ref(&self) -> &ActorRef<A>

Returns a reference to the ActorRef, which can be used to send messages to the actor.

The ActorRef can be used for interaction before the actor starts processing its event loop.

Note: if you intend to configure a default reply timeout, do so before cloning the ref out, as the value is read off the clone at the time it’s made.

pub fn reply_timeout(self, duration: Duration) -> Self

Sets a default reply timeout applied to every ask request that doesn’t specify its own.

An ask whose handler doesn’t reply within this duration resolves with a timeout error instead of waiting forever. A timeout set at the call site with AskRequest::reply_timeout always takes precedence over this default. The default applies to async ask requests; the blocking variants are unaffected.

Configure this before cloning the ActorRef out (see PreparedActor::actor_ref), otherwise the clone won’t observe the default.

pub async fn run( self, args: A::Args, ) -> Result<(A, ActorStopReason), PanicError>

Runs the actor in the current context without spawning a separate task, until the actor is stopped.

This is useful when you need to run an actor synchronously in the current context, without background execution, and when the actor is expected to be short-lived.

Note that the actor’s mailbox may already contain messages before run is called. In this case, the actor will process all pending messages in the mailbox before completing.

Example

let prepared_actor = MyActor::prepare();
// Send it a message before it runs
prepared_actor.actor_ref().tell("hello!").await?;
prepared_actor.run(MyActor).await;

pub fn spawn( self, args: A::Args, ) -> JoinHandle<Result<(A, ActorStopReason), PanicError>>

Spawns the actor in a new background tokio task, returning the JoinHandle.

See Spawn::spawn for more information.

pub fn spawn_in_thread( self, args: A::Args, ) -> JoinHandle<Result<(A, ActorStopReason), PanicError>>

Spawns the actor in a new background thread, returning the JoinHandle.

See Spawn::spawn_in_thread for more information.

Trait Implementations

impl<A: Actor> Reply for PreparedActor<A>

type Ok = PreparedActor<A>

The success type in the reply.

type Error = Infallible

The error type in the reply.

type Value = PreparedActor<A>

The type sent back to the receiver.

fn to_result(self) -> Result<Self, Infallible>

Converts a reply to a Result.

fn into_any_err(self) -> Option<Box<dyn ReplyError>>

Converts the reply into a Box<any::Any + Send> if it’s an Err, otherwise None.

fn into_value(self) -> Self::Value

Converts the type to Self::Reply.

fn downcast_ok(ok: Box<dyn Any>) -> Self::Ok

Downcasts a Box<dyn Any> into the Self::Ok type.

fn downcast_err<M: 'static>(err: BoxSendError) -> SendError<M, Self::Error>

Downcasts a Box<dyn Any> into a Self::Error type.