Trait nom::sequence::Tuple

pub trait Tuple<I, O, E> {
    fn parse(&mut self, input: I) -> IResult<I, O, E>;
}

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) -> IResult<I, O, E>

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

Implementations on Foreign Types

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

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

impl<Input: Clone, A, B, Error: ParseError<Input>, FnA: Parser<Input, A, Error>, FnB: Parser<Input, B, Error>> Tuple<Input, (A, B), Error> for (FnA, FnB)

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

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

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

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

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

impl<Input: Clone, A, B, C, D, E, 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>> Tuple<Input, (A, B, C, D, E), Error> for (FnA, FnB, FnC, FnD, FnE)

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

impl<Input: Clone, A, B, C, D, E, F, 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>> Tuple<Input, (A, B, C, D, E, F), Error> for (FnA, FnB, FnC, FnD, FnE, FnF)

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

impl<Input: Clone, A, B, C, D, E, F, G, 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>> Tuple<Input, (A, B, C, D, E, F, G), Error> for (FnA, FnB, FnC, FnD, FnE, FnF, FnG)

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

impl<Input: Clone, A, B, C, D, E, F, G, H, 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>> Tuple<Input, (A, B, C, D, E, F, G, H), Error> for (FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH)

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

impl<Input: Clone, A, B, C, D, E, F, G, H, I, 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>> Tuple<Input, (A, B, C, D, E, F, G, H, I), Error> for (FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI)

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

impl<Input: Clone, A, B, C, D, E, F, G, H, I, J, 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>> Tuple<Input, (A, B, C, D, E, F, G, H, I, J), Error> for (FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ)

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

impl<Input: Clone, A, B, C, D, E, F, G, H, I, J, K, 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>> 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)

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

impl<Input: Clone, A, B, C, D, E, F, G, H, I, J, K, L, 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>> 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)

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

impl<Input: Clone, A, B, C, D, E, F, G, H, I, J, K, L, M, 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>> 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)

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

impl<Input: Clone, A, B, C, D, E, F, G, H, I, J, K, L, M, N, 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>> 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)

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

impl<Input: Clone, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 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>> 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)

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

impl<Input: Clone, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, 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>> 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)

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

impl<Input: Clone, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, 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>> 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)

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

impl<Input: Clone, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, 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>> 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)

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

impl<Input: Clone, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, 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>> 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)

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

impl<Input: Clone, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, 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>> 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)

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

impl<Input: Clone, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, 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>> 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)

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

Implementors