Struct nom8::combinator::And

pub struct And<F, G> { /* private fields */ }

Implementation of Parser::and

Trait Implementations

impl<'a, I, O1, O2, E, F: Parser<I, O1, E>, G: Parser<I, O2, E>> Parser<I, (O1, O2), E> for And<F, G>

fn parse(&mut self, i: I) -> IResult<I, (O1, O2), E>

A parser takes in input type, and returns a Result containing either the remaining input and the output value, or an error

fn by_ref(&mut self) -> ByRef<'_, Self>where
    Self: Sized,

Treat &mut Self as a parser

fn value<O2>(self, val: O2) -> Value<Self, O, O2>where
    Self: Sized,
    O2: Clone,

Returns the provided value if the child parser succeeds.

fn output_into<O2: From<O>>(self) -> OutputInto<Self, O, O2>where
    Self: Sized,

Convert the parser’s output to another type using std::convert::From

fn recognize(self) -> Recognize<Self, O>where
    Self: Sized,

If the child parser was successful, return the consumed input as produced value.

fn with_recognized(self) -> WithRecognized<Self, O>where
    Self: Sized,

if the child parser was successful, return the consumed input with the output as a tuple. Functions similarly to recognize except it returns the parser output as well.

fn map<G, O2>(self, g: G) -> Map<Self, G, O>where
    G: Fn(O) -> O2,
    Self: Sized,

Maps a function over the result of a parser

fn map_res<G, O2, E2>(self, g: G) -> MapRes<Self, G, O>where
    Self: Sized,
    G: FnMut(O) -> Result<O2, E2>,

Applies a function returning a Result over the result of a parser.

fn map_opt<G, O2>(self, g: G) -> MapOpt<Self, G, O>where
    Self: Sized,
    G: FnMut(O) -> Option<O2>,

Applies a function returning an Option over the result of a parser.

fn flat_map<G, H, O2>(self, g: G) -> FlatMap<Self, G, O>where
    G: FnMut(O) -> H,
    H: Parser<I, O2, E>,
    Self: Sized,

Creates a second parser from the output of the first one, then apply over the rest of the input

fn and_then<G, O2>(self, g: G) -> AndThen<Self, G, O>where
    G: Parser<O, O2, E>,
    Self: Sized,

Applies a second parser over the output of the first one

fn verify<G, O2: ?Sized>(self, second: G) -> Verify<Self, G, O2>where
    Self: Sized,
    G: Fn(&O2) -> bool,

Returns the result of the child parser if it satisfies a verification function.

fn context<C>(self, context: C) -> Context<Self, O, C>where
    Self: Sized,
    C: Clone,
    E: ContextError<I, C>,

If parsing fails, add context to the error

fn complete(self) -> Complete<Self>where
    Self: Sized,

Transforms Incomplete into Error

fn err_into<E2: From<E>>(self) -> ErrInto<Self, E, E2>where
    Self: Sized,

Convert the parser’s error to another type using std::convert::From

fn dbg_err<C>(self, context: C) -> DbgErr<Self, O, C>where
    C: Display,
    Self: Sized,

Prints a message and the input if the parser fails.

fn and<G, O2>(self, g: G) -> And<Self, G>where
    G: Parser<I, O2, E>,
    Self: Sized,

👎Deprecated since 8.0.0: Replaced with `nom8::sequence::tuple

Applies a second parser after the first one, return their results as a tuple

fn or<G>(self, g: G) -> Or<Self, G>where
    G: Parser<I, O, E>,
    Self: Sized,

👎Deprecated since 8.0.0: Replaced with `nom8::branch::alt

Applies a second parser over the input if the first one failed