Trait NextTuple 

pub trait NextTuple {
    type Output<Next>;

    // Required method
    fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>;
}

Allows extending a tuple, or creating a new tuple, by adding the next value.

Required Associated Types

type Output<Next>

The type that will be returned by adding another value of type Next to the end of the current type.

Required Methods

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

Adds the next value and returns the result.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl NextTuple for ()

type Output<Next> = (Next,)

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

impl<A> NextTuple for (A,)

type Output<Next> = (A, Next)

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

type Output<Next> = (A, B, Next)

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

type Output<Next> = (A, B, C, Next)

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

type Output<Next> = (A, B, C, D, Next)

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

type Output<Next> = (A, B, C, D, E, Next)

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

type Output<Next> = (A, B, C, D, E, F, Next)

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

type Output<Next> = (A, B, C, D, E, F, G, Next)

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

type Output<Next> = (A, B, C, D, E, F, G, H, Next)

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

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

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

fn next_tuple<Next>(self, next: Next) -> Self::Output<Next>

Implementors