Trait Parser

pub trait Parser<Input> {
    type Output;
    type Error: ParseError<Input>;

    // Required method
    fn process<OM: OutputMode>(
        &mut self,
        input: Input,
    ) -> PResult<OM, Input, Self::Output, Self::Error>;

    // Provided methods
    fn parse(
        &mut self,
        input: Input,
    ) -> IResult<Input, Self::Output, Self::Error> { ... }
    fn parse_complete(
        &mut self,
        input: Input,
    ) -> IResult<Input, Self::Output, Self::Error> { ... }
    fn map<G, O2>(self, g: G) -> Map<Self, G>
       where G: FnMut(Self::Output) -> O2,
             Self: Sized { ... }
    fn map_res<G, O2, E2>(self, g: G) -> MapRes<Self, G>
       where G: FnMut(Self::Output) -> Result<O2, E2>,
             Self::Error: FromExternalError<Input, E2>,
             Self: Sized { ... }
    fn map_opt<G, O2>(self, g: G) -> MapOpt<Self, G>
       where G: FnMut(Self::Output) -> Option<O2>,
             Self: Sized { ... }
    fn flat_map<G, H>(self, g: G) -> FlatMap<Self, G>
       where G: FnMut(Self::Output) -> H,
             H: Parser<Input, Error = Self::Error>,
             Self: Sized { ... }
    fn and_then<G>(self, g: G) -> AndThen<Self, G>
       where G: Parser<Self::Output, Error = Self::Error>,
             Self: Sized { ... }
    fn and<G, O2>(self, g: G) -> And<Self, G>
       where G: Parser<Input, Output = O2, Error = Self::Error>,
             Self: Sized { ... }
    fn or<G>(self, g: G) -> Or<Self, G>
       where G: Parser<Input, Output = Self::Output, Error = Self::Error>,
             Self: Sized { ... }
    fn into<O2: From<Self::Output>, E2: From<Self::Error>>(
        self,
    ) -> Into<Self, O2, E2>
       where Self: Sized { ... }
}

All nom parsers implement this trait

Required Associated Types

type Output

Type of the produced value

type Error: ParseError<Input>

Error type of this parser

Required Methods

fn process<OM: OutputMode>( &mut self, input: Input, ) -> PResult<OM, Input, Self::Output, Self::Error>

A parser takes in input type, and returns a Result containing either the remaining input and the output value, or an error

Provided Methods

fn parse(&mut self, input: Input) -> IResult<Input, Self::Output, Self::Error>

A parser takes in input type, and returns a Result containing either the remaining input and the output value, or an error

fn parse_complete( &mut self, input: Input, ) -> IResult<Input, Self::Output, Self::Error>

A parser takes in input type, and returns a Result containing either the remaining input and the output value, or an error

fn map<G, O2>(self, g: G) -> Map<Self, G>

where G: FnMut(Self::Output) -> O2, Self: Sized,

Maps a function over the result of a parser

fn map_res<G, O2, E2>(self, g: G) -> MapRes<Self, G>

where G: FnMut(Self::Output) -> Result<O2, E2>, Self::Error: FromExternalError<Input, E2>, Self: Sized,

Applies a function returning a Result over the result of a parser.

fn map_opt<G, O2>(self, g: G) -> MapOpt<Self, G>

where G: FnMut(Self::Output) -> Option<O2>, Self: Sized,

Applies a function returning an Option over the result of a parser.

fn flat_map<G, H>(self, g: G) -> FlatMap<Self, G>

where G: FnMut(Self::Output) -> H, H: Parser<Input, Error = Self::Error>, Self: Sized,

Creates a second parser from the output of the first one, then apply over the rest of the input

fn and_then<G>(self, g: G) -> AndThen<Self, G>

where G: Parser<Self::Output, Error = Self::Error>, Self: Sized,

Applies a second parser over the output of the first one

fn and<G, O2>(self, g: G) -> And<Self, G>

where G: Parser<Input, Output = O2, Error = Self::Error>, Self: Sized,

Applies a second parser after the first one, return their results as a tuple

fn or<G>(self, g: G) -> Or<Self, G>

where G: Parser<Input, Output = Self::Output, Error = Self::Error>, Self: Sized,

Applies a second parser over the input if the first one failed

fn into<O2: From<Self::Output>, E2: From<Self::Error>>( self, ) -> Into<Self, O2, E2>

where Self: Sized,

automatically converts the parser’s output and error values to another type, as long as they implement the From trait

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<I, O1, E: ParseError<I>, P1> Parser<I> for (P1,)

where P1: Parser<I, Output = O1, Error = E>,

type Output = (O1,)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, E: ParseError<I>, P1, P2> Parser<I> for (P1, P2)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>,

type Output = (O1, O2)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, E: ParseError<I>, P1, P2, P3> Parser<I> for (P1, P2, P3)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>,

type Output = (O1, O2, O3)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, E: ParseError<I>, P1, P2, P3, P4> Parser<I> for (P1, P2, P3, P4)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>,

type Output = (O1, O2, O3, O4)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, E: ParseError<I>, P1, P2, P3, P4, P5> Parser<I> for (P1, P2, P3, P4, P5)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>,

type Output = (O1, O2, O3, O4, O5)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, O6, E: ParseError<I>, P1, P2, P3, P4, P5, P6> Parser<I> for (P1, P2, P3, P4, P5, P6)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>, P6: Parser<I, Output = O6, Error = E>,

type Output = (O1, O2, O3, O4, O5, O6)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, O6, O7, E: ParseError<I>, P1, P2, P3, P4, P5, P6, P7> Parser<I> for (P1, P2, P3, P4, P5, P6, P7)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>, P6: Parser<I, Output = O6, Error = E>, P7: Parser<I, Output = O7, Error = E>,

type Output = (O1, O2, O3, O4, O5, O6, O7)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, E: ParseError<I>, P1, P2, P3, P4, P5, P6, P7, P8> Parser<I> for (P1, P2, P3, P4, P5, P6, P7, P8)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>, P6: Parser<I, Output = O6, Error = E>, P7: Parser<I, Output = O7, Error = E>, P8: Parser<I, Output = O8, Error = E>,

type Output = (O1, O2, O3, O4, O5, O6, O7, O8)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, E: ParseError<I>, P1, P2, P3, P4, P5, P6, P7, P8, P9> Parser<I> for (P1, P2, P3, P4, P5, P6, P7, P8, P9)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>, P6: Parser<I, Output = O6, Error = E>, P7: Parser<I, Output = O7, Error = E>, P8: Parser<I, Output = O8, Error = E>, P9: Parser<I, Output = O9, Error = E>,

type Output = (O1, O2, O3, O4, O5, O6, O7, O8, O9)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, E: ParseError<I>, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> Parser<I> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>, P6: Parser<I, Output = O6, Error = E>, P7: Parser<I, Output = O7, Error = E>, P8: Parser<I, Output = O8, Error = E>, P9: Parser<I, Output = O9, Error = E>, P10: Parser<I, Output = O10, Error = E>,

type Output = (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, E: ParseError<I>, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> Parser<I> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>, P6: Parser<I, Output = O6, Error = E>, P7: Parser<I, Output = O7, Error = E>, P8: Parser<I, Output = O8, Error = E>, P9: Parser<I, Output = O9, Error = E>, P10: Parser<I, Output = O10, Error = E>, P11: Parser<I, Output = O11, Error = E>,

type Output = (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, E: ParseError<I>, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> Parser<I> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>, P6: Parser<I, Output = O6, Error = E>, P7: Parser<I, Output = O7, Error = E>, P8: Parser<I, Output = O8, Error = E>, P9: Parser<I, Output = O9, Error = E>, P10: Parser<I, Output = O10, Error = E>, P11: Parser<I, Output = O11, Error = E>, P12: Parser<I, Output = O12, Error = E>,

type Output = (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, E: ParseError<I>, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> Parser<I> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>, P6: Parser<I, Output = O6, Error = E>, P7: Parser<I, Output = O7, Error = E>, P8: Parser<I, Output = O8, Error = E>, P9: Parser<I, Output = O9, Error = E>, P10: Parser<I, Output = O10, Error = E>, P11: Parser<I, Output = O11, Error = E>, P12: Parser<I, Output = O12, Error = E>, P13: Parser<I, Output = O13, Error = E>,

type Output = (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, E: ParseError<I>, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> Parser<I> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>, P6: Parser<I, Output = O6, Error = E>, P7: Parser<I, Output = O7, Error = E>, P8: Parser<I, Output = O8, Error = E>, P9: Parser<I, Output = O9, Error = E>, P10: Parser<I, Output = O10, Error = E>, P11: Parser<I, Output = O11, Error = E>, P12: Parser<I, Output = O12, Error = E>, P13: Parser<I, Output = O13, Error = E>, P14: Parser<I, Output = O14, Error = E>,

type Output = (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, E: ParseError<I>, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> Parser<I> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>, P6: Parser<I, Output = O6, Error = E>, P7: Parser<I, Output = O7, Error = E>, P8: Parser<I, Output = O8, Error = E>, P9: Parser<I, Output = O9, Error = E>, P10: Parser<I, Output = O10, Error = E>, P11: Parser<I, Output = O11, Error = E>, P12: Parser<I, Output = O12, Error = E>, P13: Parser<I, Output = O13, Error = E>, P14: Parser<I, Output = O14, Error = E>, P15: Parser<I, Output = O15, Error = E>,

type Output = (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, E: ParseError<I>, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16> Parser<I> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>, P6: Parser<I, Output = O6, Error = E>, P7: Parser<I, Output = O7, Error = E>, P8: Parser<I, Output = O8, Error = E>, P9: Parser<I, Output = O9, Error = E>, P10: Parser<I, Output = O10, Error = E>, P11: Parser<I, Output = O11, Error = E>, P12: Parser<I, Output = O12, Error = E>, P13: Parser<I, Output = O13, Error = E>, P14: Parser<I, Output = O14, Error = E>, P15: Parser<I, Output = O15, Error = E>, P16: Parser<I, Output = O16, Error = E>,

type Output = (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, E: ParseError<I>, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17> Parser<I> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>, P6: Parser<I, Output = O6, Error = E>, P7: Parser<I, Output = O7, Error = E>, P8: Parser<I, Output = O8, Error = E>, P9: Parser<I, Output = O9, Error = E>, P10: Parser<I, Output = O10, Error = E>, P11: Parser<I, Output = O11, Error = E>, P12: Parser<I, Output = O12, Error = E>, P13: Parser<I, Output = O13, Error = E>, P14: Parser<I, Output = O14, Error = E>, P15: Parser<I, Output = O15, Error = E>, P16: Parser<I, Output = O16, Error = E>, P17: Parser<I, Output = O17, Error = E>,

type Output = (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, E: ParseError<I>, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18> Parser<I> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>, P6: Parser<I, Output = O6, Error = E>, P7: Parser<I, Output = O7, Error = E>, P8: Parser<I, Output = O8, Error = E>, P9: Parser<I, Output = O9, Error = E>, P10: Parser<I, Output = O10, Error = E>, P11: Parser<I, Output = O11, Error = E>, P12: Parser<I, Output = O12, Error = E>, P13: Parser<I, Output = O13, Error = E>, P14: Parser<I, Output = O14, Error = E>, P15: Parser<I, Output = O15, Error = E>, P16: Parser<I, Output = O16, Error = E>, P17: Parser<I, Output = O17, Error = E>, P18: Parser<I, Output = O18, Error = E>,

type Output = (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, E: ParseError<I>, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19> Parser<I> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>, P6: Parser<I, Output = O6, Error = E>, P7: Parser<I, Output = O7, Error = E>, P8: Parser<I, Output = O8, Error = E>, P9: Parser<I, Output = O9, Error = E>, P10: Parser<I, Output = O10, Error = E>, P11: Parser<I, Output = O11, Error = E>, P12: Parser<I, Output = O12, Error = E>, P13: Parser<I, Output = O13, Error = E>, P14: Parser<I, Output = O14, Error = E>, P15: Parser<I, Output = O15, Error = E>, P16: Parser<I, Output = O16, Error = E>, P17: Parser<I, Output = O17, Error = E>, P18: Parser<I, Output = O18, Error = E>, P19: Parser<I, Output = O19, Error = E>,

type Output = (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20, E: ParseError<I>, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20> Parser<I> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>, P6: Parser<I, Output = O6, Error = E>, P7: Parser<I, Output = O7, Error = E>, P8: Parser<I, Output = O8, Error = E>, P9: Parser<I, Output = O9, Error = E>, P10: Parser<I, Output = O10, Error = E>, P11: Parser<I, Output = O11, Error = E>, P12: Parser<I, Output = O12, Error = E>, P13: Parser<I, Output = O13, Error = E>, P14: Parser<I, Output = O14, Error = E>, P15: Parser<I, Output = O15, Error = E>, P16: Parser<I, Output = O16, Error = E>, P17: Parser<I, Output = O17, Error = E>, P18: Parser<I, Output = O18, Error = E>, P19: Parser<I, Output = O19, Error = E>, P20: Parser<I, Output = O20, Error = E>,

type Output = (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20, O21, E: ParseError<I>, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21> Parser<I> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21)

where P1: Parser<I, Output = O1, Error = E>, P2: Parser<I, Output = O2, Error = E>, P3: Parser<I, Output = O3, Error = E>, P4: Parser<I, Output = O4, Error = E>, P5: Parser<I, Output = O5, Error = E>, P6: Parser<I, Output = O6, Error = E>, P7: Parser<I, Output = O7, Error = E>, P8: Parser<I, Output = O8, Error = E>, P9: Parser<I, Output = O9, Error = E>, P10: Parser<I, Output = O10, Error = E>, P11: Parser<I, Output = O11, Error = E>, P12: Parser<I, Output = O12, Error = E>, P13: Parser<I, Output = O13, Error = E>, P14: Parser<I, Output = O14, Error = E>, P15: Parser<I, Output = O15, Error = E>, P16: Parser<I, Output = O16, Error = E>, P17: Parser<I, Output = O17, Error = E>, P18: Parser<I, Output = O18, Error = E>, P19: Parser<I, Output = O19, Error = E>, P20: Parser<I, Output = O20, Error = E>, P21: Parser<I, Output = O21, Error = E>,

type Output = (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20, O21)

type Error = E

fn process<OM: OutputMode>( &mut self, i: I, ) -> PResult<OM, I, Self::Output, Self::Error>

Implementors

impl<'a, I, F, O> Parser<I> for Fill<'a, F, O>

where I: Clone, F: Parser<I, Output = O>,

type Output = ()

type Error = <F as Parser<I>>::Error

impl<I, E: ParseError<I>, F, G> Parser<I> for SeparatedList0<F, G>

where I: Clone + Input, F: Parser<I, Error = E>, G: Parser<I, Error = E>,

type Output = Vec<<F as Parser<I>>::Output>

type Error = <F as Parser<I>>::Error

impl<I, E: ParseError<I>, F, G> Parser<I> for SeparatedList1<F, G>

where I: Clone + Input, F: Parser<I, Error = E>, G: Parser<I, Error = E>,

type Output = Vec<<F as Parser<I>>::Output>

type Error = <F as Parser<I>>::Error

impl<I, E: ParseError<I>, F: Parser<I, Error = E>, G: FnMut(<F as Parser<I>>::Output) -> H, H: Parser<I, Error = E>> Parser<I> for FlatMap<F, G>

type Output = <H as Parser<I>>::Output

type Error = E

impl<I, E: ParseError<I>, F: Parser<I, Error = E>, G: Parser<I, Error = E>> Parser<I> for Preceded<F, G>

type Output = <G as Parser<I>>::Output

type Error = E

impl<I, E: ParseError<I>, F: Parser<I, Error = E>, G: Parser<I, Error = E>> Parser<I> for Terminated<F, G>

type Output = <F as Parser<I>>::Output

type Error = E

impl<I, E: ParseError<I>, F: Parser<I, Error = E>, G: Parser<I, Error = E>> Parser<I> for And<F, G>

type Output = (<F as Parser<I>>::Output, <G as Parser<I>>::Output)

type Error = E

impl<I, Error, F, G> Parser<I> for Escaped<F, G, Error>

where I: Input + Clone + Offset, <I as Input>::Item: AsChar, F: Parser<I, Error = Error>, G: Parser<I, Error = Error>, Error: ParseError<I>,

type Output = I

type Error = Error

impl<I, Error, F, G, ExtendItem, Output> Parser<I> for EscapedTransform<F, G, Error, ExtendItem, Output>

where I: Clone + Offset + Input + ExtendInto<Item = ExtendItem, Extender = Output>, <F as Parser<I>>::Output: ExtendInto<Item = ExtendItem, Extender = Output>, <G as Parser<I>>::Output: ExtendInto<Item = ExtendItem, Extender = Output>, <I as Input>::Item: AsChar, F: Parser<I, Error = Error>, G: Parser<I, Error = Error>, Error: ParseError<I>,

type Output = Output

type Error = Error

impl<I, Error: ParseError<I>> Parser<I> for Take<Error>

where I: Input,

type Output = I

type Error = Error

impl<I, Error: ParseError<I>> Parser<I> for AnyChar<Error>

where I: Input, <I as Input>::Item: AsChar,

type Output = char

type Error = Error

impl<I, Error: ParseError<I>> Parser<I> for Char<Error>

where I: Input, <I as Input>::Item: AsChar,

type Output = char

type Error = Error

impl<I, Error: ParseError<I>> Parser<I> for MultiSpace0<Error>

where I: Input, <I as Input>::Item: AsChar,

type Output = I

type Error = Error

impl<I, Error: ParseError<I>, F> Parser<I> for SplitPosition1<F, Error>

where I: Input, F: Fn(<I as Input>::Item) -> bool,

type Output = I

type Error = Error

impl<I, Error: ParseError<I>, F> Parser<I> for SplitPosition<F, Error>

where I: Input, F: Fn(<I as Input>::Item) -> bool,

type Output = I

type Error = Error

impl<I, Error: ParseError<I>, F> Parser<I> for TakeWhileMN<F, Error>

where I: Input, F: Fn(<I as Input>::Item) -> bool,

type Output = I

type Error = Error

impl<I, Error: ParseError<I>, F, MakeError> Parser<I> for Satisfy<F, MakeError>

where I: Input, <I as Input>::Item: AsChar, F: Fn(char) -> bool, MakeError: Fn(I) -> Error,

type Output = char

type Error = Error

impl<I, Error: ParseError<I>, T> Parser<I> for Tag<T, Error>

where I: Input + Compare<T>, T: Input + Clone,

type Output = I

type Error = Error

impl<I, Error: ParseError<I>, T> Parser<I> for TagNoCase<T, Error>

where I: Input + Compare<T>, T: Input + Clone,

type Output = I

type Error = Error

impl<I, F> Parser<I> for AllConsuming<F>

where I: Input, F: Parser<I>,

type Output = <F as Parser<I>>::Output

type Error = <F as Parser<I>>::Error

impl<I, F> Parser<I> for Cond<F>

where F: Parser<I>,

type Output = Option<<F as Parser<I>>::Output>

type Error = <F as Parser<I>>::Error

impl<I, F> Parser<I> for Consumed<F>

where I: Clone + Offset + Input, F: Parser<I>,

type Output = (I, <F as Parser<I>>::Output)

type Error = <F as Parser<I>>::Error

impl<I, F> Parser<I> for Cut<F>

where F: Parser<I>,

type Output = <F as Parser<I>>::Output

type Error = <F as Parser<I>>::Error

impl<I, F> Parser<I> for MakeComplete<F>

where I: Clone, F: Parser<I>,

type Output = <F as Parser<I>>::Output

type Error = <F as Parser<I>>::Error

impl<I, F> Parser<I> for Not<F>

where I: Clone, F: Parser<I>,

type Output = ()

type Error = <F as Parser<I>>::Error

impl<I, F> Parser<I> for Peek<F>

where I: Clone, F: Parser<I>,

type Output = <F as Parser<I>>::Output

type Error = <F as Parser<I>>::Error

impl<I, F> Parser<I> for Recognize<F>

where I: Clone + Offset + Input, F: Parser<I>,

type Output = I

type Error = <F as Parser<I>>::Error

impl<I, F> Parser<I> for Context<F>

where I: Clone, F: Parser<I>, <F as Parser<I>>::Error: ContextError<I>,

type Output = <F as Parser<I>>::Output

type Error = <F as Parser<I>>::Error

impl<I, F> Parser<I> for Count<F>

where I: Clone, F: Parser<I>,

type Output = Vec<<F as Parser<I>>::Output>

type Error = <F as Parser<I>>::Error

impl<I, F> Parser<I> for Many0<F>

where I: Clone + Input, F: Parser<I>,

type Output = Vec<<F as Parser<I>>::Output>

type Error = <F as Parser<I>>::Error

impl<I, F> Parser<I> for Many0Count<F>

where I: Clone + Input, F: Parser<I>,

type Output = usize

type Error = <F as Parser<I>>::Error

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

where I: Clone + Input, F: Parser<I>,

type Output = Vec<<F as Parser<I>>::Output>

type Error = <F as Parser<I>>::Error

impl<I, F> Parser<I> for Many1Count<F>

where I: Clone + Input, F: Parser<I>,

type Output = usize

type Error = <F as Parser<I>>::Error

impl<I, F> Parser<I> for ManyMN<F>

where I: Clone + Input, F: Parser<I>,

type Output = Vec<<F as Parser<I>>::Output>

type Error = <F as Parser<I>>::Error

impl<I, F, G, E> Parser<I> for LengthCount<F, G, E>

where I: Clone, F: Parser<I, Error = E>, G: Parser<I, Error = E>, <F as Parser<I>>::Output: ToUsize, E: ParseError<I>,

type Output = Vec<<G as Parser<I>>::Output>

type Error = E

impl<I, F, G, E> Parser<I> for LengthValue<F, G, E>

where I: Clone + Input, F: Parser<I, Error = E>, G: Parser<I, Error = E>, <F as Parser<I>>::Output: ToUsize, E: ParseError<I>,

type Output = <G as Parser<I>>::Output

type Error = E

impl<I, F, G, E> Parser<I> for ManyTill<F, G, E>

where I: Clone + Input, F: Parser<I, Error = E>, G: Parser<I, Error = E>, E: ParseError<I>,

type Output = (Vec<<F as Parser<I>>::Output>, <G as Parser<I>>::Output)

type Error = E

impl<I, F, G, H, Range, Res> Parser<I> for Fold<F, G, H, Range>

where I: Clone + Input, F: Parser<I>, G: FnMut(Res, <F as Parser<I>>::Output) -> Res, H: FnMut() -> Res, Range: NomRange<usize>,

type Output = Res

type Error = <F as Parser<I>>::Error

impl<I, F, G, Init, R> Parser<I> for FoldMany0<F, G, Init, R>

where I: Clone + Input, F: Parser<I>, G: FnMut(R, <F as Parser<I>>::Output) -> R, Init: FnMut() -> R,

type Output = R

type Error = <F as Parser<I>>::Error

impl<I, F, G, Init, R> Parser<I> for FoldMany1<F, G, Init, R>

where I: Clone + Input, F: Parser<I>, G: FnMut(R, <F as Parser<I>>::Output) -> R, Init: FnMut() -> R,

type Output = R

type Error = <F as Parser<I>>::Error

impl<I, F, G, Init, R> Parser<I> for FoldManyMN<F, G, Init, R>

where I: Clone + Input, F: Parser<I>, G: FnMut(R, <F as Parser<I>>::Output) -> R, Init: FnMut() -> R,

type Output = R

type Error = <F as Parser<I>>::Error

impl<I, F, R, Collection> Parser<I> for Many<F, R, Collection>

where I: Clone + Input, F: Parser<I>, Collection: Extend<<F as Parser<I>>::Output> + Default, R: NomRange<usize>,

type Output = Collection

type Error = <F as Parser<I>>::Error

impl<I, F: Parser<I>> Parser<I> for Opt<F>

where I: Clone,

type Output = Option<<F as Parser<I>>::Output>

type Error = <F as Parser<I>>::Error

impl<I, F: Parser<I>, G, O2> Parser<I> for Verify<F, G, O2>

where I: Clone, G: Fn(&O2) -> bool, <F as Parser<I>>::Output: Borrow<O2>, O2: ?Sized,

type Output = <F as Parser<I>>::Output

type Error = <F as Parser<I>>::Error

impl<I, F: Parser<I>, G: Parser<<F as Parser<I>>::Output, Error = <F as Parser<I>>::Error>> Parser<I> for AndThen<F, G>

type Output = <G as Parser<<F as Parser<I>>::Output>>::Output

type Error = <F as Parser<I>>::Error

impl<I, O2, E2, F, G> Parser<I> for MapRes<F, G>

where I: Clone, <F as Parser<I>>::Error: FromExternalError<I, E2>, F: Parser<I>, G: FnMut(<F as Parser<I>>::Output) -> Result<O2, E2>,

type Output = O2

type Error = <F as Parser<I>>::Error

impl<I, O2, E: ParseError<I>, F: Parser<I, Error = E>, G: FnMut(<F as Parser<I>>::Output) -> O2> Parser<I> for Map<F, G>

type Output = O2

type Error = E

impl<I, O2, F, G> Parser<I> for MapOpt<F, G>

where I: Clone, F: Parser<I>, G: FnMut(<F as Parser<I>>::Output) -> Option<O2>,

type Output = O2

type Error = <F as Parser<I>>::Error

impl<I, O2: From<<F as Parser<I>>::Output>, E2: ParseError<I> + From<<F as Parser<I>>::Error>, F: Parser<I>> Parser<I> for Into<F, O2, E2>

type Output = O2

type Error = E2

impl<I, O, E> Parser<I> for Fail<O, E>

where E: ParseError<I>,

type Output = O

type Error = E

impl<I, O, E> Parser<I> for Success<O, E>

where O: Clone, E: ParseError<I>,

type Output = O

type Error = E

impl<I, O, E: ParseError<I>, F> Parser<I> for F

where F: FnMut(I) -> IResult<I, O, E>,

type Output = O

type Error = E

impl<I, T, Error: ParseError<I>> Parser<I> for TakeUntil1<T, Error>

where I: Input + FindSubstring<T>, T: Clone,

type Output = I

type Error = Error

impl<I, T, Error: ParseError<I>> Parser<I> for TakeUntil<T, Error>

where I: Input + FindSubstring<T>, T: Clone,

type Output = I

type Error = Error

impl<I: Clone, O, E: ParseError<I>, F: Parser<I, Output = O, Error = E>, G: Parser<I, Output = O, Error = E>> Parser<I> for Or<F, G>

type Output = <F as Parser<I>>::Output

type Error = <F as Parser<I>>::Error

impl<I: Input, E: ParseError<I>> Parser<I> for Digit1<E>

where <I as Input>::Item: AsChar,

type Output = I

type Error = E

impl<Input, Error, A, B, C, D, E, F, FnA, FnB, FnC, FnD, FnE, FnF> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>, FnF: Parser<Input, Output = F, Error = Error>,

type Output = (A, B, C, D, E, F)

type Error = Error

impl<Input, Error, A, B, C, D, E, F, G, FnA, FnB, FnC, FnD, FnE, FnF, FnG> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>, FnF: Parser<Input, Output = F, Error = Error>, FnG: Parser<Input, Output = G, Error = Error>,

type Output = (A, B, C, D, E, F, G)

type Error = Error

impl<Input, Error, A, B, C, D, E, F, G, H, FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>, FnF: Parser<Input, Output = F, Error = Error>, FnG: Parser<Input, Output = G, Error = Error>, FnH: Parser<Input, Output = H, Error = Error>,

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

type Error = Error

impl<Input, Error, A, B, C, D, E, F, G, H, I, FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>, FnF: Parser<Input, Output = F, Error = Error>, FnG: Parser<Input, Output = G, Error = Error>, FnH: Parser<Input, Output = H, Error = Error>, FnI: Parser<Input, Output = I, Error = Error>,

type Output = (A, B, C, D, E, F, G, H, I)

type Error = Error

impl<Input, Error, A, B, C, D, E, F, G, H, I, J, FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>, FnF: Parser<Input, Output = F, Error = Error>, FnG: Parser<Input, Output = G, Error = Error>, FnH: Parser<Input, Output = H, Error = Error>, FnI: Parser<Input, Output = I, Error = Error>, FnJ: Parser<Input, Output = J, Error = Error>,

type Output = (A, B, C, D, E, F, G, H, I, J)

type Error = Error

impl<Input, Error, A, B, C, D, E, F, G, H, I, J, K, FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>, FnF: Parser<Input, Output = F, Error = Error>, FnG: Parser<Input, Output = G, Error = Error>, FnH: Parser<Input, Output = H, Error = Error>, FnI: Parser<Input, Output = I, Error = Error>, FnJ: Parser<Input, Output = J, Error = Error>, FnK: Parser<Input, Output = K, Error = Error>,

type Output = (A, B, C, D, E, F, G, H, I, J, K)

type Error = Error

impl<Input, Error, A, B, C, D, E, F, G, H, I, J, K, L, FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>, FnF: Parser<Input, Output = F, Error = Error>, FnG: Parser<Input, Output = G, Error = Error>, FnH: Parser<Input, Output = H, Error = Error>, FnI: Parser<Input, Output = I, Error = Error>, FnJ: Parser<Input, Output = J, Error = Error>, FnK: Parser<Input, Output = K, Error = Error>, FnL: Parser<Input, Output = L, Error = Error>,

type Output = (A, B, C, D, E, F, G, H, I, J, K, L)

type Error = Error

impl<Input, Error, A, B, C, D, E, F, G, H, I, J, K, L, M, FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>, FnF: Parser<Input, Output = F, Error = Error>, FnG: Parser<Input, Output = G, Error = Error>, FnH: Parser<Input, Output = H, Error = Error>, FnI: Parser<Input, Output = I, Error = Error>, FnJ: Parser<Input, Output = J, Error = Error>, FnK: Parser<Input, Output = K, Error = Error>, FnL: Parser<Input, Output = L, Error = Error>, FnM: Parser<Input, Output = M, Error = Error>,

type Output = (A, B, C, D, E, F, G, H, I, J, K, L, M)

type Error = Error

impl<Input, Error, A, B, C, D, E, F, G, H, I, J, K, L, M, N, FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>, FnF: Parser<Input, Output = F, Error = Error>, FnG: Parser<Input, Output = G, Error = Error>, FnH: Parser<Input, Output = H, Error = Error>, FnI: Parser<Input, Output = I, Error = Error>, FnJ: Parser<Input, Output = J, Error = Error>, FnK: Parser<Input, Output = K, Error = Error>, FnL: Parser<Input, Output = L, Error = Error>, FnM: Parser<Input, Output = M, Error = Error>, FnN: Parser<Input, Output = N, Error = Error>,

type Output = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

type Error = Error

impl<Input, Error, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>, FnF: Parser<Input, Output = F, Error = Error>, FnG: Parser<Input, Output = G, Error = Error>, FnH: Parser<Input, Output = H, Error = Error>, FnI: Parser<Input, Output = I, Error = Error>, FnJ: Parser<Input, Output = J, Error = Error>, FnK: Parser<Input, Output = K, Error = Error>, FnL: Parser<Input, Output = L, Error = Error>, FnM: Parser<Input, Output = M, Error = Error>, FnN: Parser<Input, Output = N, Error = Error>, FnO: Parser<Input, Output = O, Error = Error>,

type Output = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

type Error = Error

impl<Input, Error, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>, FnF: Parser<Input, Output = F, Error = Error>, FnG: Parser<Input, Output = G, Error = Error>, FnH: Parser<Input, Output = H, Error = Error>, FnI: Parser<Input, Output = I, Error = Error>, FnJ: Parser<Input, Output = J, Error = Error>, FnK: Parser<Input, Output = K, Error = Error>, FnL: Parser<Input, Output = L, Error = Error>, FnM: Parser<Input, Output = M, Error = Error>, FnN: Parser<Input, Output = N, Error = Error>, FnO: Parser<Input, Output = O, Error = Error>, FnP: Parser<Input, Output = P, Error = Error>,

type Output = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

type Error = Error

impl<Input, Error, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP, FnQ> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP, FnQ), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>, FnF: Parser<Input, Output = F, Error = Error>, FnG: Parser<Input, Output = G, Error = Error>, FnH: Parser<Input, Output = H, Error = Error>, FnI: Parser<Input, Output = I, Error = Error>, FnJ: Parser<Input, Output = J, Error = Error>, FnK: Parser<Input, Output = K, Error = Error>, FnL: Parser<Input, Output = L, Error = Error>, FnM: Parser<Input, Output = M, Error = Error>, FnN: Parser<Input, Output = N, Error = Error>, FnO: Parser<Input, Output = O, Error = Error>, FnP: Parser<Input, Output = P, Error = Error>, FnQ: Parser<Input, Output = Q, Error = Error>,

type Output = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

type Error = Error

impl<Input, Error, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP, FnQ, FnR> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP, FnQ, FnR), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>, FnF: Parser<Input, Output = F, Error = Error>, FnG: Parser<Input, Output = G, Error = Error>, FnH: Parser<Input, Output = H, Error = Error>, FnI: Parser<Input, Output = I, Error = Error>, FnJ: Parser<Input, Output = J, Error = Error>, FnK: Parser<Input, Output = K, Error = Error>, FnL: Parser<Input, Output = L, Error = Error>, FnM: Parser<Input, Output = M, Error = Error>, FnN: Parser<Input, Output = N, Error = Error>, FnO: Parser<Input, Output = O, Error = Error>, FnP: Parser<Input, Output = P, Error = Error>, FnQ: Parser<Input, Output = Q, Error = Error>, FnR: Parser<Input, Output = R, Error = Error>,

type Output = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

type Error = Error

impl<Input, Error, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP, FnQ, FnR, FnS> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP, FnQ, FnR, FnS), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>, FnF: Parser<Input, Output = F, Error = Error>, FnG: Parser<Input, Output = G, Error = Error>, FnH: Parser<Input, Output = H, Error = Error>, FnI: Parser<Input, Output = I, Error = Error>, FnJ: Parser<Input, Output = J, Error = Error>, FnK: Parser<Input, Output = K, Error = Error>, FnL: Parser<Input, Output = L, Error = Error>, FnM: Parser<Input, Output = M, Error = Error>, FnN: Parser<Input, Output = N, Error = Error>, FnO: Parser<Input, Output = O, Error = Error>, FnP: Parser<Input, Output = P, Error = Error>, FnQ: Parser<Input, Output = Q, Error = Error>, FnR: Parser<Input, Output = R, Error = Error>, FnS: Parser<Input, Output = S, Error = Error>,

type Output = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

type Error = Error

impl<Input, Error, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP, FnQ, FnR, FnS, FnT> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP, FnQ, FnR, FnS, FnT), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>, FnF: Parser<Input, Output = F, Error = Error>, FnG: Parser<Input, Output = G, Error = Error>, FnH: Parser<Input, Output = H, Error = Error>, FnI: Parser<Input, Output = I, Error = Error>, FnJ: Parser<Input, Output = J, Error = Error>, FnK: Parser<Input, Output = K, Error = Error>, FnL: Parser<Input, Output = L, Error = Error>, FnM: Parser<Input, Output = M, Error = Error>, FnN: Parser<Input, Output = N, Error = Error>, FnO: Parser<Input, Output = O, Error = Error>, FnP: Parser<Input, Output = P, Error = Error>, FnQ: Parser<Input, Output = Q, Error = Error>, FnR: Parser<Input, Output = R, Error = Error>, FnS: Parser<Input, Output = S, Error = Error>, FnT: Parser<Input, Output = T, Error = Error>,

type Output = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

type Error = Error

impl<Input, Error, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP, FnQ, FnR, FnS, FnT, FnU> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP, FnQ, FnR, FnS, FnT, FnU), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>, FnF: Parser<Input, Output = F, Error = Error>, FnG: Parser<Input, Output = G, Error = Error>, FnH: Parser<Input, Output = H, Error = Error>, FnI: Parser<Input, Output = I, Error = Error>, FnJ: Parser<Input, Output = J, Error = Error>, FnK: Parser<Input, Output = K, Error = Error>, FnL: Parser<Input, Output = L, Error = Error>, FnM: Parser<Input, Output = M, Error = Error>, FnN: Parser<Input, Output = N, Error = Error>, FnO: Parser<Input, Output = O, Error = Error>, FnP: Parser<Input, Output = P, Error = Error>, FnQ: Parser<Input, Output = Q, Error = Error>, FnR: Parser<Input, Output = R, Error = Error>, FnS: Parser<Input, Output = S, Error = Error>, FnT: Parser<Input, Output = T, Error = Error>, FnU: Parser<Input, Output = U, Error = Error>,

type Output = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

type Error = Error

impl<Input, Error, A, B, C, D, E, FnA, FnB, FnC, FnD, FnE> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD, FnE), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>, FnE: Parser<Input, Output = E, Error = Error>,

type Output = (A, B, C, D, E)

type Error = Error

impl<Input, Error, A, B, C, D, FnA, FnB, FnC, FnD> Parser<Input> for Permutation<(FnA, FnB, FnC, FnD), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>, FnD: Parser<Input, Output = D, Error = Error>,

type Output = (A, B, C, D)

type Error = Error

impl<Input, Error, A, B, C, FnA, FnB, FnC> Parser<Input> for Permutation<(FnA, FnB, FnC), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>,

type Output = (A, B, C)

type Error = Error

impl<Input, Error, A, B, FnA, FnB> Parser<Input> for Permutation<(FnA, FnB), Error>

where Input: Clone, Error: ParseError<Input>, FnA: Parser<Input, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>,

type Output = (A, B)

type Error = Error

impl<Input, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A,)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<&mut [A]>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>, F: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E, F)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>, F: Parser<Input, Output = Output, Error = Error>, G: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E, F, G)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>, F: Parser<Input, Output = Output, Error = Error>, G: Parser<Input, Output = Output, Error = Error>, H: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E, F, G, H)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>, F: Parser<Input, Output = Output, Error = Error>, G: Parser<Input, Output = Output, Error = Error>, H: Parser<Input, Output = Output, Error = Error>, I: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E, F, G, H, I)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>, F: Parser<Input, Output = Output, Error = Error>, G: Parser<Input, Output = Output, Error = Error>, H: Parser<Input, Output = Output, Error = Error>, I: Parser<Input, Output = Output, Error = Error>, J: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E, F, G, H, I, J)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>, F: Parser<Input, Output = Output, Error = Error>, G: Parser<Input, Output = Output, Error = Error>, H: Parser<Input, Output = Output, Error = Error>, I: Parser<Input, Output = Output, Error = Error>, J: Parser<Input, Output = Output, Error = Error>, K: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E, F, G, H, I, J, K)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>, F: Parser<Input, Output = Output, Error = Error>, G: Parser<Input, Output = Output, Error = Error>, H: Parser<Input, Output = Output, Error = Error>, I: Parser<Input, Output = Output, Error = Error>, J: Parser<Input, Output = Output, Error = Error>, K: Parser<Input, Output = Output, Error = Error>, L: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E, F, G, H, I, J, K, L)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>, F: Parser<Input, Output = Output, Error = Error>, G: Parser<Input, Output = Output, Error = Error>, H: Parser<Input, Output = Output, Error = Error>, I: Parser<Input, Output = Output, Error = Error>, J: Parser<Input, Output = Output, Error = Error>, K: Parser<Input, Output = Output, Error = Error>, L: Parser<Input, Output = Output, Error = Error>, M: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E, F, G, H, I, J, K, L, M)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>, F: Parser<Input, Output = Output, Error = Error>, G: Parser<Input, Output = Output, Error = Error>, H: Parser<Input, Output = Output, Error = Error>, I: Parser<Input, Output = Output, Error = Error>, J: Parser<Input, Output = Output, Error = Error>, K: Parser<Input, Output = Output, Error = Error>, L: Parser<Input, Output = Output, Error = Error>, M: Parser<Input, Output = Output, Error = Error>, N: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>, F: Parser<Input, Output = Output, Error = Error>, G: Parser<Input, Output = Output, Error = Error>, H: Parser<Input, Output = Output, Error = Error>, I: Parser<Input, Output = Output, Error = Error>, J: Parser<Input, Output = Output, Error = Error>, K: Parser<Input, Output = Output, Error = Error>, L: Parser<Input, Output = Output, Error = Error>, M: Parser<Input, Output = Output, Error = Error>, N: Parser<Input, Output = Output, Error = Error>, O: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>, F: Parser<Input, Output = Output, Error = Error>, G: Parser<Input, Output = Output, Error = Error>, H: Parser<Input, Output = Output, Error = Error>, I: Parser<Input, Output = Output, Error = Error>, J: Parser<Input, Output = Output, Error = Error>, K: Parser<Input, Output = Output, Error = Error>, L: Parser<Input, Output = Output, Error = Error>, M: Parser<Input, Output = Output, Error = Error>, N: Parser<Input, Output = Output, Error = Error>, O: Parser<Input, Output = Output, Error = Error>, P: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>, F: Parser<Input, Output = Output, Error = Error>, G: Parser<Input, Output = Output, Error = Error>, H: Parser<Input, Output = Output, Error = Error>, I: Parser<Input, Output = Output, Error = Error>, J: Parser<Input, Output = Output, Error = Error>, K: Parser<Input, Output = Output, Error = Error>, L: Parser<Input, Output = Output, Error = Error>, M: Parser<Input, Output = Output, Error = Error>, N: Parser<Input, Output = Output, Error = Error>, O: Parser<Input, Output = Output, Error = Error>, P: Parser<Input, Output = Output, Error = Error>, Q: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>, F: Parser<Input, Output = Output, Error = Error>, G: Parser<Input, Output = Output, Error = Error>, H: Parser<Input, Output = Output, Error = Error>, I: Parser<Input, Output = Output, Error = Error>, J: Parser<Input, Output = Output, Error = Error>, K: Parser<Input, Output = Output, Error = Error>, L: Parser<Input, Output = Output, Error = Error>, M: Parser<Input, Output = Output, Error = Error>, N: Parser<Input, Output = Output, Error = Error>, O: Parser<Input, Output = Output, Error = Error>, P: Parser<Input, Output = Output, Error = Error>, Q: Parser<Input, Output = Output, Error = Error>, R: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>, F: Parser<Input, Output = Output, Error = Error>, G: Parser<Input, Output = Output, Error = Error>, H: Parser<Input, Output = Output, Error = Error>, I: Parser<Input, Output = Output, Error = Error>, J: Parser<Input, Output = Output, Error = Error>, K: Parser<Input, Output = Output, Error = Error>, L: Parser<Input, Output = Output, Error = Error>, M: Parser<Input, Output = Output, Error = Error>, N: Parser<Input, Output = Output, Error = Error>, O: Parser<Input, Output = Output, Error = Error>, P: Parser<Input, Output = Output, Error = Error>, Q: Parser<Input, Output = Output, Error = Error>, R: Parser<Input, Output = Output, Error = Error>, S: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>, F: Parser<Input, Output = Output, Error = Error>, G: Parser<Input, Output = Output, Error = Error>, H: Parser<Input, Output = Output, Error = Error>, I: Parser<Input, Output = Output, Error = Error>, J: Parser<Input, Output = Output, Error = Error>, K: Parser<Input, Output = Output, Error = Error>, L: Parser<Input, Output = Output, Error = Error>, M: Parser<Input, Output = Output, Error = Error>, N: Parser<Input, Output = Output, Error = Error>, O: Parser<Input, Output = Output, Error = Error>, P: Parser<Input, Output = Output, Error = Error>, Q: Parser<Input, Output = Output, Error = Error>, R: Parser<Input, Output = Output, Error = Error>, S: Parser<Input, Output = Output, Error = Error>, T: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)>

type Output = Output

type Error = Error

impl<Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>, B: Parser<Input, Output = Output, Error = Error>, C: Parser<Input, Output = Output, Error = Error>, D: Parser<Input, Output = Output, Error = Error>, E: Parser<Input, Output = Output, Error = Error>, F: Parser<Input, Output = Output, Error = Error>, G: Parser<Input, Output = Output, Error = Error>, H: Parser<Input, Output = Output, Error = Error>, I: Parser<Input, Output = Output, Error = Error>, J: Parser<Input, Output = Output, Error = Error>, K: Parser<Input, Output = Output, Error = Error>, L: Parser<Input, Output = Output, Error = Error>, M: Parser<Input, Output = Output, Error = Error>, N: Parser<Input, Output = Output, Error = Error>, O: Parser<Input, Output = Output, Error = Error>, P: Parser<Input, Output = Output, Error = Error>, Q: Parser<Input, Output = Output, Error = Error>, R: Parser<Input, Output = Output, Error = Error>, S: Parser<Input, Output = Output, Error = Error>, T: Parser<Input, Output = Output, Error = Error>, U: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)>

type Output = Output

type Error = Error

impl<const N: usize, Input: Clone, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>> Parser<Input> for Choice<[A; N]>

type Output = Output

type Error = Error