Struct `Permutation`

struct Permutation<T, Error> { ... }

Wrapping structure for the [permutation] combinator implementation

Implementations

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

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

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

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

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

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

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

fn process<OM: crate::OutputMode>(self: &mut Self, input: Input) -> crate::PResult<OM, Input, <Self as >::Output, <Self as >::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 for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ), Error>`

fn process<OM: crate::OutputMode>(self: &mut Self, input: Input) -> crate::PResult<OM, Input, <Self as >::Output, <Self as >::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 for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK), Error>`

fn process<OM: crate::OutputMode>(self: &mut Self, input: Input) -> crate::PResult<OM, Input, <Self as >::Output, <Self as >::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 for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL), Error>`

fn process<OM: crate::OutputMode>(self: &mut Self, input: Input) -> crate::PResult<OM, Input, <Self as >::Output, <Self as >::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 for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM), Error>`

fn process<OM: crate::OutputMode>(self: &mut Self, input: Input) -> crate::PResult<OM, Input, <Self as >::Output, <Self as >::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 for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN), Error>`

fn process<OM: crate::OutputMode>(self: &mut Self, input: Input) -> crate::PResult<OM, Input, <Self as >::Output, <Self as >::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 for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO), Error>`

fn process<OM: crate::OutputMode>(self: &mut Self, input: Input) -> crate::PResult<OM, Input, <Self as >::Output, <Self as >::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 for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP), Error>`

fn process<OM: crate::OutputMode>(self: &mut Self, input: Input) -> crate::PResult<OM, Input, <Self as >::Output, <Self as >::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 for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP, FnQ), Error>`

fn process<OM: crate::OutputMode>(self: &mut Self, input: Input) -> crate::PResult<OM, Input, <Self as >::Output, <Self as >::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 for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP, FnQ, FnR), Error>`

fn process<OM: crate::OutputMode>(self: &mut Self, input: Input) -> crate::PResult<OM, Input, <Self as >::Output, <Self as >::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 for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP, FnQ, FnR, FnS), Error>`

fn process<OM: crate::OutputMode>(self: &mut Self, input: Input) -> crate::PResult<OM, Input, <Self as >::Output, <Self as >::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 for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP, FnQ, FnR, FnS, FnT), Error>`

fn process<OM: crate::OutputMode>(self: &mut Self, input: Input) -> crate::PResult<OM, Input, <Self as >::Output, <Self as >::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 for Permutation<(FnA, FnB, FnC, FnD, FnE, FnF, FnG, FnH, FnI, FnJ, FnK, FnL, FnM, FnN, FnO, FnP, FnQ, FnR, FnS, FnT, FnU), Error>`

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

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

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

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

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

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

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

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

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

`impl<T> Any for Permutation<T, Error>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Permutation<T, Error>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Permutation<T, Error>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> From for Permutation<T, Error>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, Error> Freeze for Permutation<T, Error>`

`impl<T, Error> RefUnwindSafe for Permutation<T, Error>`

`impl<T, Error> Send for Permutation<T, Error>`

`impl<T, Error> Sync for Permutation<T, Error>`

`impl<T, Error> Unpin for Permutation<T, Error>`

`impl<T, Error> UnwindSafe for Permutation<T, Error>`

`impl<T, U> Into for Permutation<T, Error>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Permutation<T, Error>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Permutation<T, Error>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>