Struct CtxDagChain 

pub struct CtxDagChain<C, In, Out, Chain> { /* private fields */ }

Main chain builder for a context-aware DAG.

Chain implements [CtxChainCall<C, E, Out = Out>].

Implementations

impl<C, In, Out: 'static, Chain> CtxDagChain<C, In, Out, Chain>

pub fn fork(self) -> CtxDagChainFork<C, In, Out, Chain, ()>

Enter fork mode. Subsequent .arm() calls add parallel branches.

impl<C, In, Chain: CtxChainCall<C, In, Out = ()>> CtxDagChain<C, In, (), Chain>

pub fn build(self) -> CtxDag<C, In, Chain>

Finalize into a CtxDag that implements [CtxStepCall].

impl<C, In, Chain: CtxChainCall<C, In, Out = Option<()>>> CtxDagChain<C, In, Option<()>, Chain>

pub fn build(self) -> CtxDag<C, In, CtxDiscardOptionNode<Chain>>

Finalize into a CtxDag, discarding the Option<()>.

impl<Ctx, In, Out: 'static, Chain> CtxDagChain<Ctx, In, Out, Chain>

pub fn then<NewOut, Params, S>( self, f: S, registry: &Registry, ) -> CtxDagChain<Ctx, In, NewOut, CtxDagThenNode<Chain, S::Step, NewOut>>

where NewOut: 'static, S: IntoCtxStep<Ctx, &'static Out, NewOut, Params>, S::Step: for<'a> CtxStepCall<Ctx, &'a Out, Out = NewOut> + 'static,

Append a step. The step receives &Out by reference.

pub fn guard<Params, S: IntoCtxRefStep<Ctx, Out, bool, Params>>( self, f: S, registry: &Registry, ) -> CtxDagChain<Ctx, In, Option<Out>, CtxGuardNode<Chain, S::Step>>

Conditionally wrap the output in Option.

pub fn tap<Params, S: IntoCtxRefStep<Ctx, Out, (), Params>>( self, f: S, registry: &Registry, ) -> CtxDagChain<Ctx, In, Out, CtxTapNode<Chain, S::Step>>

Observe the current value without consuming or changing it.

impl<Ctx, In, T: 'static, Chain> CtxDagChain<Ctx, In, Option<T>, Chain>

pub fn map<U, Params, S>( self, f: S, registry: &Registry, ) -> CtxDagChain<Ctx, In, Option<U>, CtxDagMapOptionNode<Chain, S::Step, U>>

where U: 'static, S: IntoCtxStep<Ctx, &'static T, U, Params>, S::Step: for<'x> CtxStepCall<Ctx, &'x T, Out = U>,

Transform the inner value. Step not called on None.

pub fn and_then<U, Params, S>( self, f: S, registry: &Registry, ) -> CtxDagChain<Ctx, In, Option<U>, CtxDagAndThenOptionNode<Chain, S::Step, U>>

where U: 'static, S: IntoCtxStep<Ctx, &'static T, Option<U>, Params>, S::Step: for<'x> CtxStepCall<Ctx, &'x T, Out = Option<U>>,

Short-circuits on None. std: Option::and_then

pub fn on_none<Params, S: IntoCtxProducer<Ctx, (), Params>>( self, f: S, registry: &Registry, ) -> CtxDagChain<Ctx, In, Option<T>, CtxOnNoneNode<Chain, S::Step>>

Side effect on None.

pub fn filter<Params, S: IntoCtxRefStep<Ctx, T, bool, Params>>( self, f: S, registry: &Registry, ) -> CtxDagChain<Ctx, In, Option<T>, CtxFilterNode<Chain, S::Step>>

Keep value if predicate holds. std: Option::filter

pub fn inspect<Params, S: IntoCtxRefStep<Ctx, T, (), Params>>( self, f: S, registry: &Registry, ) -> CtxDagChain<Ctx, In, Option<T>, CtxInspectOptionNode<Chain, S::Step>>

Side effect on Some value. std: Option::inspect

pub fn ok_or<E: Clone>( self, err: E, ) -> CtxDagChain<Ctx, In, Result<T, E>, CtxOkOrNode<Chain, E>>

None becomes Err(err). std: Option::ok_or

pub fn unwrap_or( self, default: T, ) -> CtxDagChain<Ctx, In, T, CtxUnwrapOrOptionNode<Chain, T>>

where T: Clone,

Exit Option — None becomes the default value.

pub fn unwrap_or_else<Params, S: IntoCtxProducer<Ctx, T, Params>>( self, f: S, registry: &Registry, ) -> CtxDagChain<Ctx, In, T, CtxUnwrapOrElseOptionNode<Chain, S::Step>>

Exit Option — None becomes f().

impl<Ctx, In, T: 'static, Err: 'static, Chain> CtxDagChain<Ctx, In, Result<T, Err>, Chain>

pub fn map<U, Params, S>( self, f: S, registry: &Registry, ) -> CtxDagChain<Ctx, In, Result<U, Err>, CtxDagMapResultNode<Chain, S::Step, U>>

where U: 'static, S: IntoCtxStep<Ctx, &'static T, U, Params>, S::Step: for<'x> CtxStepCall<Ctx, &'x T, Out = U>,

Transform the Ok value. Step not called on Err.

pub fn and_then<U, Params, S>( self, f: S, registry: &Registry, ) -> CtxDagChain<Ctx, In, Result<U, Err>, CtxDagAndThenResultNode<Chain, S::Step, U>>

where U: 'static, S: IntoCtxStep<Ctx, &'static T, Result<U, Err>, Params>, S::Step: for<'x> CtxStepCall<Ctx, &'x T, Out = Result<U, Err>>,

Short-circuits on Err. std: Result::and_then

pub fn catch<Params, S>( self, f: S, registry: &Registry, ) -> CtxDagChain<Ctx, In, Option<T>, CtxDagCatchNode<Chain, S::Step>>

where S: IntoCtxStep<Ctx, &'static Err, (), Params>, S::Step: for<'x> CtxStepCall<Ctx, &'x Err, Out = ()>,

Handle error and transition to Option.

pub fn map_err<E2, Params, S: IntoCtxStep<Ctx, Err, E2, Params>>( self, f: S, registry: &Registry, ) -> CtxDagChain<Ctx, In, Result<T, E2>, CtxMapErrNode<Chain, S::Step>>

Transform the error. std: Result::map_err

pub fn inspect<Params, S: IntoCtxRefStep<Ctx, T, (), Params>>( self, f: S, registry: &Registry, ) -> CtxDagChain<Ctx, In, Result<T, Err>, CtxInspectResultNode<Chain, S::Step>>

Side effect on Ok value. std: Result::inspect

pub fn inspect_err<Params, S: IntoCtxRefStep<Ctx, Err, (), Params>>( self, f: S, registry: &Registry, ) -> CtxDagChain<Ctx, In, Result<T, Err>, CtxInspectErrNode<Chain, S::Step>>

Side effect on Err. std: Result::inspect_err

pub fn ok(self) -> CtxDagChain<Ctx, In, Option<T>, CtxOkNode<Chain>>

Discard error, enter Option land. std: Result::ok

pub fn unwrap_or( self, default: T, ) -> CtxDagChain<Ctx, In, T, CtxUnwrapOrResultNode<Chain, T>>

where T: Clone,

Exit Result — Err becomes the default value.