Struct SendLayer 

pub struct SendLayer<Owned, Inner> {
    pub owned: Owned,
    pub inner: Inner,
}

Send effects introduced by one wrapper around inner send effects.

owned contains effects introduced by the current behavior layer and inner contains effects of the wrapped interaction. The structural SendsFor implementation is the composition law:

Event'   = OwnedEvent + InnerEvent
Effects' = OwnedEffects × InnerEffects

Owned return to the emitters target Event'; inner return to the emitters target InnerEvent and are therefore lifted through the same Inner injection. Established actor, child, and ancestor destinations are unaffected because they are not return to the emitters.

Fields

owned: Owned

inner: Inner

Implementations

impl<Owned, Inner> SendLayer<Owned, Inner>

pub const fn new(owned: Owned, inner: Inner) -> Self

Trait Implementations

impl<Owned: Clone, Inner: Clone> Clone for SendLayer<Owned, Inner>

fn clone(&self) -> SendLayer<Owned, Inner>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Owned: Copy, Inner: Copy> Copy for SendLayer<Owned, Inner>

impl<Owned: Debug, Inner: Debug> Debug for SendLayer<Owned, Inner>

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

Formats the value using the given formatter.

impl<Owned: Eq, Inner: Eq> Eq for SendLayer<Owned, Inner>

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

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

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

Interpret every value in this product in its defined structural order. The returned future completes each effect before beginning the next, so an asynchronous delivery can wait for bounded-mailbox capacity without reordering later effects or converting pressure into rejection.

impl<Owned: PartialEq, Inner: PartialEq> PartialEq for SendLayer<Owned, Inner>

fn eq(&self, other: &SendLayer<Owned, Inner>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<Owned: SendEffects, Inner: SendEffects> SendEffects for SendLayer<Owned, Inner>

fn empty() -> Self

fn append(&mut self, other: Self)

fn combine(self, other: Self) -> Self

fn send<Input, Path>(&mut self, input: Input)

where Self: SendInput<Input, Path>,

Append one request to its statically selected semantic lane.

fn sending<Input, Path>(input: Input) -> Self

where Self: SendInput<Input, Path>,

Build a send product containing one request in its selected lane.

impl<Input, Path, Owned, Inner> SendInput<Input, Path> for SendLayer<Owned, Inner>

where Owned: SendInput<Input, Path>,

fn emit(&mut self, input: Input)

impl<Event, OwnedEffects, InnerEffects> SendsFor<Event> for SendLayer<OwnedEffects, InnerEffects>

where Event: ComposedEvent, OwnedEffects: SendsFor<Event>, InnerEffects: SendsFor<Event::Inner>,

impl<Owned: PartialEq, Inner: PartialEq> StructuralPartialEq for SendLayer<Owned, Inner>