Trait nom::Parser

source · [−]
pub trait Parser<I, O, E> {
    fn parse(&mut self, input: I) -> IResult<I, O, E>;

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

    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,
    { ... }

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

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

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

    fn into<O2: From<O>, E2: From<E>>(self) -> Into<Self, O, O2, E, E2>
    where
        Self: Sized,
    { ... }
}
Expand description

All nom parsers implement this trait

Required methods

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

Provided methods

Maps a function over the result of a parser

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

Applies a second parser over the output of the first one

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

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

automatically converts the parser’s output and error values to another type, as long as they implement the From trait

Implementations on Foreign Types

Implementors