Enum comb::adapters::Either

pub enum Either<L, R> where
    L: Scanner,
    R: Scanner<Input = L::Input, Output = L::Output>,  {
    Left(L),
    Right(R),
}

Left and Right kinds for an Either<L,R> type. This acts as an combinator

Variants

Left(L)Right(R)

Trait Implementations

impl<L, R> Scanner for Either<L, R> where
    L: Scanner,
    R: Scanner<Input = L::Input, Output = L::Output>, 

type Input = L::Input

type Output = L::Output

fn scan(
    &self,
    stream: &mut Stream<Self::Input>
) -> Result<Self::Output, Self::Input>

fn map<T, F>(self, f: F) -> Map<T, Self, F> where
    Self: Sized,
    F: Fn(Self::Output) -> T, 

Maps a function over the sequence

fn or<T>(self, x: T) -> Or<Self, T> where
    Self: Sized,
    T: Scanner<Input = Self::Input, Output = Self::Output>, 

Produces an or squence with the current and next combinator

fn and<T>(self, x: T) -> And<Self, T> where
    Self: Sized,
    T: Scanner<Input = Self::Input>, 

Produces an and sequence with the current and next combinator

fn skip<T>(self, x: T) -> Skip<Self, T> where
    Self: Sized,
    T: Scanner<Input = Self::Input>, 

Skips the next element if it matches the type

fn optional(self) -> Optional<Self> where
    Self: Sized, 

Produces a sequence where this element is optional

fn then<B, F>(self, f: F) -> Then<Self, F, B> where
    Self: Sized,
    F: Fn(Self::Output) -> B,
    B: Scanner<Input = Self::Input>, 

When a successful production has happened, run a function producing a new sequence

fn many(self) -> Many<Self> where
    Self: Sized, 

Repeat the previous combinator until an error is produced

fn many1(self) -> Many<Self> where
    Self: Sized, 

Repeat the previous combinator at least once until an error is produced

fn many_n(self, n: usize) -> Many<Self> where
    Self: Sized, 

Repeat the previous combinator at least n times until an error is produced

fn with<T>(self, x: T) -> With<Self, T> where
    Self: Sized,
    T: Scanner<Input = Self::Input>, 

Chains two combinators together

fn value<T: Clone>(self, x: T) -> With<Self, Value<T, Self::Input>> where
    Self: Sized, 

Produces a value from this sequence

fn message(self, msg: Expected<Self::Input>) -> Message<Self> where
    Self: Sized,
    Self::Input: Clone, 

Produces an error message at this point in the sequence

fn attempt(self) -> Attempt<Self> where
    Self: Sized, 

Try to do the combinator, otherwise rollback to the last successful one