Struct parser_compose::Predicate

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

A parser that only succeeds if it does not report an error and the predicate returns true. See when()

Trait Implementations

impl<In, Out, E, P, F> Parser<In, Out, E> for Predicate<P, F>where P: Parser<In, Out, E>, F: Fn(&Out) -> bool,

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

Recognizes a value from the input and returns the result

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

Returns a new parser that calls the closure if it succeeds, providing the extracted value as an argument

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

Returns a new parser which that calls the closure if it fails, providing the error as an argument

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

Returns a new parser that succeeds when either the current or the next parser succeed

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 that succeeds even if it does not not recognize the input

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

Returns a parser that succeeds or fails with inner parser, but never consumes any input regardless of the outcome

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