Trait Tuple

pub trait Tuple<I, O, E> {
    // Required method
    fn parse(&mut self, input: I) -> Result<(I, O), Err<E>>;
}

Available on crate feature mtls only.

Helper trait for the tuple combinator.

This trait is implemented for tuples of parsers of up to 21 elements.

Required Methods

fn parse(&mut self, input: I) -> Result<(I, O), Err<E>>

Parses the input and returns a tuple of results of each parser.

Implementations on Foreign Types

impl<I, E> Tuple<I, (), E> for ()

where E: ParseError<I>,

fn parse(&mut self, input: I) -> Result<(I, ()), Err<E>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E)), Err<Error>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E, F)), Err<Error>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E, F, G)), Err<Error>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E, F, G, H)), Err<Error>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E, F, G, H, I)), Err<Error>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E, F, G, H, I, J)), Err<Error>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E, F, G, H, I, J, K)), Err<Error>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E, F, G, H, I, J, K, L)), Err<Error>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E, F, G, H, I, J, K, L, M)), Err<Error>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E, F, G, H, I, J, K, L, M, N)), Err<Error>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)), Err<Error>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)), Err<Error>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)), Err<Error>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)), Err<Error>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)), Err<Error>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)), Err<Error>>

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

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

fn parse( &mut self, input: Input, ) -> Result<(Input, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)), Err<Error>>

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

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

fn parse(&mut self, input: Input) -> Result<(Input, (A, B, C, D)), Err<Error>>

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

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

fn parse(&mut self, input: Input) -> Result<(Input, (A, B, C)), Err<Error>>

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

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

fn parse(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

impl<Input, Output, Error, F> Tuple<Input, (Output,), Error> for (F,)

where Error: ParseError<Input>, F: Parser<Input, Output, Error>,

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

Implementors