# 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

source

#### fn parse(&mut self, input: I) -> IResult<I, O, E>

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

## Provided Methods

source

#### 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

source

#### 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

source

#### 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

source

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

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

source

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

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

source

#### fn into<O2: From<O>, E2: From<E>>(self) -> Into<Self, O, O2, E, E2> where
Self: Sized,

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

## Trait Implementations

source

### impl<'a, I, O, E> Parser<I, O, E> for Box<dyn Parser<I, O, E> + 'a>

source

#### fn parse(&mut self, input: I) -> IResult<I, O, E>

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

source

#### 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

source

#### 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

source

#### 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

source

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

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

source

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

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

source

#### fn into<O2: From<O>, E2: From<E>>(self) -> Into<Self, O, O2, E, E2> where
Self: Sized,

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

## Implementations on Foreign Types

source

### impl<'a, I, O, E> Parser<I, O, E> for Box<dyn Parser<I, O, E> + 'a>

source

#### fn parse(&mut self, input: I) -> IResult<I, O, E>

## Implementors

source

### impl<'a, I, O1, O2, E, F: Parser<I, O1, E>, G: Fn(O1) -> H, H: Parser<I, O2, E>> Parser<I, O2, E> for FlatMap<F, G, O1>

source

### impl<'a, I, O1, O2, E, F: Parser<I, O1, E>, G: Fn(O1) -> O2> Parser<I, O2, E> for Map<F, G, O1>

source

### 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>

source

### impl<'a, I, O1, O2, E, F: Parser<I, O1, E>, G: Parser<O1, O2, E>> Parser<I, O2, E> for AndThen<F, G, O1>

source

### impl<'a, I, O, E, F> Parser<I, O, E> for F where
F: FnMut(I) -> IResult<I, O, E> + 'a,

source

### impl<'a, I: Clone, O1, O2: From<O1>, E1, E2: ParseError<I> + From<E1>, F: Parser<I, O1, E1>> Parser<I, O2, E2> for Into<F, O1, O2, E1, E2>

source

### impl<'a, I: Clone, O, E: ParseError<I>, F: Parser<I, O, E>, G: Parser<I, O, E>> Parser<I, O, E> for Or<F, G>