Trait Tuple

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

Helper trait for the tuple combinator.

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

Required Methods

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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_tuple(&mut self, input: I) -> Result<(I, ()), Err<E>>

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

fn parse_tuple( &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>>

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

fn parse_tuple( &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>>

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

fn parse_tuple( &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>>

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

fn parse_tuple( &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>>

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

fn parse_tuple( &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>>

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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, Output = A, Error = Error>, FnB: Parser<Input, Output = B, Error = Error>, FnC: Parser<Input, Output = C, Error = Error>,

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

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

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

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

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

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

👎Deprecated since 8.0.0: Parser is directly implemented for tuples

Implementors