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.

Object Safety

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