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", so this trait is not object safe.

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

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>

Implementors

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

type Item = T

type Next = ()

type Error = Error<E>