Struct TellRequest 

pub struct TellRequest<'a, A, M, Tm>
where
    A: Actor + Message<M>,
    M: Send + 'static,
{ /* private fields */ }

A request to send a message to an actor without any reply.

This can be thought of as “fire and forget”.

Implementations

impl<'a, A, M, Tm> TellRequest<'a, A, M, Tm>

where A: Actor + Message<M>, M: Send + 'static,

pub fn mailbox_timeout( self, duration: Duration, ) -> TellRequest<'a, A, M, WithRequestTimeout>

Sets the timeout for waiting for the actors mailbox to have capacity.

pub async fn send(self) -> Result<(), SendError<M>>

where Tm: Into<Option<Duration>>,

Sends the message.

pub fn send_after( self, duration: Duration, ) -> JoinHandle<Result<(), SendError<M>>>

where Tm: Into<Option<Duration>>,

Sends a message to the actor after a delay.

Returns a JoinHandle that can be used to cancel the scheduled send via JoinHandle::abort. The handle can safely be ignored for fire-and-forget usage.

Awaiting the handle will block until the delay has elapsed and the message has been sent; this is rarely what you want.

impl<A, M> TellRequest<'_, A, M, WithoutRequestTimeout>

where A: Actor + Message<M>, M: Send + 'static,

pub fn try_send(self) -> Result<(), SendError<M>>

Tries to send the message without waiting for mailbox capacity.

pub fn blocking_send(self) -> Result<(), SendError<M>>

Sends the message in a blocking context.

Trait Implementations

impl<'a, A, M, Tm> IntoFuture for TellRequest<'a, A, M, Tm>

where A: Actor + Message<M>, M: Send + 'static, Tm: Into<Option<Duration>> + Send + 'static,

type Output = Result<(), SendError<M>>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <TellRequest<'a, A, M, Tm> as IntoFuture>::Output> + Send + 'a>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.