Trait tupl::Tuple

pub trait Tuple: Sealed {
    type Append<T>: Tuple;
    type Prepend<T>: Tuple;

    const ARITY: usize;

    // Required methods
    fn append<T>(self, value: T) -> Self::Append<T>;
    fn prepend<T>(self, value: T) -> Self::Prepend<T>;
}

A trait representing tuples. It is only implemented for tuples of arity 0 to 50.
This trait is sealed and as such not meant to be implemented.

Required Associated Types

type Append<T>: Tuple

type Prepend<T>: Tuple

Required Associated Constants

const ARITY: usize

The arity or length of this tuple type.

Required Methods

fn append<T>(self, value: T) -> Self::Append<T>

Consumes this tuple and appends a value to it, returning a new tuple.

Examples

let tuple = (1, 2);
let tuple = tuple.append(3);
assert_eq!(tuple, (1, 2, 3));

Panics

Calling this function on a tuple of arity 50 or greater will cause a panic.

fn prepend<T>(self, value: T) -> Self::Prepend<T>

Consumes this tuple and prepends a value to it, returning a new tuple.

Examples

let tuple = (2, 3);
let tuple = tuple.prepend(1);
assert_eq!(tuple, (1, 2, 3));

Panics

Calling this function on a tuple of arity 50 or greater will cause a panic.

Implementations on Foreign Types

impl<Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 34usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<E, D, C, B, A> Tuple for (E, D, C, B, A)

type Append<T> = (E, D, C, B, A, T)

type Prepend<T> = (T, E, D, C, B, A)

const ARITY: usize = 5usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 28usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 15usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 22usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 45usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<H, G, F, E, D, C, B, A> Tuple for (H, G, F, E, D, C, B, A)

type Append<T> = (H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, H, G, F, E, D, C, B, A)

const ARITY: usize = 8usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 32usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 38usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 44usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 31usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 14usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<B, A> Tuple for (B, A)

type Append<T> = (B, A, T)

type Prepend<T> = (T, B, A)

const ARITY: usize = 2usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<C, B, A> Tuple for (C, B, A)

type Append<T> = (C, B, A, T)

type Prepend<T> = (T, C, B, A)

const ARITY: usize = 3usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 25usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 41usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 24usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Ω, Ψ, Χ, Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Ω, Ψ, Χ, Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Ω, Ψ, Χ, Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Ω, Ψ, Χ, Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 49usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 39usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 43usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 35usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 23usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 26usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 42usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 46usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 13usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 17usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<F, E, D, C, B, A> Tuple for (F, E, D, C, B, A)

type Append<T> = (F, E, D, C, B, A, T)

type Prepend<T> = (T, F, E, D, C, B, A)

const ARITY: usize = 6usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 33usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 37usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<K, J, I, H, G, F, E, D, C, B, A> Tuple for (K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 11usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 40usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 27usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<I, H, G, F, E, D, C, B, A> Tuple for (I, H, G, F, E, D, C, B, A)

type Append<T> = (I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 9usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<A> Tuple for (A,)

type Append<T> = (A, T)

type Prepend<T> = (T, A)

const ARITY: usize = 1usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<D, C, B, A> Tuple for (D, C, B, A)

type Append<T> = (D, C, B, A, T)

type Prepend<T> = (T, D, C, B, A)

const ARITY: usize = 4usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 16usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl Tuple for Infallible

type Prepend<T> = Infallible

type Append<T> = Infallible

const ARITY: usize = 4_294_967_295usize

fn prepend<T>(self, _: T) -> Self::Prepend<T>

fn append<T>(self, _: T) -> Self::Append<T>

impl Tuple for ()

type Append<T> = (T,)

type Prepend<T> = (T,)

const ARITY: usize = 0usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 20usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Χ, Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Χ, Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Χ, Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Χ, Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 47usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Ψ, Χ, Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Ψ, Χ, Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Ψ, Χ, Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Ψ, Χ, Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 48usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 29usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<J, I, H, G, F, E, D, C, B, A> Tuple for (J, I, H, G, F, E, D, C, B, A)

type Append<T> = (J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 10usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<ඞ, Ω, Ψ, Χ, Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (ඞ, Ω, Ψ, Χ, Φ, Υ, Τ, Σ, Ρ, Π, Ο, Ξ, Ν, Μ, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Prepend<T> = Infallible

type Append<T> = Infallible

const ARITY: usize = 50usize

fn prepend<T>(self, _: T) -> Self::Prepend<T>

fn append<T>(self, _: T) -> Self::Append<T>

impl<S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 19usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 30usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 21usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<G, F, E, D, C, B, A> Tuple for (G, F, E, D, C, B, A)

type Append<T> = (G, F, E, D, C, B, A, T)

type Prepend<T> = (T, G, F, E, D, C, B, A)

const ARITY: usize = 7usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, Λ, Κ, Ι, Θ, Η, Ζ, Ε, Δ, Γ, Β, Α, Z, Y, X, W, V, U, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 36usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 18usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

impl<L, K, J, I, H, G, F, E, D, C, B, A> Tuple for (L, K, J, I, H, G, F, E, D, C, B, A)

type Append<T> = (L, K, J, I, H, G, F, E, D, C, B, A, T)

type Prepend<T> = (T, L, K, J, I, H, G, F, E, D, C, B, A)

const ARITY: usize = 12usize

fn append<T>(self, value: T) -> Self::Append<T>

fn prepend<T>(self, value: T) -> Self::Prepend<T>

Implementors