Trait wasm_reader_traits::Parser

pub trait Parser {
    type Item;
    type Next;
    type Error;
    fn next<R: Read>(
        self, 
        reader: &mut R
    ) -> ParseResult<Self::Item, Self::Next, Self::Error>;
}

Associated Types

type Item

type Next

type Error

Loading content...

Required methods

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

Loading content...

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

type Next = (A::Next, B, C, D, E, F, G, H)

type Error = A::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::Item

type Next = (B::Next, C, D, E, F, G, H)

type Error = B::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::Item

type Next = (C::Next, D, E, F, G, H)

type Error = C::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::Item

type Next = (D::Next, E, F, G, H)

type Error = D::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::Item

type Next = (E::Next, F, G, H)

type Error = E::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::Item

type Next = (F::Next, G, H)

type Error = F::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::Item

type Next = (G::Next, H)

type Error = G::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::Item

type Next = (H::Next,)

type Error = H::Error

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

Loading content...

Implementors

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

type Item = T

type Next = ()

type Error = Error<E>

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

Loading content...