Struct AndThen 

pub struct AndThen<First, Second> { /* private fields */ }

Type-chained sequence: feed input through first, then feed the intermediate through second. The type system enforces first::Out = second::In; the error channel is bridged by Second::Err: From<First::Err> (thiserror #[from] chains supply the impls). This is the composition law of the form family — the only operator the backport lands at G2; Race/Tee/Quorum follow when a use case asks.

AndThen is itself a Pipe (and a SendPipe when both stages are), so chains nest: AndThen::new(a, AndThen::new(b, c)).

Implementations

impl<First, Second> AndThen<First, Second>

pub const fn new(first: First, second: Second) -> Self

Construct a two-stage AndThen. Nest for longer chains.

Trait Implementations

impl<First: AllocFree, Second: AllocFree> AllocFree for AndThen<First, Second>

impl<First: Clone, Second: Clone> Clone for AndThen<First, Second>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<First: Commutative, Second: Commutative> Commutative for AndThen<First, Second>

impl<First: Copy, Second: Copy> Copy for AndThen<First, Second>

impl<First: Debug, Second: Debug> Debug for AndThen<First, Second>

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

Formats the value using the given formatter.

impl<First: Deterministic, Second: Deterministic> Deterministic for AndThen<First, Second>

impl<First: DropSafe, Second: DropSafe> DropSafe for AndThen<First, Second>

impl<First: IdempotentSideEffectFree, Second: IdempotentSideEffectFree> IdempotentSideEffectFree for AndThen<First, Second>

impl<First: IsPure, Second: IsPure> IsPure for AndThen<First, Second>

impl<First: NoStd, Second: NoStd> NoStd for AndThen<First, Second>

impl<First, Second> Pipe for AndThen<First, Second>

where First: Pipe, Second: Pipe<In = First::Out>, Second::Err: From<First::Err>,

type In = <First as Pipe>::In

Input the pipe consumes.

type Out = <Second as Pipe>::Out

Output the pipe produces.

type Err = <Second as Pipe>::Err

Error the pipe can fail with. Debug + 'static; Send is added only on the cross-core SendPipe form.

fn call( &self, input: Self::In, ) -> impl Future<Output = Result<Self::Out, Self::Err>>

Apply the pipe. The returned future is NOT required to be Send.

impl<First: Reproducible, Second: Reproducible> Reproducible for AndThen<First, Second>

impl<First, Second> SendPipe for AndThen<First, Second>

where First: SendPipe, Second: SendPipe<In = First::Out>, Second::Err: From<First::Err>, First::In: Send,

type In = <First as SendPipe>::In

Input the pipe consumes.

type Out = <Second as SendPipe>::Out

Output the pipe produces.

type Err = <Second as SendPipe>::Err

Error the pipe can fail with — Send here so it can cross cores.

fn call( &self, input: Self::In, ) -> impl Future<Output = Result<Self::Out, Self::Err>> + Send

Apply the pipe. The returned future IS Send.

impl<First, Second> UnpinPipe for AndThen<First, Second>

where First: UnpinPipe, Second: UnpinPipe<In = First::Out>, Second::Err: From<First::Err>,

type In = <First as UnpinPipe>::In

Input the pipe consumes.

type Out = <Second as UnpinPipe>::Out

Output the pipe produces.

type Err = <Second as UnpinPipe>::Err

Error the pipe can fail with.

fn call( &self, input: Self::In, ) -> impl Future<Output = Result<Self::Out, Self::Err>> + Unpin

Apply the pipe. The returned future IS Unpin — pollable in place.

impl<First, Second> UnpinSendPipe for AndThen<First, Second>

where First: UnpinSendPipe, Second: UnpinSendPipe<In = First::Out>, Second::Err: From<First::Err>,

type In = <First as UnpinSendPipe>::In

Input the pipe consumes.

type Out = <Second as UnpinSendPipe>::Out

Output the pipe produces.

type Err = <Second as UnpinSendPipe>::Err

Error the pipe can fail with — Send here so it can cross cores.

fn call( &self, input: Self::In, ) -> impl Future<Output = Result<Self::Out, Self::Err>> + Send + Unpin

Apply the pipe. The returned future is Send AND Unpin.

impl<First: WithoutFilesystem, Second: WithoutFilesystem> WithoutFilesystem for AndThen<First, Second>

impl<First: WithoutNetwork, Second: WithoutNetwork> WithoutNetwork for AndThen<First, Second>

impl<First: WithoutRandom, Second: WithoutRandom> WithoutRandom for AndThen<First, Second>

impl<First: WithoutSpawn, Second: WithoutSpawn> WithoutSpawn for AndThen<First, Second>

impl<First: WithoutTime, Second: WithoutTime> WithoutTime for AndThen<First, Second>