Trait Parser

pub trait Parser {
    type Input: Stream;
    type Output;

    // Provided methods
    fn parse(
        &mut self,
        input: Self::Input,
    ) -> Result<(Self::Output, Self::Input), ParseError<<Self::Input as Stream>::Item>> { ... }
    fn parse_state(
        &mut self,
        input: State<Self::Input>,
    ) -> ParseResult<Self::Output, Self::Input, <Self::Input as Stream>::Item> { ... }
    fn parse_lazy(
        &mut self,
        input: State<Self::Input>,
    ) -> ParseResult<Self::Output, Self::Input, <Self::Input as Stream>::Item> { ... }
    fn add_error(
        &mut self,
        _error: &mut ParseError<<Self::Input as Stream>::Item>,
    ) { ... }
}

By implementing the Parser trait a type says that it can be used to parse an input stream into the type Output.

All methods have a default implementation but there needs to be at least an implementation of parse_state orparse_lazy. If parse_ok is implemented an implementation of add_error is also recommended to improve error reporting.

Required Associated Types

type Input: Stream

A type implementing the Stream trait which is the specific type that is parsed.

type Output

The type which is returned when the parsing is successful.

Provided Methods

fn parse( &mut self, input: Self::Input, ) -> Result<(Self::Output, Self::Input), ParseError<<Self::Input as Stream>::Item>>

Entrypoint of the parser Takes some input and tries to parse it returning a ParseResult

fn parse_state( &mut self, input: State<Self::Input>, ) -> ParseResult<Self::Output, Self::Input, <Self::Input as Stream>::Item>

Parses using the state input by calling Stream::uncons one or more times On success returns Ok((value, new_state)) on failure it returns Err(error)

fn parse_lazy( &mut self, input: State<Self::Input>, ) -> ParseResult<Self::Output, Self::Input, <Self::Input as Stream>::Item>

Specialized version of parse_state where the parser does not need to add an error to the ParseError when it does not consume any input before encountering the error. Instead the error can be added later through the add_error method

fn add_error(&mut self, _error: &mut ParseError<<Self::Input as Stream>::Item>)

Adds the first error that would normally be returned by this parser if it failed

Implementations on Foreign Types

impl<'a, I, O, P> Parser for &'a mut P

where I: Stream, P: Parser<Input = I, Output = O> + ?Sized,

type Input = I

type Output = O

fn parse_state(&mut self, input: State<I>) -> ParseResult<O, I, I::Item>

fn parse_lazy(&mut self, input: State<I>) -> ParseResult<O, I, I::Item>

fn add_error(&mut self, error: &mut ParseError<<Self::Input as Stream>::Item>)

impl<'a, I: Stream, O> Parser for dyn FnMut(State<I>) -> ParseResult<O, I, I::Item> + 'a

type Input = I

type Output = O

fn parse_state(&mut self, input: State<I>) -> ParseResult<O, I, I::Item>

impl<I, O> Parser for fn(State<I>) -> ParseResult<O, I, I::Item>

where I: Stream,

type Input = I

type Output = O

fn parse_state(&mut self, input: State<I>) -> ParseResult<O, I, I::Item>

impl<I, O, P> Parser for Box<P>

where I: Stream, P: Parser<Input = I, Output = O> + ?Sized,

type Input = I

type Output = O

fn parse_state(&mut self, input: State<I>) -> ParseResult<O, I, I::Item>

fn parse_lazy(&mut self, input: State<I>) -> ParseResult<O, I, I::Item>

fn add_error(&mut self, error: &mut ParseError<<Self::Input as Stream>::Item>)

impl<Input: Stream, A: Parser<Input = Input>, B: Parser<Input = Input>> Parser for (A, B)

type Input = Input

type Output = (<A as Parser>::Output, <B as Parser>::Output)

fn parse_lazy( &mut self, input: State<Input>, ) -> ParseResult<(A::Output, B::Output), Input, Input::Item>

fn add_error(&mut self, errors: &mut ParseError<<Self::Input as Stream>::Item>)

impl<Input: Stream, A: Parser<Input = Input>, B: Parser<Input = Input>, C: Parser<Input = Input>> Parser for (A, B, C)

type Input = Input

type Output = (<A as Parser>::Output, <B as Parser>::Output, <C as Parser>::Output)

fn parse_lazy( &mut self, input: State<Input>, ) -> ParseResult<(A::Output, B::Output, C::Output), Input, Input::Item>

fn add_error(&mut self, errors: &mut ParseError<<Self::Input as Stream>::Item>)

impl<Input: Stream, A: Parser<Input = Input>, B: Parser<Input = Input>, C: Parser<Input = Input>, D: Parser<Input = Input>> Parser for (A, B, C, D)

type Input = Input

type Output = (<A as Parser>::Output, <B as Parser>::Output, <C as Parser>::Output, <D as Parser>::Output)

fn parse_lazy( &mut self, input: State<Input>, ) -> ParseResult<(A::Output, B::Output, C::Output, D::Output), Input, Input::Item>

fn add_error(&mut self, errors: &mut ParseError<<Self::Input as Stream>::Item>)

impl<Input: Stream, A: Parser<Input = Input>, B: Parser<Input = Input>, C: Parser<Input = Input>, D: Parser<Input = Input>, E: Parser<Input = Input>> Parser for (A, B, C, D, E)

type Input = Input

type Output = (<A as Parser>::Output, <B as Parser>::Output, <C as Parser>::Output, <D as Parser>::Output, <E as Parser>::Output)

fn parse_lazy( &mut self, input: State<Input>, ) -> ParseResult<(A::Output, B::Output, C::Output, D::Output, E::Output), Input, Input::Item>

fn add_error(&mut self, errors: &mut ParseError<<Self::Input as Stream>::Item>)

impl<Input: Stream, A: Parser<Input = Input>, B: Parser<Input = Input>, C: Parser<Input = Input>, D: Parser<Input = Input>, E: Parser<Input = Input>, F: Parser<Input = Input>> Parser for (A, B, C, D, E, F)

type Input = Input

type Output = (<A as Parser>::Output, <B as Parser>::Output, <C as Parser>::Output, <D as Parser>::Output, <E as Parser>::Output, <F as Parser>::Output)

fn parse_lazy( &mut self, input: State<Input>, ) -> ParseResult<(A::Output, B::Output, C::Output, D::Output, E::Output, F::Output), Input, Input::Item>

fn add_error(&mut self, errors: &mut ParseError<<Self::Input as Stream>::Item>)

impl<Input: Stream, A: Parser<Input = Input>, B: Parser<Input = Input>, C: Parser<Input = Input>, D: Parser<Input = Input>, E: Parser<Input = Input>, F: Parser<Input = Input>, G: Parser<Input = Input>> Parser for (A, B, C, D, E, F, G)

type Input = Input

type Output = (<A as Parser>::Output, <B as Parser>::Output, <C as Parser>::Output, <D as Parser>::Output, <E as Parser>::Output, <F as Parser>::Output, <G as Parser>::Output)

fn parse_lazy( &mut self, input: State<Input>, ) -> ParseResult<(A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output), Input, Input::Item>

fn add_error(&mut self, errors: &mut ParseError<<Self::Input as Stream>::Item>)

impl<Input: Stream, A: Parser<Input = Input>, B: Parser<Input = Input>, C: Parser<Input = Input>, D: Parser<Input = Input>, E: Parser<Input = Input>, F: Parser<Input = Input>, G: Parser<Input = Input>, H: Parser<Input = Input>> Parser for (A, B, C, D, E, F, G, H)

type Input = Input

type Output = (<A as Parser>::Output, <B as Parser>::Output, <C as Parser>::Output, <D as Parser>::Output, <E as Parser>::Output, <F as Parser>::Output, <G as Parser>::Output, <H as Parser>::Output)

fn parse_lazy( &mut self, input: State<Input>, ) -> ParseResult<(A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output), Input, Input::Item>

fn add_error(&mut self, errors: &mut ParseError<<Self::Input as Stream>::Item>)

impl<Input: Stream, A: Parser<Input = Input>, B: Parser<Input = Input>, C: Parser<Input = Input>, D: Parser<Input = Input>, E: Parser<Input = Input>, F: Parser<Input = Input>, G: Parser<Input = Input>, H: Parser<Input = Input>, I: Parser<Input = Input>> Parser for (A, B, C, D, E, F, G, H, I)

type Input = Input

type Output = (<A as Parser>::Output, <B as Parser>::Output, <C as Parser>::Output, <D as Parser>::Output, <E as Parser>::Output, <F as Parser>::Output, <G as Parser>::Output, <H as Parser>::Output, <I as Parser>::Output)

fn parse_lazy( &mut self, input: State<Input>, ) -> ParseResult<(A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output), Input, Input::Item>

fn add_error(&mut self, errors: &mut ParseError<<Self::Input as Stream>::Item>)

impl<Input: Stream, A: Parser<Input = Input>, B: Parser<Input = Input>, C: Parser<Input = Input>, D: Parser<Input = Input>, E: Parser<Input = Input>, F: Parser<Input = Input>, G: Parser<Input = Input>, H: Parser<Input = Input>, I: Parser<Input = Input>, J: Parser<Input = Input>> Parser for (A, B, C, D, E, F, G, H, I, J)

type Input = Input

type Output = (<A as Parser>::Output, <B as Parser>::Output, <C as Parser>::Output, <D as Parser>::Output, <E as Parser>::Output, <F as Parser>::Output, <G as Parser>::Output, <H as Parser>::Output, <I as Parser>::Output, <J as Parser>::Output)

fn parse_lazy( &mut self, input: State<Input>, ) -> ParseResult<(A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output), Input, Input::Item>

fn add_error(&mut self, errors: &mut ParseError<<Self::Input as Stream>::Item>)

impl<Input: Stream, A: Parser<Input = Input>, B: Parser<Input = Input>, C: Parser<Input = Input>, D: Parser<Input = Input>, E: Parser<Input = Input>, F: Parser<Input = Input>, G: Parser<Input = Input>, H: Parser<Input = Input>, I: Parser<Input = Input>, J: Parser<Input = Input>, K: Parser<Input = Input>> Parser for (A, B, C, D, E, F, G, H, I, J, K)

type Input = Input

type Output = (<A as Parser>::Output, <B as Parser>::Output, <C as Parser>::Output, <D as Parser>::Output, <E as Parser>::Output, <F as Parser>::Output, <G as Parser>::Output, <H as Parser>::Output, <I as Parser>::Output, <J as Parser>::Output, <K as Parser>::Output)

fn parse_lazy( &mut self, input: State<Input>, ) -> ParseResult<(A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output), Input, Input::Item>

fn add_error(&mut self, errors: &mut ParseError<<Self::Input as Stream>::Item>)

impl<Input: Stream, A: Parser<Input = Input>, B: Parser<Input = Input>, C: Parser<Input = Input>, D: Parser<Input = Input>, E: Parser<Input = Input>, F: Parser<Input = Input>, G: Parser<Input = Input>, H: Parser<Input = Input>, I: Parser<Input = Input>, J: Parser<Input = Input>, K: Parser<Input = Input>, L: Parser<Input = Input>> Parser for (A, B, C, D, E, F, G, H, I, J, K, L)

type Input = Input

type Output = (<A as Parser>::Output, <B as Parser>::Output, <C as Parser>::Output, <D as Parser>::Output, <E as Parser>::Output, <F as Parser>::Output, <G as Parser>::Output, <H as Parser>::Output, <I as Parser>::Output, <J as Parser>::Output, <K as Parser>::Output, <L as Parser>::Output)

fn parse_lazy( &mut self, input: State<Input>, ) -> ParseResult<(A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output), Input, Input::Item>

fn add_error(&mut self, errors: &mut ParseError<<Self::Input as Stream>::Item>)

Implementors

impl<F, P> Parser for Many1<F, P>

where F: FromIterator<<P as Parser>::Output>, P: Parser,

type Input = <P as Parser>::Input

type Output = F

impl<F, P> Parser for Many<F, P>

where P: Parser, F: FromIterator<<P as Parser>::Output>,

type Input = <P as Parser>::Input

type Output = F

impl<F, P, S> Parser for SepBy<F, P, S>

where F: FromIterator<<P as Parser>::Output>, P: Parser, S: Parser<Input = <P as Parser>::Input>,

type Input = <P as Parser>::Input

type Output = F

impl<I> Parser for AlphaNum<I>

where I: Stream<Item = char>,

type Input = I

type Output = <Expected<Satisfy<I, fn(char) -> bool>> as Parser>::Output

impl<I> Parser for CrLf<I>

where I: Stream<Item = char>,

type Input = I

type Output = <Expected<With<Satisfy<I, fn(char) -> bool>, NewLine<I>>> as Parser>::Output

impl<I> Parser for Digit<I>

where I: Stream<Item = char>,

type Input = I

type Output = <Expected<Satisfy<I, fn(char) -> bool>> as Parser>::Output

impl<I> Parser for HexDigit<I>

where I: Stream<Item = char>,

type Input = I

type Output = <Expected<Satisfy<I, fn(char) -> bool>> as Parser>::Output

impl<I> Parser for Letter<I>

where I: Stream<Item = char>,

type Input = I

type Output = <Expected<Satisfy<I, fn(char) -> bool>> as Parser>::Output

impl<I> Parser for Lower<I>

where I: Stream<Item = char>,

type Input = I

type Output = <Expected<Satisfy<I, fn(char) -> bool>> as Parser>::Output

impl<I> Parser for NewLine<I>

where I: Stream<Item = char>,

type Input = I

type Output = <Expected<Satisfy<I, fn(char) -> bool>> as Parser>::Output

impl<I> Parser for OctDigit<I>

where I: Stream<Item = char>,

type Input = I

type Output = <Expected<Satisfy<I, fn(char) -> bool>> as Parser>::Output

impl<I> Parser for Space<I>

where I: Stream<Item = char>,

type Input = I

type Output = <Expected<Satisfy<I, fn(char) -> bool>> as Parser>::Output

impl<I> Parser for Spaces<I>

where I: Stream<Item = char>,

type Input = I

type Output = <Expected<SkipMany<Space<I>>> as Parser>::Output

impl<I> Parser for String<I>

where I: Stream<Item = char>,

type Input = I

type Output = &'static str

impl<I> Parser for Tab<I>

where I: Stream<Item = char>,

type Input = I

type Output = <Expected<Satisfy<I, fn(char) -> bool>> as Parser>::Output

impl<I> Parser for Upper<I>

where I: Stream<Item = char>,

type Input = I

type Output = <Expected<Satisfy<I, fn(char) -> bool>> as Parser>::Output

impl<I> Parser for Any<I>

where I: Stream,

type Input = I

type Output = <I as Stream>::Item

impl<I> Parser for Token<I>

where I: Stream, I::Item: PartialEq,

type Input = I

type Output = <I as Stream>::Item

impl<I> Parser for Unexpected<I>

where I: Stream,

type Input = I

type Output = ()

impl<I, A, B, P1, P2> Parser for And<P1, P2>

where I: Stream, P1: Parser<Input = I, Output = A>, P2: Parser<Input = I, Output = B>,

type Input = I

type Output = (A, B)

impl<I, A, B, P, F> Parser for Map<P, F>

where I: Stream, P: Parser<Input = I, Output = A>, F: FnMut(A) -> B,

type Input = I

type Output = B

impl<I, O, F> Parser for FnParser<I, F>

where I: Stream, F: FnMut(State<I>) -> ParseResult<O, I, I::Item>,

type Input = I

type Output = O

impl<I, O, P1, P2> Parser for Or<P1, P2>

where I: Stream, P1: Parser<Input = I, Output = O>, P2: Parser<Input = I, Output = O>,

type Input = I

type Output = O

impl<I, O, P> Parser for Try<P>

where I: Stream, P: Parser<Input = I, Output = O>,

type Input = I

type Output = O

impl<I, O, P, Op> Parser for Chainl1<P, Op>

where I: Stream, P: Parser<Input = I, Output = O>, Op: Parser<Input = I>, Op::Output: FnOnce(O, O) -> O,

type Input = I

type Output = O

impl<I, O, P, Op> Parser for Chainr1<P, Op>

where I: Stream, P: Parser<Input = I, Output = O>, Op: Parser<Input = I>, Op::Output: FnOnce(O, O) -> O,

type Input = I

type Output = O

impl<I, O, S, P> Parser for Choice<S, P>

where I: Stream, S: AsMut<[P]>, P: Parser<Input = I, Output = O>,

type Input = I

type Output = O

impl<I, P1, P2> Parser for Skip<P1, P2>

where I: Stream, P1: Parser<Input = I>, P2: Parser<Input = I>,

type Input = I

type Output = <P1 as Parser>::Output

impl<I, P1, P2> Parser for With<P1, P2>

where I: Stream, P1: Parser<Input = I>, P2: Parser<Input = I>,

type Input = I

type Output = <P2 as Parser>::Output

impl<I, P> Parser for Message<P>

where I: Stream, P: Parser<Input = I>,

type Input = I

type Output = <P as Parser>::Output

impl<I, P> Parser for Satisfy<I, P>

where I: Stream, P: FnMut(I::Item) -> bool,

type Input = I

type Output = <I as Stream>::Item

impl<I, T> Parser for Value<I, T>

where I: Stream, T: Clone,

type Input = I

type Output = T

impl<L, R, P> Parser for Between<L, R, P>

where L: Parser, R: Parser<Input = <L as Parser>::Input>, P: Parser<Input = <L as Parser>::Input>,

type Input = <L as Parser>::Input

type Output = <Skip<With<L, P>, R> as Parser>::Output

impl<P> Parser for Expected<P>

where P: Parser,

type Input = <P as Parser>::Input

type Output = <P as Parser>::Output

impl<P> Parser for NotFollowedBy<P>

where P: Parser,

type Input = <P as Parser>::Input

type Output = <Or<Then<Try<P>, fn(<P as Parser>::Output) -> Unexpected<<P as Parser>::Input>>, Value<<P as Parser>::Input, ()>> as Parser>::Output

impl<P> Parser for Optional<P>

where P: Parser,

type Input = <P as Parser>::Input

type Output = Option<<P as Parser>::Output>

impl<P> Parser for SkipMany1<P>

where P: Parser,

type Input = <P as Parser>::Input

type Output = <Map<Many1<Vec<()>, Map<P, fn(<P as Parser>::Output)>>, fn(Vec<()>)> as Parser>::Output

impl<P> Parser for SkipMany<P>

where P: Parser,

type Input = <P as Parser>::Input

type Output = <Map<Many<Vec<()>, Map<P, fn(<P as Parser>::Output)>>, fn(Vec<()>)> as Parser>::Output

impl<P, F, O, E> Parser for AndThen<P, F>

where P: Parser, F: FnMut(P::Output) -> Result<O, E>, E: Into<Error<<P::Input as Stream>::Item>>,

type Input = <P as Parser>::Input

type Output = O

impl<P, N, F> Parser for Then<P, F>

where F: FnMut(<P as Parser>::Output) -> N, P: Parser, N: Parser<Input = <P as Parser>::Input>,

type Input = <N as Parser>::Input

type Output = <N as Parser>::Output