Trait tuple::OpSplit

pub trait OpSplit<L> {
    type R;

    // Required method
    fn split(self) -> (L, Self::R);
}

Required Associated Types

type R

Required Methods

fn split(self) -> (L, Self::R)

Implementations on Foreign Types

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

type R = b

fn split(self) -> (a, Self::R)

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

type R = c

fn split(self) -> ((a, b), Self::R)

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

type R = (b, c)

fn split(self) -> (a, Self::R)

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

type R = (c, d)

fn split(self) -> ((a, b), Self::R)

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

type R = d

fn split(self) -> ((a, b, c), Self::R)

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

type R = (b, c, d)

fn split(self) -> (a, Self::R)

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

type R = (c, d, e)

fn split(self) -> ((a, b), Self::R)

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

type R = (d, e)

fn split(self) -> ((a, b, c), Self::R)

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

type R = e

fn split(self) -> ((a, b, c, d), Self::R)

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

type R = (b, c, d, e)

fn split(self) -> (a, Self::R)

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

type R = (c, d, e, f)

fn split(self) -> ((a, b), Self::R)

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

type R = (d, e, f)

fn split(self) -> ((a, b, c), Self::R)

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

type R = (e, f)

fn split(self) -> ((a, b, c, d), Self::R)

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

type R = f

fn split(self) -> ((a, b, c, d, e), Self::R)

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

type R = (b, c, d, e, f)

fn split(self) -> (a, Self::R)

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

type R = (c, d, e, f, g)

fn split(self) -> ((a, b), Self::R)

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

type R = (d, e, f, g)

fn split(self) -> ((a, b, c), Self::R)

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

type R = (e, f, g)

fn split(self) -> ((a, b, c, d), Self::R)

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

type R = (f, g)

fn split(self) -> ((a, b, c, d, e), Self::R)

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

type R = g

fn split(self) -> ((a, b, c, d, e, f), Self::R)

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

type R = (b, c, d, e, f, g)

fn split(self) -> (a, Self::R)

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

type R = (c, d, e, f, g, h)

fn split(self) -> ((a, b), Self::R)

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

type R = (d, e, f, g, h)

fn split(self) -> ((a, b, c), Self::R)

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

type R = (e, f, g, h)

fn split(self) -> ((a, b, c, d), Self::R)

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

type R = (f, g, h)

fn split(self) -> ((a, b, c, d, e), Self::R)

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

type R = (g, h)

fn split(self) -> ((a, b, c, d, e, f), Self::R)

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

type R = h

fn split(self) -> ((a, b, c, d, e, f, g), Self::R)

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

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

fn split(self) -> (a, Self::R)

Implementors

impl<a, b> OpSplit<T1<a>> for T2<a, b>

type R = T1<b>

impl<a, b, c> OpSplit<T1<a>> for T3<a, b, c>

type R = T2<b, c>

impl<a, b, c> OpSplit<T2<a, b>> for T3<a, b, c>

type R = T1<c>

impl<a, b, c, d> OpSplit<T1<a>> for T4<a, b, c, d>

type R = T3<b, c, d>

impl<a, b, c, d> OpSplit<T2<a, b>> for T4<a, b, c, d>

type R = T2<c, d>

impl<a, b, c, d> OpSplit<T3<a, b, c>> for T4<a, b, c, d>

type R = T1<d>

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

type R = T4<b, c, d, e>

impl<a, b, c, d, e> OpSplit<T2<a, b>> for T5<a, b, c, d, e>

type R = T3<c, d, e>

impl<a, b, c, d, e> OpSplit<T3<a, b, c>> for T5<a, b, c, d, e>

type R = T2<d, e>

impl<a, b, c, d, e> OpSplit<T4<a, b, c, d>> for T5<a, b, c, d, e>

type R = T1<e>

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

type R = T5<b, c, d, e, f>

impl<a, b, c, d, e, f> OpSplit<T2<a, b>> for T6<a, b, c, d, e, f>

type R = T4<c, d, e, f>

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

type R = T3<d, e, f>

impl<a, b, c, d, e, f> OpSplit<T4<a, b, c, d>> for T6<a, b, c, d, e, f>

type R = T2<e, f>

impl<a, b, c, d, e, f> OpSplit<T5<a, b, c, d, e>> for T6<a, b, c, d, e, f>

type R = T1<f>

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

type R = T6<b, c, d, e, f, g>

impl<a, b, c, d, e, f, g> OpSplit<T2<a, b>> for T7<a, b, c, d, e, f, g>

type R = T5<c, d, e, f, g>

impl<a, b, c, d, e, f, g> OpSplit<T3<a, b, c>> for T7<a, b, c, d, e, f, g>

type R = T4<d, e, f, g>

impl<a, b, c, d, e, f, g> OpSplit<T4<a, b, c, d>> for T7<a, b, c, d, e, f, g>

type R = T3<e, f, g>

impl<a, b, c, d, e, f, g> OpSplit<T5<a, b, c, d, e>> for T7<a, b, c, d, e, f, g>

type R = T2<f, g>

impl<a, b, c, d, e, f, g> OpSplit<T6<a, b, c, d, e, f>> for T7<a, b, c, d, e, f, g>

type R = T1<g>

impl<a, b, c, d, e, f, g, h> OpSplit<T1<a>> for T8<a, b, c, d, e, f, g, h>

type R = T7<b, c, d, e, f, g, h>

impl<a, b, c, d, e, f, g, h> OpSplit<T2<a, b>> for T8<a, b, c, d, e, f, g, h>

type R = T6<c, d, e, f, g, h>

impl<a, b, c, d, e, f, g, h> OpSplit<T3<a, b, c>> for T8<a, b, c, d, e, f, g, h>

type R = T5<d, e, f, g, h>

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

type R = T4<e, f, g, h>

impl<a, b, c, d, e, f, g, h> OpSplit<T5<a, b, c, d, e>> for T8<a, b, c, d, e, f, g, h>

type R = T3<f, g, h>

impl<a, b, c, d, e, f, g, h> OpSplit<T6<a, b, c, d, e, f>> for T8<a, b, c, d, e, f, g, h>

type R = T2<g, h>

impl<a, b, c, d, e, f, g, h> OpSplit<T7<a, b, c, d, e, f, g>> for T8<a, b, c, d, e, f, g, h>

type R = T1<h>