Trait Pipe 

pub trait Pipe<I, O, E = NeverErr, R = I> {
    // Required method
    fn apply(&mut self, input: I) -> Result<R, O, E>;
}

Combinator trait

Required Methods

fn apply(&mut self, input: I) -> Result<R, O, E>

Produces a Result from an input

from an input I produces either:

• an output O and what remains from the input: R
• an error E

Implementations on Foreign Types

impl<I, E> Pipe<I, (), E> for ()

fn apply(&mut self, input: I) -> Result<I, (), E>

Implementors

impl<'a, I, O, E, R> Pipe<I, O, E, R> for BoxedPipe<'a, I, O, E, R>

impl<I, I2, O, E, P> Pipe<I, (), E, I2> for Skip<P, O>

where P: Pipe<I, O, E, I2>,

impl<I, O, E, E2, R, P, F> Pipe<I, O, E2, R> for MapErr<P, F, E>

where P: Pipe<I, O, E, R>, F: FnMut(FatalError<E>) -> FatalError<E2>,

impl<I, O, E, P> Pipe<I, (Option<<O as Unpack>::Output>,), E> for Opt<P, O>

where O: Unpack, I: Clone, P: Pipe<I, O, E>,

impl<I, O, E, P> Pipe<I, (Vec<<O as Unpack>::Output>,), E> for RepeatPipe<P, O>

where I: Clone, O: Unpack, P: Pipe<I, O, E> + Sized,

impl<I, O, E, R, F> Pipe<I, O, E, R> for F

where F: FnMut(I) -> Result<R, O, E>,

a pipe is implemented for all closures with the same signature

impl<I, O, E, R, I2, O2, R2, P, F> Pipe<I2, O2, E, R2> for Wrap<I, O, R, P, F>

where P: Pipe<I, O, E, R>, F: FnMut(&mut P, I2) -> Result<R2, O2, E>,

impl<I, O, E, R, O2, R2, P1, P2> Pipe<I, (), E, R2> for AndSkip<P1, P2, O, O2, R>

where P1: Pipe<I, O, E, R>, P2: Pipe<R, O2, E, R2>,

impl<I, O, E, R, O2, R2, P1, P2> Pipe<I, O2, E, R2> for AndOther<P1, P2, O, R>

where P1: Pipe<I, O, E, R>, P2: Pipe<R, O2, E, R2>,

impl<I, O, E, R, O2, R2, P1, P2> Pipe<I, O, E, R2> for AndSelf<P1, P2, R, O2>

where P1: Pipe<I, O, E, R>, P2: Pipe<R, O2, E, R2>,

impl<I, O, E, R, P> Pipe<I, <O as Unpack>::Output, E, R> for UnpackPipe<P, O>

where O: Unpack, P: Pipe<I, O, E, R>,

impl<I, O, E, R, P> Pipe<I, (E,), NotError<(R, O), E>> for Not<O, R, P>

where I: Clone, P: Pipe<I, O, E, R>,

impl<I, O, E, R, P> Pipe<I, O, E> for Peek<P, R>

where I: Clone, P: Pipe<I, O, E, R>,

impl<I, O, E, R, P, P1> Pipe<I, O, E, R> for Or<P, P1>

where P: Pipe<I, O, E, R>, P1: Pipe<I, O, E, R>, I: Clone,

impl<I, O, E, R, P: Pipe<I, O, E, R>> Pipe<I, O, E, R> for Deescalate<P>

impl<I, O, E, R, P: Pipe<I, O, E, R>> Pipe<I, O, E, R> for Escalate<P>

impl<I, O, O2, E, P1, P2> Pipe<I, <(Vec<<O as Unpack>::Output>,) as Extend<O2>>::Output, E> for NoMoreUntil<P1, P2, O, O2>

where I: Clone, O: Unpack, O2: HList, (Vec<O::Output>,): Extend<O2>, P1: Pipe<I, O, E>, P2: Pipe<I, O2, E>,

impl<I, O, O2, E, P1, P2> Pipe<I, <(Vec<<O as Unpack>::Output>,) as Extend<O2>>::Output, E> for RepeatUntil<P1, P2, O, O2>

where I: Clone, O: Unpack, O2: HList, (Vec<O::Output>,): Extend<O2>, P1: Pipe<I, O, E>, P2: Pipe<I, O2, E>,

impl<I, O, O2, E, P1, P2> Pipe<I, <(Vec<<O as Unpack>::Output>,) as Extend<O2>>::Output, E> for Until<P1, P2, O, O2>

where I: Clone, O: Unpack, O2: HList, (Vec<O::Output>,): Extend<O2>, P1: Pipe<I, O, E>, P2: Pipe<I, O2, E>,

impl<I, O, O2, E, R, F, P> Pipe<I, (O2,), E, R> for Map1<P, F, O>

where F: FunMut<O, Output = O2>, P: Pipe<I, O, E, R>, O: HList,

impl<I, O, O2, E, R, F, P> Pipe<I, O2, E, R> for Map<P, F, O>

where O: HList, F: FunMut<O, Output = O2>, P: Pipe<I, O, E, R>,

impl<I, O, O2, E, R, F, P> Pipe<I, O2, E, R> for MapF<P, F, O>

where F: FnMut(O) -> O2, P: Pipe<I, O, E, R>,

impl<I, O, O2, E, R, P, F> Pipe<I, O2, E, R> for AndThen<O, P, F>

where O: HList, P: Pipe<I, O, E, R>, F: FunMut<O, Output = Result<O2, FatalError<E>>>,

impl<I, O, O2, E, R, P, F> Pipe<I, O2, E, R> for AndThenF<O, P, F>

where O: HList, P: Pipe<I, O, E, R>, F: FnMut(O) -> Result<O2, FatalError<E>>,

impl<I, O, O2, E, R, P, P1> Pipe<I, (Option<<O2 as Unpack>::Output>,), E, R> for OrOther<O, O2, P, P1>

where O2: Unpack, P: Pipe<I, O, E, R>, P1: Pipe<I, O2, E, R>, I: Clone,

impl<I, O, O2, E, R, P, P1> Pipe<I, (Option<<O as Unpack>::Output>,), E, R> for OrSelf<O, O2, P, P1>

where O: Unpack, P: Pipe<I, O, E, R>, P1: Pipe<I, O2, E, R>, I: Clone,

impl<I, O, O2, E, R, P, P1> Pipe<I, (Either<<O as Unpack>::Output, <O2 as Unpack>::Output>,), E, R> for EitherPipe<O, O2, P, P1>

where I: Clone, O: Unpack, O2: Unpack, P: Pipe<I, O, E, R> + Sized, P1: Pipe<I, O2, E, R>,

impl<I, O, O2, E, R, P, P1> Pipe<I, (), E, R> for OrSkip<O, O2, P, P1>

where P: Pipe<I, O, E, R>, P1: Pipe<I, O2, E, R>, I: Clone,

impl<I, O, O2, E, R, R2, P, F> Pipe<I, O2, E, R2> for OkAndThen<O, R, P, F>

where P: Pipe<I, O, E, R>, F: FunMut<(R, O), Output = Result<(R2, O2), FatalError<E>>>,

impl<I, O, O2, E, R, R2, P, P1> Pipe<I, <O as Extend<O2>>::Output, E, R2> for And<P, P1, O, O2, R>

where O: Extend<O2>, O2: HList, P: Pipe<I, O, E, R>, P1: Pipe<R, O2, E, R2>,

impl<I, O, O2, E, R, R2, P, P1> Pipe<I, (Either<<O as Unpack>::Output, <O2 as Unpack>::Output>,), E, Either<R, R2>> for EitherPipeFull<O, O2, P, P1>

where I: Clone, O: Unpack, O2: Unpack, P: Pipe<I, O, E, R> + Sized, P1: Pipe<I, O2, E, R2>,

impl<I, O, O2, E, R, R2, P, P1> Pipe<I, O2, E, R2> for OkThen<O, R, P, P1>

where O: HList, P: Pipe<I, O, E, R>, P1: Pipe<(R, O), O2, E, R2>,