Struct comb::adapters::Many

pub struct Many<A: Scanner>(_, _, _);

Trait Implementations

impl<A: Scanner> Scanner for Many<A>

type Input = A::Input

type Output = Vec<A::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

impl<A: Clone + Scanner> Clone for Many<A>

fn clone(&self) -> Many<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Scanner> Debug for Many<A>

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

Formats the value using the given formatter.