Trait Parser 

pub trait Parser {
    type Item;
    type Next;
    type Error;

    // Required method
    fn next<R: Read>(
        self,
        reader: &mut R,
    ) -> ParseResult<Self::Item, Self::Next, Self::Error>;
}

Required Associated Types

type Item

type Next

type Error

Required Methods

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

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

where (A, B, C, D, E, F, G, H): Parser,

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

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

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

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

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

type Item = <A as Parser>::Item

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

type Error = <A as Parser>::Error

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

impl<B, C, D, E, F, G, H> Parser for ((), B, C, D, E, F, G, H)

where (B, C, D, E, F, G, H): Parser,

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

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

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

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

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

type Item = <B as Parser>::Item

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

type Error = <B as Parser>::Error

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

impl<C, D, E, F, G, H> Parser for ((), C, D, E, F, G, H)

where (C, D, E, F, G, H): Parser,

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

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

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

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

impl<C: Parser, D: Parser<Error = C::Error>, E: Parser<Error = C::Error>, F: Parser<Error = C::Error>, G: Parser<Error = C::Error>, H: Parser<Error = C::Error>> Parser for (C, D, E, F, G, H)

type Item = <C as Parser>::Item

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

type Error = <C as Parser>::Error

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

impl<D, E, F, G, H> Parser for ((), D, E, F, G, H)

where (D, E, F, G, H): Parser,

type Item = <(D, E, F, G, H) as Parser>::Item

type Next = <(D, E, F, G, H) as Parser>::Next

type Error = <(D, E, F, G, H) as Parser>::Error

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

impl<D: Parser, E: Parser<Error = D::Error>, F: Parser<Error = D::Error>, G: Parser<Error = D::Error>, H: Parser<Error = D::Error>> Parser for (D, E, F, G, H)

type Item = <D as Parser>::Item

type Next = (<D as Parser>::Next, E, F, G, H)

type Error = <D as Parser>::Error

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

impl<E, F, G, H> Parser for ((), E, F, G, H)

where (E, F, G, H): Parser,

type Item = <(E, F, G, H) as Parser>::Item

type Next = <(E, F, G, H) as Parser>::Next

type Error = <(E, F, G, H) as Parser>::Error

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

impl<E: Parser, F: Parser<Error = E::Error>, G: Parser<Error = E::Error>, H: Parser<Error = E::Error>> Parser for (E, F, G, H)

type Item = <E as Parser>::Item

type Next = (<E as Parser>::Next, F, G, H)

type Error = <E as Parser>::Error

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

impl<F, G, H> Parser for ((), F, G, H)

where (F, G, H): Parser,

type Item = <(F, G, H) as Parser>::Item

type Next = <(F, G, H) as Parser>::Next

type Error = <(F, G, H) as Parser>::Error

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

impl<F: Parser, G: Parser<Error = F::Error>, H: Parser<Error = F::Error>> Parser for (F, G, H)

type Item = <F as Parser>::Item

type Next = (<F as Parser>::Next, G, H)

type Error = <F as Parser>::Error

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

impl<G, H> Parser for ((), G, H)

where (G, H): Parser,

type Item = <(G, H) as Parser>::Item

type Next = <(G, H) as Parser>::Next

type Error = <(G, H) as Parser>::Error

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

impl<G: Parser, H: Parser<Error = G::Error>> Parser for (G, H)

type Item = <G as Parser>::Item

type Next = (<G as Parser>::Next, H)

type Error = <G as Parser>::Error

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

impl<H: Parser> Parser for (H,)

type Item = <H as Parser>::Item

type Next = (<H as Parser>::Next,)

type Error = <H as Parser>::Error

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

impl<H> Parser for ((), H)

where H: Parser,

type Item = <H as Parser>::Item

type Next = <H as Parser>::Next

type Error = <H as Parser>::Error

fn next<R: Read>( self, reader: &mut R, ) -> ParseResult<Self::Item, Self::Next, Self::Error>

Implementors

impl<T, E> Parser for JustResult<T, E>

type Item = T

type Next = ()

type Error = Error<E>