Struct parser_compose::Peeked

pub struct Peeked<P> { /* private fields */ }

A parser that does not consume any input regardless of its outcome. See peeked()

Trait Implementations

impl<In, Out, E, P> Parser<In, Out, E> for Peeked<P>where In: Clone, P: Parser<In, Out, E>,

fn try_parse(&self, input: In) -> Res<In, Out, E>

Recognizes a value from the input and returns the result

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

Returns a parser that maps a Parser<In, Out, E> to Parser<In, Mapped, E> by applying a function to the result of the parser if it succeeded.

fn map_err<F, M>(self, f: F) -> MapErr<Self, F, E>where Self: Sized, F: Fn(Error<E>) -> Error<M>,

Returns a parser that maps a Parser<In, Out, E> to Parser<In, Out, Mapped> by applying a function to the error reported by the parser if it failed.

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

Returns a parser that succeeds if self does. Otherwise, it’s outcome is that of next.

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

Returns a new parser that succeeds if the predicate returns true. The predicate is given the extracted value of the current parser as an argument

fn repeated<R: RepetitionArgument>(self, count: R) -> Repeat<Self, R>where Self: Sized,

Returns a parser that suceeds if it is able to repeat count times.

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

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

fn peeked(self) -> Peeked<Self>where Self: Sized,

Returns a parser that succeeds or fails as normal, but never consumes any input regardless of the outcome. This can be used to look ahead.

fn not_peeked(self) -> NotPeeked<Self, Out>where Self: Sized,

Reverse of peeked(). Returns a parse that succeeds if it was not able to recognize the input and fails if it was able to.

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

Returns a parser that is similar to map() in its behavior, except that the provided closure may fail, which affects the outcome of the parser.