Struct parser_compose::Map

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

See map().

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<In, Out, P, F, M> Parser<In> for Map<P, F>where P: Parser<In, Out = Out>, F: Fn(P::Out) -> M,

type Out = M

The type this parser outputs if successfull

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, 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 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, label: &'static str) -> Label<Self>where Self: Sized,

Returns an identical parser that uses label when reporting errors to the FailureLog

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