Struct parser_compose::Fold

pub struct Fold<P, Operation, Init> { /* private fields */ }

See fold()

Trait Implementations

impl<P: Clone, Operation: Clone, Init: Clone> Clone for Fold<P, Operation, Init>

fn clone(&self) -> Fold<P, Operation, Init>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<In, Out, P, Operation, Init, Accum> Parser<In> for Fold<P, Operation, Init>where P: Parser<In, Out = Out>, Init: Fn() -> Accum, Operation: Fn(Accum, Out) -> Accum, In: Clone,

type Out = Accum

The type this parser outputs if successful

fn try_parse(&self, ctx: ParserContext<In>) -> Res<In, Self::Out>

Recognizes a value from the input and returns the result

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

Returns a parser that applies the the function f to its output

fn or<P>(self, next: P) -> Or<Self, P>where Self: Sized,

Returns a parser that calls the next parser if it failed to match its input.

fn when<F>(self, pred: F) -> Predicate<Self, F>where Self: Sized, F: Fn(Self::Out) -> bool,

Returns a parser that only succeeds if pred returns true when given the parser’s output

fn fold<R, Op, Init, IV>( self, count: R, op: Op, init: Init ) -> Fold<Self, Op, Init>where R: RepetitionArgument, Init: Fn() -> IV, Op: Fn(IV, Self::Out) -> IV, Self: Sized,

Returns a parser that succeeds if it is able to match its input count times.

fn skim<R>(self, count: R) -> Fold<Self, fn(_: (), _: Self::Out), fn()>where Self: Sized, R: RepetitionArgument,

Returns a parser that succeeds if it is able to match its input count times, discarding any output along the way

fn accumulate<R>( self, count: R ) -> Fold<Self, fn(_: Vec<Self::Out>, _: Self::Out) -> Vec<Self::Out>, fn() -> Vec<Self::Out>>where R: RepetitionArgument, Self: Sized,

Returns a parser that succeeds if it is able to match its input count times, accumulating output into a Vec along the way.

fn input(self) -> Input<Self>where Self: Sized,

Returns a parser that outputs the slice of the input that was recognized.

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

Returns a parser always succeeds but wraps the output in an Option. If the original parser would have failed, the parser outputs a None.

fn peek(self) -> Peek<Self>where Self: Sized,

Returns a parser that never consumes any input regardless of its outcome. It can be used to look ahead.

fn not(self) -> Not<Self>where Self: Sized,

Returns a parser that succeeds if it was not able to recognize its input and fails if it was able to. It never consumes any input

fn and_then<F, U, E>(self, f: F) -> AndThen<Self, F>where Self: Sized, F: Fn(Self::Out) -> Result<U, E>, E: Error,

Returns a parser that applies a falible function f to its output. The parser will report whatever error f fails with.

fn label(self, l: &'static str) -> Label<Self>where Self: Sized,

Returns a parser with a label that will be printed should it fail. See ErrorTree for more information.

fn err<E, F>(self, f: F) -> UserErr<Self, F>where Self: Sized, F: Fn() -> E, for<'a> E: Error + 'a,

Returns a parser that will report the given error when it fails. See ErrorTree for more information.

impl<P: Copy, Operation: Copy, Init: Copy> Copy for Fold<P, Operation, Init>