Struct parser_compose::AndThen

pub struct AndThen<P, F> { /* private fields */ }

See and_then()

Trait Implementations

impl<P: Clone, F: Clone> Clone for AndThen<P, F>

fn clone(&self) -> AndThen<P, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<In, Out, E, P, F, U> Parser<In> for AndThen<P, F>

where P: Parser<In, Out = Out>, F: Fn(P::Out) -> Result<U, E>,

type Out = U

The type this parser outputs if successfull

fn try_parse(&self, input: In) -> Option<(Self::Out, In)>

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 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 fails to match its input.

fn when<F>(self, predicate: 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 repeats<R>( self, count: R ) -> Fold<Self, RepeatsOperation<Self::Out>, RepeatsInit>

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, AccumulateOperation<Self::Out>, AccumulateInit<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 Some(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>,

Returns a parser that applies a falible function f to its output. The parser will return None if f fails.

impl<P: Copy, F: Copy> Copy for AndThen<P, F>