Trait tuple_utils::Append

pub trait Append<T> {
    type Output;
    fn append(self, _: T) -> Self::Output;
}

Helper trait to allow Appending of tuples

Associated Types

type Output

Required Methods

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

Append T onto the end of the tuple returning a new tuple with the existing elements and T

Implementations on Foreign Types

impl<A, T> Append<T> for (A,)

type Output = (A, T)

fn append(self, x: T) -> (A, T)

impl<A, B, T> Append<T> for (A, B)

type Output = (A, B, T)

fn append(self, x: T) -> (A, B, T)

impl<A, B, C, T> Append<T> for (A, B, C)

type Output = (A, B, C, T)

fn append(self, x: T) -> (A, B, C, T)

impl<A, B, C, D, T> Append<T> for (A, B, C, D)

type Output = (A, B, C, D, T)

fn append(self, x: T) -> (A, B, C, D, T)

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

type Output = (A, B, C, D, E, T)

fn append(self, x: T) -> (A, B, C, D, E, T)

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

type Output = (A, B, C, D, E, F, T)

fn append(self, x: T) -> (A, B, C, D, E, F, T)

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

type Output = (A, B, C, D, E, F, G, T)

fn append(self, x: T) -> (A, B, C, D, E, F, G, T)

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

type Output = (A, B, C, D, E, F, G, H, T)

fn append(self, x: T) -> (A, B, C, D, E, F, G, H, T)

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

type Output = (A, B, C, D, E, F, G, H, I, T)

fn append(self, x: T) -> (A, B, C, D, E, F, G, H, I, T)

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

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

fn append(self, x: T) -> (A, B, C, D, E, F, G, H, I, J, T)

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

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

fn append(self, x: T) -> (A, B, C, D, E, F, G, H, I, J, K, T)

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

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

fn append(self, x: T) -> (A, B, C, D, E, F, G, H, I, J, K, L, T)

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

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

fn append(self, x: T) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, T)

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

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

fn append(self, x: T) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, T)

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

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

fn append(self, x: T) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, T)

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

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

fn append(self, x: T) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, T)

Implementors