Struct SendProduct 

pub struct SendProduct<L, R> {
    pub inner: L,
    pub own: R,
}

A product of independently typed send protocols.

Fields

inner: L

own: R

Implementations

impl<L, R> SendProduct<L, R>

pub const fn new(inner: L, own: R) -> SendProduct<L, R>

pub fn split(self) -> (L, R)

Trait Implementations

impl<L, R> Clone for SendProduct<L, R>

where L: Clone, R: Clone,

fn clone(&self) -> SendProduct<L, R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L, R> Debug for SendProduct<L, R>

where L: Debug, R: Debug,

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

Formats the value using the given formatter.

impl<L, R> Eq for SendProduct<L, R>

where L: Eq, R: Eq,

impl<L, R> From<(L, R)> for SendProduct<L, R>

fn from(_: (L, R)) -> SendProduct<L, R>

Converts to this type from the input type.

impl<L, R, N> ObservesCreations<N> for SendProduct<L, R>

where L: ObservesCreations<N>, R: ObservesCreations<N>, N: Copy,

fn observes_creation(&self, nonce: N) -> bool

Whether this algebra contains an ObserveCreation for nonce.

impl<L, R> PartialEq for SendProduct<L, R>

where L: PartialEq, R: PartialEq,

fn eq(&self, other: &SendProduct<L, R>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<A, R, L, Own> RouteSends<A, R> for SendProduct<L, Own>

where A: Address + Send, L: RouteSends<A, R> + Send, Own: RouteSends<A, R> + Send, R: Send,

type Error = SendProductError<<L as RouteSends<A, R>>::Error, <Own as RouteSends<A, R>>::Error>

Delivery failure.

async fn route( self, from: A, router: &mut R, ) -> Result<(), <SendProduct<L, Own> as RouteSends<A, R>>::Error>

Route every send in fold order.

impl<L, R> SendAlgebra for SendProduct<L, R>

where L: SendAlgebra, R: SendAlgebra,

fn empty() -> SendProduct<L, R>

fn append(&mut self, other: SendProduct<L, R>)

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<L, R, Input, Path> SendInput<Input, Inner<Path>> for SendProduct<L, R>

where L: SendInput<Input, Path>,

fn emit(&mut self, input: Input)

impl<L, R, Input> SendInput<Input, Own> for SendProduct<L, R>

where R: SendInput<Input, Own>,

fn emit(&mut self, input: Input)

impl<L, R> StructuralPartialEq for SendProduct<L, R>

where L: PartialEq, R: PartialEq,