Struct parser_compose::Or

pub struct Or<P1, P2> { /* private fields */ }

A parser that succeeds if at least one inner parser succeeds. See or()

Trait Implementations

impl<In, Out, P1, P2> Parser<In, Out> for Or<P1, P2>where P1: Parser<In, Out>, P2: Parser<In, Out>, In: Clone,

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

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> to Parser<In, Mapped> by applying a function to the result of the parser if it succeeded.

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. It never consumes any input.

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

Returns a parser that is similar to map() in its behavior, except that the provided closure may fail. The parser reports whatevere error the closure fails with.

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

Returns an identical parser, but with a label. Labels are used when reporting errors. See ErrorTree for more information.

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

Returns an identical parser that will report the given error when it fails. See ErrorTree for more information on abount error handling