Trait TupleConcat

Source
pub trait TupleConcat<T> {
    type Output;

    // Required method
    fn concat(self, other: T) -> Self::Output;
}
Expand description

Concat two tuples.

This works like TupleZip, but takes another tuple as input.

Note: This trait only has implementations for operations that return tuples of length 5 / 10 (long-tuple-impl feature) or less. That means that (A, B, C, D, E, F, G) cannot be concated with (H, I, J, K, L).

§Example

use rs_std_ext::tuple::TupleConcat;

let x = (10u8, 'a');
let y = (-5i32, "foo");
let z = x.concat(y);

assert_eq!(z, (10u8, 'a', -5i32, "foo"));

Required Associated Types§

Required Methods§

Source

fn concat(self, other: T) -> Self::Output

Implementations on Foreign Types§

§

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

§

type Output = (A, B)

§

fn concat(self, other: (B,)) -> Self::Output

§

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

§

type Output = (A, B, C)

§

fn concat(self, other: (B, C)) -> Self::Output

§

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

§

type Output = (A, B, C)

§

fn concat(self, other: (C,)) -> Self::Output

§

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

§

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

§

fn concat(self, other: (B, C, D)) -> Self::Output

§

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

§

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

§

fn concat(self, other: (C, D)) -> Self::Output

§

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

§

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

§

fn concat(self, other: (D,)) -> Self::Output

§

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

§

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

§

fn concat(self, other: (B, C, D, E)) -> Self::Output

§

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

§

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

§

fn concat(self, other: (C, D, E)) -> Self::Output

§

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

§

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

§

fn concat(self, other: (D, E)) -> Self::Output

§

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

§

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

§

fn concat(self, other: (E,)) -> Self::Output

§

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

§

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

§

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

§

fn concat(self, other: (C, D, E, F)) -> Self::Output

§

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

§

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

§

fn concat(self, other: (D, E, F)) -> Self::Output

§

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

§

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

§

fn concat(self, other: (E, F)) -> Self::Output

§

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

§

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

§

fn concat(self, other: (F,)) -> Self::Output

§

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

§

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

§

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

§

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

§

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

§

fn concat(self, other: (E, F, G)) -> Self::Output

§

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

§

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

§

fn concat(self, other: (F, G)) -> Self::Output

§

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

§

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

§

fn concat(self, other: (G,)) -> Self::Output

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn concat(self, other: (G, H)) -> Self::Output

§

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

§

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

§

fn concat(self, other: (H,)) -> Self::Output

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn concat(self, other: (I,)) -> Self::Output

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

Implementors§