Trait combine::parser::choice::ChoiceParser

pub trait ChoiceParser<Input: Stream> {
    type Output;
    type PartialState: Default;

    fn parse_first(
        &mut self, 
        input: &mut Input, 
        state: &mut Self::PartialState
    ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>;
    fn parse_partial(
        &mut self, 
        input: &mut Input, 
        state: &mut Self::PartialState
    ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>;
    fn parse_mode_choice<M>(
        &mut self, 
        mode: M, 
        input: &mut Input, 
        state: &mut Self::PartialState
    ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
    where
        M: ParseMode,
        Self: Sized;
    fn add_error_choice(
        &mut self, 
        error: &mut Tracked<<Input as StreamOnce>::Error>
    );
}

ChoiceParser represents a parser which may parse one of several different choices depending on the input.

This is an internal trait used to overload the choice function.

Required Associated Types

type Output

type PartialState: Default

Required Methods

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode,
    Self: Sized, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

Implementations on Foreign Types

impl<'a, Input, P> ChoiceParser<Input> for &'a mut P where
    Input: Stream,
    P: ?Sized + ChoiceParser<Input>, 

type Output = <P as ChoiceParser<Input>>::Output

type PartialState = <P as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    A: Parser<Input, Output = Output>,
    B: Parser<Input, Output = Output>,
    C: Parser<Input, Output = Output>,
    D: Parser<Input, Output = Output>,
    E: Parser<Input, Output = Output>,
    F: Parser<Input, Output = Output>,
    G: Parser<Input, Output = Output>,
    H: Parser<Input, Output = Output>,
    I: Parser<Input, Output = Output>,
    J: Parser<Input, Output = Output>,
    K: Parser<Input, Output = Output>,
    L: Parser<Input, Output = Output>,
    M: Parser<Input, Output = Output>,
    N: Parser<Input, Output = Output>,
    O: Parser<Input, Output = Output>,
    P: Parser<Input, Output = Output>,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = A<<A as Parser<Input>>::PartialState, <B as Parser<Input>>::PartialState, <C as Parser<Input>>::PartialState, <D as Parser<Input>>::PartialState, <E as Parser<Input>>::PartialState, <F as Parser<Input>>::PartialState, <G as Parser<Input>>::PartialState, <H as Parser<Input>>::PartialState, <I as Parser<Input>>::PartialState, <J as Parser<Input>>::PartialState, <K as Parser<Input>>::PartialState, <L as Parser<Input>>::PartialState, <M as Parser<Input>>::PartialState, <N as Parser<Input>>::PartialState, <O as Parser<Input>>::PartialState, <P as Parser<Input>>::PartialState, <Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    B: Parser<Input, Output = Output>,
    C: Parser<Input, Output = Output>,
    D: Parser<Input, Output = Output>,
    E: Parser<Input, Output = Output>,
    F: Parser<Input, Output = Output>,
    G: Parser<Input, Output = Output>,
    H: Parser<Input, Output = Output>,
    I: Parser<Input, Output = Output>,
    J: Parser<Input, Output = Output>,
    K: Parser<Input, Output = Output>,
    L: Parser<Input, Output = Output>,
    M: Parser<Input, Output = Output>,
    N: Parser<Input, Output = Output>,
    O: Parser<Input, Output = Output>,
    P: Parser<Input, Output = Output>,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = B<<B as Parser<Input>>::PartialState, <C as Parser<Input>>::PartialState, <D as Parser<Input>>::PartialState, <E as Parser<Input>>::PartialState, <F as Parser<Input>>::PartialState, <G as Parser<Input>>::PartialState, <H as Parser<Input>>::PartialState, <I as Parser<Input>>::PartialState, <J as Parser<Input>>::PartialState, <K as Parser<Input>>::PartialState, <L as Parser<Input>>::PartialState, <M as Parser<Input>>::PartialState, <N as Parser<Input>>::PartialState, <O as Parser<Input>>::PartialState, <P as Parser<Input>>::PartialState, <Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    C: Parser<Input, Output = Output>,
    D: Parser<Input, Output = Output>,
    E: Parser<Input, Output = Output>,
    F: Parser<Input, Output = Output>,
    G: Parser<Input, Output = Output>,
    H: Parser<Input, Output = Output>,
    I: Parser<Input, Output = Output>,
    J: Parser<Input, Output = Output>,
    K: Parser<Input, Output = Output>,
    L: Parser<Input, Output = Output>,
    M: Parser<Input, Output = Output>,
    N: Parser<Input, Output = Output>,
    O: Parser<Input, Output = Output>,
    P: Parser<Input, Output = Output>,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = C<<C as Parser<Input>>::PartialState, <D as Parser<Input>>::PartialState, <E as Parser<Input>>::PartialState, <F as Parser<Input>>::PartialState, <G as Parser<Input>>::PartialState, <H as Parser<Input>>::PartialState, <I as Parser<Input>>::PartialState, <J as Parser<Input>>::PartialState, <K as Parser<Input>>::PartialState, <L as Parser<Input>>::PartialState, <M as Parser<Input>>::PartialState, <N as Parser<Input>>::PartialState, <O as Parser<Input>>::PartialState, <P as Parser<Input>>::PartialState, <Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    D: Parser<Input, Output = Output>,
    E: Parser<Input, Output = Output>,
    F: Parser<Input, Output = Output>,
    G: Parser<Input, Output = Output>,
    H: Parser<Input, Output = Output>,
    I: Parser<Input, Output = Output>,
    J: Parser<Input, Output = Output>,
    K: Parser<Input, Output = Output>,
    L: Parser<Input, Output = Output>,
    M: Parser<Input, Output = Output>,
    N: Parser<Input, Output = Output>,
    O: Parser<Input, Output = Output>,
    P: Parser<Input, Output = Output>,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = D<<D as Parser<Input>>::PartialState, <E as Parser<Input>>::PartialState, <F as Parser<Input>>::PartialState, <G as Parser<Input>>::PartialState, <H as Parser<Input>>::PartialState, <I as Parser<Input>>::PartialState, <J as Parser<Input>>::PartialState, <K as Parser<Input>>::PartialState, <L as Parser<Input>>::PartialState, <M as Parser<Input>>::PartialState, <N as Parser<Input>>::PartialState, <O as Parser<Input>>::PartialState, <P as Parser<Input>>::PartialState, <Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    E: Parser<Input, Output = Output>,
    F: Parser<Input, Output = Output>,
    G: Parser<Input, Output = Output>,
    H: Parser<Input, Output = Output>,
    I: Parser<Input, Output = Output>,
    J: Parser<Input, Output = Output>,
    K: Parser<Input, Output = Output>,
    L: Parser<Input, Output = Output>,
    M: Parser<Input, Output = Output>,
    N: Parser<Input, Output = Output>,
    O: Parser<Input, Output = Output>,
    P: Parser<Input, Output = Output>,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = E<<E as Parser<Input>>::PartialState, <F as Parser<Input>>::PartialState, <G as Parser<Input>>::PartialState, <H as Parser<Input>>::PartialState, <I as Parser<Input>>::PartialState, <J as Parser<Input>>::PartialState, <K as Parser<Input>>::PartialState, <L as Parser<Input>>::PartialState, <M as Parser<Input>>::PartialState, <N as Parser<Input>>::PartialState, <O as Parser<Input>>::PartialState, <P as Parser<Input>>::PartialState, <Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    F: Parser<Input, Output = Output>,
    G: Parser<Input, Output = Output>,
    H: Parser<Input, Output = Output>,
    I: Parser<Input, Output = Output>,
    J: Parser<Input, Output = Output>,
    K: Parser<Input, Output = Output>,
    L: Parser<Input, Output = Output>,
    M: Parser<Input, Output = Output>,
    N: Parser<Input, Output = Output>,
    O: Parser<Input, Output = Output>,
    P: Parser<Input, Output = Output>,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = F<<F as Parser<Input>>::PartialState, <G as Parser<Input>>::PartialState, <H as Parser<Input>>::PartialState, <I as Parser<Input>>::PartialState, <J as Parser<Input>>::PartialState, <K as Parser<Input>>::PartialState, <L as Parser<Input>>::PartialState, <M as Parser<Input>>::PartialState, <N as Parser<Input>>::PartialState, <O as Parser<Input>>::PartialState, <P as Parser<Input>>::PartialState, <Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    G: Parser<Input, Output = Output>,
    H: Parser<Input, Output = Output>,
    I: Parser<Input, Output = Output>,
    J: Parser<Input, Output = Output>,
    K: Parser<Input, Output = Output>,
    L: Parser<Input, Output = Output>,
    M: Parser<Input, Output = Output>,
    N: Parser<Input, Output = Output>,
    O: Parser<Input, Output = Output>,
    P: Parser<Input, Output = Output>,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = G<<G as Parser<Input>>::PartialState, <H as Parser<Input>>::PartialState, <I as Parser<Input>>::PartialState, <J as Parser<Input>>::PartialState, <K as Parser<Input>>::PartialState, <L as Parser<Input>>::PartialState, <M as Parser<Input>>::PartialState, <N as Parser<Input>>::PartialState, <O as Parser<Input>>::PartialState, <P as Parser<Input>>::PartialState, <Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    H: Parser<Input, Output = Output>,
    I: Parser<Input, Output = Output>,
    J: Parser<Input, Output = Output>,
    K: Parser<Input, Output = Output>,
    L: Parser<Input, Output = Output>,
    M: Parser<Input, Output = Output>,
    N: Parser<Input, Output = Output>,
    O: Parser<Input, Output = Output>,
    P: Parser<Input, Output = Output>,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = H<<H as Parser<Input>>::PartialState, <I as Parser<Input>>::PartialState, <J as Parser<Input>>::PartialState, <K as Parser<Input>>::PartialState, <L as Parser<Input>>::PartialState, <M as Parser<Input>>::PartialState, <N as Parser<Input>>::PartialState, <O as Parser<Input>>::PartialState, <P as Parser<Input>>::PartialState, <Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    I: Parser<Input, Output = Output>,
    J: Parser<Input, Output = Output>,
    K: Parser<Input, Output = Output>,
    L: Parser<Input, Output = Output>,
    M: Parser<Input, Output = Output>,
    N: Parser<Input, Output = Output>,
    O: Parser<Input, Output = Output>,
    P: Parser<Input, Output = Output>,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = I<<I as Parser<Input>>::PartialState, <J as Parser<Input>>::PartialState, <K as Parser<Input>>::PartialState, <L as Parser<Input>>::PartialState, <M as Parser<Input>>::PartialState, <N as Parser<Input>>::PartialState, <O as Parser<Input>>::PartialState, <P as Parser<Input>>::PartialState, <Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    J: Parser<Input, Output = Output>,
    K: Parser<Input, Output = Output>,
    L: Parser<Input, Output = Output>,
    M: Parser<Input, Output = Output>,
    N: Parser<Input, Output = Output>,
    O: Parser<Input, Output = Output>,
    P: Parser<Input, Output = Output>,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = J<<J as Parser<Input>>::PartialState, <K as Parser<Input>>::PartialState, <L as Parser<Input>>::PartialState, <M as Parser<Input>>::PartialState, <N as Parser<Input>>::PartialState, <O as Parser<Input>>::PartialState, <P as Parser<Input>>::PartialState, <Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    K: Parser<Input, Output = Output>,
    L: Parser<Input, Output = Output>,
    M: Parser<Input, Output = Output>,
    N: Parser<Input, Output = Output>,
    O: Parser<Input, Output = Output>,
    P: Parser<Input, Output = Output>,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = K<<K as Parser<Input>>::PartialState, <L as Parser<Input>>::PartialState, <M as Parser<Input>>::PartialState, <N as Parser<Input>>::PartialState, <O as Parser<Input>>::PartialState, <P as Parser<Input>>::PartialState, <Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    L: Parser<Input, Output = Output>,
    M: Parser<Input, Output = Output>,
    N: Parser<Input, Output = Output>,
    O: Parser<Input, Output = Output>,
    P: Parser<Input, Output = Output>,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = L<<L as Parser<Input>>::PartialState, <M as Parser<Input>>::PartialState, <N as Parser<Input>>::PartialState, <O as Parser<Input>>::PartialState, <P as Parser<Input>>::PartialState, <Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    M: Parser<Input, Output = Output>,
    N: Parser<Input, Output = Output>,
    O: Parser<Input, Output = Output>,
    P: Parser<Input, Output = Output>,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = M<<M as Parser<Input>>::PartialState, <N as Parser<Input>>::PartialState, <O as Parser<Input>>::PartialState, <P as Parser<Input>>::PartialState, <Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (N, O, P, Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    N: Parser<Input, Output = Output>,
    O: Parser<Input, Output = Output>,
    P: Parser<Input, Output = Output>,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = N<<N as Parser<Input>>::PartialState, <O as Parser<Input>>::PartialState, <P as Parser<Input>>::PartialState, <Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (O, P, Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    O: Parser<Input, Output = Output>,
    P: Parser<Input, Output = Output>,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = O<<O as Parser<Input>>::PartialState, <P as Parser<Input>>::PartialState, <Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (P, Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    P: Parser<Input, Output = Output>,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = P<<P as Parser<Input>>::PartialState, <Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (Q, R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    Q: Parser<Input, Output = Output>,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = Q<<Q as Parser<Input>>::PartialState, <R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (R, S, T, U, V, X, Y, Z) where
    Input: Stream,
    R: Parser<Input, Output = Output>,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = R<<R as Parser<Input>>::PartialState, <S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (S, T, U, V, X, Y, Z) where
    Input: Stream,
    S: Parser<Input, Output = Output>,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = S<<S as Parser<Input>>::PartialState, <T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, T, U, V, X, Y, Z> ChoiceParser<Input> for (T, U, V, X, Y, Z) where
    Input: Stream,
    T: Parser<Input, Output = Output>,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = T<<T as Parser<Input>>::PartialState, <U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, U, V, X, Y, Z> ChoiceParser<Input> for (U, V, X, Y, Z) where
    Input: Stream,
    U: Parser<Input, Output = Output>,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = U<<U as Parser<Input>>::PartialState, <V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, V, X, Y, Z> ChoiceParser<Input> for (V, X, Y, Z) where
    Input: Stream,
    V: Parser<Input, Output = Output>,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = V<<V as Parser<Input>>::PartialState, <X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, X, Y, Z> ChoiceParser<Input> for (X, Y, Z) where
    Input: Stream,
    X: Parser<Input, Output = Output>,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = X<<X as Parser<Input>>::PartialState, <Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, Y, Z> ChoiceParser<Input> for (Y, Z) where
    Input: Stream,
    Y: Parser<Input, Output = Output>,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = Y<<Y as Parser<Input>>::PartialState, <Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, Output, Z> ChoiceParser<Input> for (Z,) where
    Input: Stream,
    Z: Parser<Input, Output = Output>, 

type Output = Output

type PartialState = Z<<Z as Parser<Input>>::PartialState>

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<Mode>(
    &mut self,
    mode: Mode,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    Mode: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 0] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 1] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 2] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 3] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 4] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 5] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 6] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 7] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 8] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 9] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 10] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 11] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 12] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 13] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 14] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 15] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 16] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 17] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 18] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 19] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 20] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 21] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 22] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 23] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 24] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 25] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 26] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 27] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 28] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 29] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 30] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 31] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, P> ChoiceParser<Input> for [P; 32] where
    Input: Stream,
    P: Parser<Input>, 

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

type PartialState = <[P] as ChoiceParser<Input>>::PartialState

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>

fn parse_mode_choice<M>(
    &mut self,
    mode: M,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

impl<Input, O, P> ChoiceParser<Input> for [P] where
    Input: Stream,
    P: Parser<Input, Output = O>, 

type Output = O

type PartialState = (usize, <P as Parser<Input>>::PartialState)

fn parse_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_first(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

fn parse_mode_choice<M>(
    &mut self,
    _mode: M,
    _input: &mut Input,
    _state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
    M: ParseMode, 

fn add_error_choice(
    &mut self,
    error: &mut Tracked<<Input as StreamOnce>::Error>
)

Implementors