Trait InterpretSends 

pub trait InterpretSends<Interpreter, RootEvent, Path>: SendSettlements + Send {
    // Required method
    fn interpret(
        self,
        interpreter: &mut Interpreter,
    ) -> impl Future<Output = Interpretation<Self::Settlements>> + Send;
}

Static interpretation of one complete sends value at an absolute event path.

Implementations are monomorphized over Interpreter; there is no erased envelope, runtime lane lookup, or downcast. RootEvent is the event type ultimately enqueued for the actor and Path is the current send owner’s absolute position in it. Lawful rejection and blocking continue to later independent items. Corruption stops interpretation but retains the exact fault item and every untouched suffix value in the settlement shape.

Required Methods

fn interpret( self, interpreter: &mut Interpreter, ) -> impl Future<Output = Interpretation<Self::Settlements>> + Send

Interpret every value in this product in its declared stable order.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<Interpreter, RootEvent, Path, Child, Source, Input, Occurrence> InterpretSends<Interpreter, RootEvent, Path> for Vec<ChildInput<Child, Source, Input, Occurrence>>

where Interpreter: InterpretItem<ChildInput<Child, Source, Input, Occurrence>, RootEvent, Path>, Child: Behavior, Child::Event: ChildInputIngress<Source, Input>, ChildInput<Child, Source, Input, Occurrence>: ActionItem,

fn interpret( self, interpreter: &mut Interpreter, ) -> impl Future<Output = Interpretation<Self::Settlements>> + Send

impl<Interpreter, RootEvent, Path, P, Occurrence> InterpretSends<Interpreter, RootEvent, Path> for Vec<ChildDelivery<P, Occurrence>>

where Interpreter: InterpretItem<ChildDelivery<P, Occurrence>, RootEvent, Path>, P: Protocol, ChildDelivery<P, Occurrence>: ActionItem,

fn interpret( self, interpreter: &mut Interpreter, ) -> impl Future<Output = Interpretation<Self::Settlements>> + Send

impl<Interpreter, RootEvent, Path, P> InterpretSends<Interpreter, RootEvent, Path> for Vec<Delivery<P>>

where Interpreter: InterpretItem<Delivery<P>, RootEvent, Path>, P: Protocol, Delivery<P>: ActionItem,

fn interpret( self, interpreter: &mut Interpreter, ) -> impl Future<Output = Interpretation<Self::Settlements>> + Send

impl<Interpreter, RootEvent, Path, P> InterpretSends<Interpreter, RootEvent, Path> for Vec<EstablishedDelivery<P>>

where Interpreter: InterpretItem<EstablishedDelivery<P>, RootEvent, Path>, P: Protocol, P::Addr: EndpointAddress, EstablishedDelivery<P>: ActionItem,

fn interpret( self, interpreter: &mut Interpreter, ) -> impl Future<Output = Interpretation<Self::Settlements>> + Send

impl<Interpreter, RootEvent, Path> InterpretSends<Interpreter, RootEvent, Path> for Vec<Never>

fn interpret( self, _: &mut Interpreter, ) -> impl Future<Output = Interpretation<Self::Settlements>> + Send

Implementors

impl<Interpreter, RootEvent, Path, Item> InterpretSends<Interpreter, RootEvent, Path> for SourceActions<Item>

where Interpreter: InterpretItem<Item, RootEvent, Path>, Item: SourceAction,

impl<Interpreter, RootEvent, Path, Owned, Inner> InterpretSends<Interpreter, RootEvent, Path> for SendLayer<Owned, Inner>

where Interpreter: Send, Owned: InterpretSends<Interpreter, RootEvent, Path> + Send, Inner: InterpretSends<Interpreter, RootEvent, Inside<Path>> + Send,

impl<Interpreter, RootEvent, Path, Request> InterpretSends<Interpreter, RootEvent, Path> for InterpreterRequests<Request>

where Interpreter: InterpretItem<Request, RootEvent, Path>, Request: ActionItem,

impl<Interpreter, RootEvent, Path> InterpretSends<Interpreter, RootEvent, Path> for NoSends