Struct Then 

pub struct Then<A, B> { /* private fields */ }

Two stages run back to back — the output of Then is the composition of its parts.

Then<A, B> is itself a Stage: it feeds an input through A, then feeds A’s output through B, and its own Input/Output are A::Input and B::Output. It is the node Pipeline::then builds, and you rarely name it directly — a three-stage pipeline has type Pipeline<Then<Then<A, B>, C>>, assembled for you by chaining .then(...). It is pub only because it appears in those inferred types.

Composition is monomorphized: dispatch to each stage is a direct, inlinable call with no boxing and no virtual dispatch, so a pipeline of any length is as cheap as calling the stages by hand.

Trait Implementations

impl<A: Clone, B: Clone> Clone for Then<A, B>

fn clone(&self) -> Then<A, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug, B: Debug> Debug for Then<A, B>

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

Formats the value using the given formatter.

impl<C, A, B> Stage<C> for Then<A, B>

where A: Stage<C>, B: Stage<C, Input = A::Output>,

fn name(&self) -> &'static str

The name of the final stage in the composition — the stage whose output the pipeline ultimately produces.

type Input = <A as Stage<C>>::Input

The artifact this stage consumes.

type Output = <B as Stage<C>>::Output

The artifact this stage produces.

fn run( &mut self, input: Self::Input, session: &mut Session<C>, ) -> Result<Self::Output, DriverError>

Run the stage: consume input, use the Session as needed, and produce the output.