Trait flatten::tuple::IntoTuple [−] [src]

pub trait IntoTuple: ValidNode {
    type Out;
    fn into_tuple(self) -> Self::Out;
}

extern crate flatten;
use flatten::Flatten;

let too_big = (1, 2, 3, (4, 5), 6, (7, 8), (9, 10), (11, 12, 13, 14), 15);
too_big.flatten();//~ ERROR length of result tuple should be <= 12

Associated Types

`type Out`

Required Methods

`fn into_tuple(self) -> Self::Out`

Implementors

impl<A, B> IntoTuple for Cons<A, Cons<B, Nil>> where A: ValidHead, B: ValidHead, type Out = (A, B);
impl<A, B, C> IntoTuple for Cons<A, Cons<B, Cons<C, Nil>>> where A: ValidHead, B: ValidHead, C: ValidHead, type Out = (A, B, C);
impl<A, B, C, D> IntoTuple for Cons<A, Cons<B, Cons<C, Cons<D, Nil>>>> where A: ValidHead, B: ValidHead, C: ValidHead, D: ValidHead, type Out = (A, B, C, D);
impl<A, B, C, D, E> IntoTuple for Cons<A, Cons<B, Cons<C, Cons<D, Cons<E, Nil>>>>> where A: ValidHead, B: ValidHead, C: ValidHead, D: ValidHead, E: ValidHead, type Out = (A, B, C, D, E);
impl<A, B, C, D, E, F> IntoTuple for Cons<A, Cons<B, Cons<C, Cons<D, Cons<E, Cons<F, Nil>>>>>> where A: ValidHead, B: ValidHead, C: ValidHead, D: ValidHead, E: ValidHead, F: ValidHead, type Out = (A, B, C, D, E, F);
impl<A, B, C, D, E, F, G> IntoTuple for Cons<A, Cons<B, Cons<C, Cons<D, Cons<E, Cons<F, Cons<G, Nil>>>>>>> where A: ValidHead, B: ValidHead, C: ValidHead, D: ValidHead, E: ValidHead, F: ValidHead, G: ValidHead, type Out = (A, B, C, D, E, F, G);
impl<A, B, C, D, E, F, G, H> IntoTuple for Cons<A, Cons<B, Cons<C, Cons<D, Cons<E, Cons<F, Cons<G, Cons<H, Nil>>>>>>>> where A: ValidHead, B: ValidHead, C: ValidHead, D: ValidHead, E: ValidHead, F: ValidHead, G: ValidHead, H: ValidHead, type Out = (A, B, C, D, E, F, G, H);
impl<A, B, C, D, E, F, G, H, I> IntoTuple for Cons<A, Cons<B, Cons<C, Cons<D, Cons<E, Cons<F, Cons<G, Cons<H, Cons<I, Nil>>>>>>>>> where A: ValidHead, B: ValidHead, C: ValidHead, D: ValidHead, E: ValidHead, F: ValidHead, G: ValidHead, H: ValidHead, I: ValidHead, type Out = (A, B, C, D, E, F, G, H, I);
impl<A, B, C, D, E, F, G, H, I, J> IntoTuple for Cons<A, Cons<B, Cons<C, Cons<D, Cons<E, Cons<F, Cons<G, Cons<H, Cons<I, Cons<J, Nil>>>>>>>>>> where A: ValidHead, B: ValidHead, C: ValidHead, D: ValidHead, E: ValidHead, F: ValidHead, G: ValidHead, H: ValidHead, I: ValidHead, J: ValidHead, type Out = (A, B, C, D, E, F, G, H, I, J);
impl<A, B, C, D, E, F, G, H, I, J, K> IntoTuple for Cons<A, Cons<B, Cons<C, Cons<D, Cons<E, Cons<F, Cons<G, Cons<H, Cons<I, Cons<J, Cons<K, Nil>>>>>>>>>>> where A: ValidHead, B: ValidHead, C: ValidHead, D: ValidHead, E: ValidHead, F: ValidHead, G: ValidHead, H: ValidHead, I: ValidHead, J: ValidHead, K: ValidHead, type Out = (A, B, C, D, E, F, G, H, I, J, K);
impl<A, B, C, D, E, F, G, H, I, J, K, L> IntoTuple for Cons<A, Cons<B, Cons<C, Cons<D, Cons<E, Cons<F, Cons<G, Cons<H, Cons<I, Cons<J, Cons<K, Cons<L, Nil>>>>>>>>>>>> where A: ValidHead, B: ValidHead, C: ValidHead, D: ValidHead, E: ValidHead, F: ValidHead, G: ValidHead, H: ValidHead, I: ValidHead, J: ValidHead, K: ValidHead, L: ValidHead, type Out = (A, B, C, D, E, F, G, H, I, J, K, L);
impl<A: ValidHead> IntoTuple for Cons<A, Nil> type Out = (A,);