Trait tuple::OpJoin

pub trait OpJoin<RHS> {
    type Output;

    // Required method
    fn join(self, rhs: RHS) -> Self::Output;
}

Allows to join/concatenate two tuples

Required Associated Types

type Output

Required Methods

fn join(self, rhs: RHS) -> Self::Output

Implementations on Foreign Types

impl<a, b> OpJoin<(b,)> for (a,)

type Output = (a, b)

fn join(self, rhs: (b,)) -> Self::Output

impl<a, b, c> OpJoin<(b, c)> for (a,)

type Output = (a, b, c)

fn join(self, rhs: (b, c)) -> Self::Output

impl<a, b, c> OpJoin<(c,)> for (a, b)

type Output = (a, b, c)

fn join(self, rhs: (c,)) -> Self::Output

impl<a, b, c, d> OpJoin<(b, c, d)> for (a,)

type Output = (a, b, c, d)

fn join(self, rhs: (b, c, d)) -> Self::Output

impl<a, b, c, d> OpJoin<(c, d)> for (a, b)

type Output = (a, b, c, d)

fn join(self, rhs: (c, d)) -> Self::Output

impl<a, b, c, d> OpJoin<(d,)> for (a, b, c)

type Output = (a, b, c, d)

fn join(self, rhs: (d,)) -> Self::Output

impl<a, b, c, d, e> OpJoin<(b, c, d, e)> for (a,)

type Output = (a, b, c, d, e)

fn join(self, rhs: (b, c, d, e)) -> Self::Output

impl<a, b, c, d, e> OpJoin<(c, d, e)> for (a, b)

type Output = (a, b, c, d, e)

fn join(self, rhs: (c, d, e)) -> Self::Output

impl<a, b, c, d, e> OpJoin<(d, e)> for (a, b, c)

type Output = (a, b, c, d, e)

fn join(self, rhs: (d, e)) -> Self::Output

impl<a, b, c, d, e> OpJoin<(e,)> for (a, b, c, d)

type Output = (a, b, c, d, e)

fn join(self, rhs: (e,)) -> Self::Output

impl<a, b, c, d, e, f> OpJoin<(b, c, d, e, f)> for (a,)

type Output = (a, b, c, d, e, f)

fn join(self, rhs: (b, c, d, e, f)) -> Self::Output

impl<a, b, c, d, e, f> OpJoin<(c, d, e, f)> for (a, b)

type Output = (a, b, c, d, e, f)

fn join(self, rhs: (c, d, e, f)) -> Self::Output

impl<a, b, c, d, e, f> OpJoin<(d, e, f)> for (a, b, c)

type Output = (a, b, c, d, e, f)

fn join(self, rhs: (d, e, f)) -> Self::Output

impl<a, b, c, d, e, f> OpJoin<(e, f)> for (a, b, c, d)

type Output = (a, b, c, d, e, f)

fn join(self, rhs: (e, f)) -> Self::Output

impl<a, b, c, d, e, f> OpJoin<(f,)> for (a, b, c, d, e)

type Output = (a, b, c, d, e, f)

fn join(self, rhs: (f,)) -> Self::Output

impl<a, b, c, d, e, f, g> OpJoin<(b, c, d, e, f, g)> for (a,)

type Output = (a, b, c, d, e, f, g)

fn join(self, rhs: (b, c, d, e, f, g)) -> Self::Output

impl<a, b, c, d, e, f, g> OpJoin<(c, d, e, f, g)> for (a, b)

type Output = (a, b, c, d, e, f, g)

fn join(self, rhs: (c, d, e, f, g)) -> Self::Output

impl<a, b, c, d, e, f, g> OpJoin<(d, e, f, g)> for (a, b, c)

type Output = (a, b, c, d, e, f, g)

fn join(self, rhs: (d, e, f, g)) -> Self::Output

impl<a, b, c, d, e, f, g> OpJoin<(e, f, g)> for (a, b, c, d)

type Output = (a, b, c, d, e, f, g)

fn join(self, rhs: (e, f, g)) -> Self::Output

impl<a, b, c, d, e, f, g> OpJoin<(f, g)> for (a, b, c, d, e)

type Output = (a, b, c, d, e, f, g)

fn join(self, rhs: (f, g)) -> Self::Output

impl<a, b, c, d, e, f, g> OpJoin<(g,)> for (a, b, c, d, e, f)

type Output = (a, b, c, d, e, f, g)

fn join(self, rhs: (g,)) -> Self::Output

impl<a, b, c, d, e, f, g, h> OpJoin<(b, c, d, e, f, g, h)> for (a,)

type Output = (a, b, c, d, e, f, g, h)

fn join(self, rhs: (b, c, d, e, f, g, h)) -> Self::Output

impl<a, b, c, d, e, f, g, h> OpJoin<(c, d, e, f, g, h)> for (a, b)

type Output = (a, b, c, d, e, f, g, h)

fn join(self, rhs: (c, d, e, f, g, h)) -> Self::Output

impl<a, b, c, d, e, f, g, h> OpJoin<(d, e, f, g, h)> for (a, b, c)

type Output = (a, b, c, d, e, f, g, h)

fn join(self, rhs: (d, e, f, g, h)) -> Self::Output

impl<a, b, c, d, e, f, g, h> OpJoin<(e, f, g, h)> for (a, b, c, d)

type Output = (a, b, c, d, e, f, g, h)

fn join(self, rhs: (e, f, g, h)) -> Self::Output

impl<a, b, c, d, e, f, g, h> OpJoin<(f, g, h)> for (a, b, c, d, e)

type Output = (a, b, c, d, e, f, g, h)

fn join(self, rhs: (f, g, h)) -> Self::Output

impl<a, b, c, d, e, f, g, h> OpJoin<(g, h)> for (a, b, c, d, e, f)

type Output = (a, b, c, d, e, f, g, h)

fn join(self, rhs: (g, h)) -> Self::Output

impl<a, b, c, d, e, f, g, h> OpJoin<(h,)> for (a, b, c, d, e, f, g)

type Output = (a, b, c, d, e, f, g, h)

fn join(self, rhs: (h,)) -> Self::Output

Implementors

impl<a, b> OpJoin<T1<b>> for T1<a>

type Output = T2<a, b>

impl<a, b, c> OpJoin<T1<c>> for T2<a, b>

type Output = T3<a, b, c>

impl<a, b, c> OpJoin<T2<b, c>> for T1<a>

type Output = T3<a, b, c>

impl<a, b, c, d> OpJoin<T1<d>> for T3<a, b, c>

type Output = T4<a, b, c, d>

impl<a, b, c, d> OpJoin<T2<c, d>> for T2<a, b>

type Output = T4<a, b, c, d>

impl<a, b, c, d> OpJoin<T3<b, c, d>> for T1<a>

type Output = T4<a, b, c, d>

impl<a, b, c, d, e> OpJoin<T1<e>> for T4<a, b, c, d>

type Output = T5<a, b, c, d, e>

impl<a, b, c, d, e> OpJoin<T2<d, e>> for T3<a, b, c>

type Output = T5<a, b, c, d, e>

impl<a, b, c, d, e> OpJoin<T3<c, d, e>> for T2<a, b>

type Output = T5<a, b, c, d, e>

impl<a, b, c, d, e> OpJoin<T4<b, c, d, e>> for T1<a>

type Output = T5<a, b, c, d, e>

impl<a, b, c, d, e, f> OpJoin<T1<f>> for T5<a, b, c, d, e>

type Output = T6<a, b, c, d, e, f>

impl<a, b, c, d, e, f> OpJoin<T2<e, f>> for T4<a, b, c, d>

type Output = T6<a, b, c, d, e, f>

impl<a, b, c, d, e, f> OpJoin<T3<d, e, f>> for T3<a, b, c>

type Output = T6<a, b, c, d, e, f>

impl<a, b, c, d, e, f> OpJoin<T4<c, d, e, f>> for T2<a, b>

type Output = T6<a, b, c, d, e, f>

impl<a, b, c, d, e, f> OpJoin<T5<b, c, d, e, f>> for T1<a>

type Output = T6<a, b, c, d, e, f>

impl<a, b, c, d, e, f, g> OpJoin<T1<g>> for T6<a, b, c, d, e, f>

type Output = T7<a, b, c, d, e, f, g>

impl<a, b, c, d, e, f, g> OpJoin<T2<f, g>> for T5<a, b, c, d, e>

type Output = T7<a, b, c, d, e, f, g>

impl<a, b, c, d, e, f, g> OpJoin<T3<e, f, g>> for T4<a, b, c, d>

type Output = T7<a, b, c, d, e, f, g>

impl<a, b, c, d, e, f, g> OpJoin<T4<d, e, f, g>> for T3<a, b, c>

type Output = T7<a, b, c, d, e, f, g>

impl<a, b, c, d, e, f, g> OpJoin<T5<c, d, e, f, g>> for T2<a, b>

type Output = T7<a, b, c, d, e, f, g>

impl<a, b, c, d, e, f, g> OpJoin<T6<b, c, d, e, f, g>> for T1<a>

type Output = T7<a, b, c, d, e, f, g>

impl<a, b, c, d, e, f, g, h> OpJoin<T1<h>> for T7<a, b, c, d, e, f, g>

type Output = T8<a, b, c, d, e, f, g, h>

impl<a, b, c, d, e, f, g, h> OpJoin<T2<g, h>> for T6<a, b, c, d, e, f>

type Output = T8<a, b, c, d, e, f, g, h>

impl<a, b, c, d, e, f, g, h> OpJoin<T3<f, g, h>> for T5<a, b, c, d, e>

type Output = T8<a, b, c, d, e, f, g, h>

impl<a, b, c, d, e, f, g, h> OpJoin<T4<e, f, g, h>> for T4<a, b, c, d>

type Output = T8<a, b, c, d, e, f, g, h>

impl<a, b, c, d, e, f, g, h> OpJoin<T5<d, e, f, g, h>> for T3<a, b, c>

type Output = T8<a, b, c, d, e, f, g, h>

impl<a, b, c, d, e, f, g, h> OpJoin<T6<c, d, e, f, g, h>> for T2<a, b>

type Output = T8<a, b, c, d, e, f, g, h>

impl<a, b, c, d, e, f, g, h> OpJoin<T7<b, c, d, e, f, g, h>> for T1<a>

type Output = T8<a, b, c, d, e, f, g, h>