Trait nom::branch::Permutation

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

helper trait for the permutation() combinator

this trait is implemented for tuples of up to 21 elements

Required methods

fn permutation(&self, input: I) -> IResult<I, O, E>

tries to apply all parsers in the tuple in various orders until all of them succeed

Implementations on Foreign Types

impl<Input: Clone, A, B, Error: ParseError<Input>, FnA: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>> Permutation<Input, (A, B), Error> for (FnA, FnB)

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

impl<Input: Clone, A, B, C, Error: ParseError<Input>, FnA: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>> Permutation<Input, (A, B, C), Error> for (FnA, FnB, FnC)

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

impl<Input: Clone, A, B, C, D, Error: ParseError<Input>, FnA: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>> Permutation<Input, (A, B, C, D), Error> for (FnA, FnB, FnC, FnD)

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

impl<Input: Clone, A, B, C, D, E, Error: ParseError<Input>, FnA: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>> Permutation<Input, (A, B, C, D, E), Error> for (FnA, FnB, FnC, FnD, FnE)

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

impl<Input: Clone, A, B, C, D, E, F, Error: ParseError<Input>, FnA: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>, FnF: Fn(Input) -> IResult<Input, F, Error>> Permutation<Input, (A, B, C, D, E, F), Error> for (FnA, FnB, FnC, FnD, FnE, FnF)

fn permutation(&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: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>, FnF: Fn(Input) -> IResult<Input, F, Error>, FnG: Fn(Input) -> IResult<Input, G, Error>> Permutation<Input, (A, B, C, D, E, F, G), Error> for (FnA, FnB, FnC, FnD, FnE, FnF, FnG)

fn permutation(
    &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: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>, FnF: Fn(Input) -> IResult<Input, F, Error>, FnG: Fn(Input) -> IResult<Input, G, Error>, FnH: Fn(Input) -> IResult<Input, H, Error>> Permutation<Input, (A, B, C, D, E, F, G, H), Error> for (FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH)

fn permutation(
    &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: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>, FnF: Fn(Input) -> IResult<Input, F, Error>, FnG: Fn(Input) -> IResult<Input, G, Error>, FnH: Fn(Input) -> IResult<Input, H, Error>, FnI: Fn(Input) -> IResult<Input, I, Error>> Permutation<Input, (A, B, C, D, E, F, G, H, I), Error> for (FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI)

fn permutation(
    &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: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>, FnF: Fn(Input) -> IResult<Input, F, Error>, FnG: Fn(Input) -> IResult<Input, G, Error>, FnH: Fn(Input) -> IResult<Input, H, Error>, FnI: Fn(Input) -> IResult<Input, I, Error>, FnJ: Fn(Input) -> IResult<Input, J, Error>> Permutation<Input, (A, B, C, D, E, F, G, H, I, J), Error> for (FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ)

fn permutation(
    &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: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>, FnF: Fn(Input) -> IResult<Input, F, Error>, FnG: Fn(Input) -> IResult<Input, G, Error>, FnH: Fn(Input) -> IResult<Input, H, Error>, FnI: Fn(Input) -> IResult<Input, I, Error>, FnJ: Fn(Input) -> IResult<Input, J, Error>, FnK: Fn(Input) -> IResult<Input, K, Error>> Permutation<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 permutation(
    &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: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>, FnF: Fn(Input) -> IResult<Input, F, Error>, FnG: Fn(Input) -> IResult<Input, G, Error>, FnH: Fn(Input) -> IResult<Input, H, Error>, FnI: Fn(Input) -> IResult<Input, I, Error>, FnJ: Fn(Input) -> IResult<Input, J, Error>, FnK: Fn(Input) -> IResult<Input, K, Error>, FnL: Fn(Input) -> IResult<Input, L, Error>> Permutation<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 permutation(
    &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: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>, FnF: Fn(Input) -> IResult<Input, F, Error>, FnG: Fn(Input) -> IResult<Input, G, Error>, FnH: Fn(Input) -> IResult<Input, H, Error>, FnI: Fn(Input) -> IResult<Input, I, Error>, FnJ: Fn(Input) -> IResult<Input, J, Error>, FnK: Fn(Input) -> IResult<Input, K, Error>, FnL: Fn(Input) -> IResult<Input, L, Error>, FnM: Fn(Input) -> IResult<Input, M, Error>> Permutation<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 permutation(
    &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: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>, FnF: Fn(Input) -> IResult<Input, F, Error>, FnG: Fn(Input) -> IResult<Input, G, Error>, FnH: Fn(Input) -> IResult<Input, H, Error>, FnI: Fn(Input) -> IResult<Input, I, Error>, FnJ: Fn(Input) -> IResult<Input, J, Error>, FnK: Fn(Input) -> IResult<Input, K, Error>, FnL: Fn(Input) -> IResult<Input, L, Error>, FnM: Fn(Input) -> IResult<Input, M, Error>, FnN: Fn(Input) -> IResult<Input, N, Error>> Permutation<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 permutation(
    &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: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>, FnF: Fn(Input) -> IResult<Input, F, Error>, FnG: Fn(Input) -> IResult<Input, G, Error>, FnH: Fn(Input) -> IResult<Input, H, Error>, FnI: Fn(Input) -> IResult<Input, I, Error>, FnJ: Fn(Input) -> IResult<Input, J, Error>, FnK: Fn(Input) -> IResult<Input, K, Error>, FnL: Fn(Input) -> IResult<Input, L, Error>, FnM: Fn(Input) -> IResult<Input, M, Error>, FnN: Fn(Input) -> IResult<Input, N, Error>, FnO: Fn(Input) -> IResult<Input, O, Error>> Permutation<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 permutation(
    &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: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>, FnF: Fn(Input) -> IResult<Input, F, Error>, FnG: Fn(Input) -> IResult<Input, G, Error>, FnH: Fn(Input) -> IResult<Input, H, Error>, FnI: Fn(Input) -> IResult<Input, I, Error>, FnJ: Fn(Input) -> IResult<Input, J, Error>, FnK: Fn(Input) -> IResult<Input, K, Error>, FnL: Fn(Input) -> IResult<Input, L, Error>, FnM: Fn(Input) -> IResult<Input, M, Error>, FnN: Fn(Input) -> IResult<Input, N, Error>, FnO: Fn(Input) -> IResult<Input, O, Error>, FnP: Fn(Input) -> IResult<Input, P, Error>> Permutation<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 permutation(
    &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: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>, FnF: Fn(Input) -> IResult<Input, F, Error>, FnG: Fn(Input) -> IResult<Input, G, Error>, FnH: Fn(Input) -> IResult<Input, H, Error>, FnI: Fn(Input) -> IResult<Input, I, Error>, FnJ: Fn(Input) -> IResult<Input, J, Error>, FnK: Fn(Input) -> IResult<Input, K, Error>, FnL: Fn(Input) -> IResult<Input, L, Error>, FnM: Fn(Input) -> IResult<Input, M, Error>, FnN: Fn(Input) -> IResult<Input, N, Error>, FnO: Fn(Input) -> IResult<Input, O, Error>, FnP: Fn(Input) -> IResult<Input, P, Error>, FnQ: Fn(Input) -> IResult<Input, Q, Error>> Permutation<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 permutation(
    &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: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>, FnF: Fn(Input) -> IResult<Input, F, Error>, FnG: Fn(Input) -> IResult<Input, G, Error>, FnH: Fn(Input) -> IResult<Input, H, Error>, FnI: Fn(Input) -> IResult<Input, I, Error>, FnJ: Fn(Input) -> IResult<Input, J, Error>, FnK: Fn(Input) -> IResult<Input, K, Error>, FnL: Fn(Input) -> IResult<Input, L, Error>, FnM: Fn(Input) -> IResult<Input, M, Error>, FnN: Fn(Input) -> IResult<Input, N, Error>, FnO: Fn(Input) -> IResult<Input, O, Error>, FnP: Fn(Input) -> IResult<Input, P, Error>, FnQ: Fn(Input) -> IResult<Input, Q, Error>, FnR: Fn(Input) -> IResult<Input, R, Error>> Permutation<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 permutation(
    &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: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>, FnF: Fn(Input) -> IResult<Input, F, Error>, FnG: Fn(Input) -> IResult<Input, G, Error>, FnH: Fn(Input) -> IResult<Input, H, Error>, FnI: Fn(Input) -> IResult<Input, I, Error>, FnJ: Fn(Input) -> IResult<Input, J, Error>, FnK: Fn(Input) -> IResult<Input, K, Error>, FnL: Fn(Input) -> IResult<Input, L, Error>, FnM: Fn(Input) -> IResult<Input, M, Error>, FnN: Fn(Input) -> IResult<Input, N, Error>, FnO: Fn(Input) -> IResult<Input, O, Error>, FnP: Fn(Input) -> IResult<Input, P, Error>, FnQ: Fn(Input) -> IResult<Input, Q, Error>, FnR: Fn(Input) -> IResult<Input, R, Error>, FnS: Fn(Input) -> IResult<Input, S, Error>> Permutation<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 permutation(
    &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: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>, FnF: Fn(Input) -> IResult<Input, F, Error>, FnG: Fn(Input) -> IResult<Input, G, Error>, FnH: Fn(Input) -> IResult<Input, H, Error>, FnI: Fn(Input) -> IResult<Input, I, Error>, FnJ: Fn(Input) -> IResult<Input, J, Error>, FnK: Fn(Input) -> IResult<Input, K, Error>, FnL: Fn(Input) -> IResult<Input, L, Error>, FnM: Fn(Input) -> IResult<Input, M, Error>, FnN: Fn(Input) -> IResult<Input, N, Error>, FnO: Fn(Input) -> IResult<Input, O, Error>, FnP: Fn(Input) -> IResult<Input, P, Error>, FnQ: Fn(Input) -> IResult<Input, Q, Error>, FnR: Fn(Input) -> IResult<Input, R, Error>, FnS: Fn(Input) -> IResult<Input, S, Error>, FnT: Fn(Input) -> IResult<Input, T, Error>> Permutation<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 permutation(
    &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: Fn(Input) -> IResult<Input, A, Error>, FnB: Fn(Input) -> IResult<Input, B, Error>, FnC: Fn(Input) -> IResult<Input, C, Error>, FnD: Fn(Input) -> IResult<Input, D, Error>, FnE: Fn(Input) -> IResult<Input, E, Error>, FnF: Fn(Input) -> IResult<Input, F, Error>, FnG: Fn(Input) -> IResult<Input, G, Error>, FnH: Fn(Input) -> IResult<Input, H, Error>, FnI: Fn(Input) -> IResult<Input, I, Error>, FnJ: Fn(Input) -> IResult<Input, J, Error>, FnK: Fn(Input) -> IResult<Input, K, Error>, FnL: Fn(Input) -> IResult<Input, L, Error>, FnM: Fn(Input) -> IResult<Input, M, Error>, FnN: Fn(Input) -> IResult<Input, N, Error>, FnO: Fn(Input) -> IResult<Input, O, Error>, FnP: Fn(Input) -> IResult<Input, P, Error>, FnQ: Fn(Input) -> IResult<Input, Q, Error>, FnR: Fn(Input) -> IResult<Input, R, Error>, FnS: Fn(Input) -> IResult<Input, S, Error>, FnT: Fn(Input) -> IResult<Input, T, Error>, FnU: Fn(Input) -> IResult<Input, U, Error>> Permutation<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 permutation(
    &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