Trait Cons 

pub trait Cons {
    type Head;
    type Tail;

    // Required method
    fn uncons(self) -> (Self::Head, Self::Tail);
}

A sequence that can be represented as a cons cell.

Required Associated Types

type Head

type Tail

Required Methods

fn uncons(self) -> (Self::Head, Self::Tail)

Implementations on Foreign Types

impl<'a, 'b, A> Cons for &'a &'b [A; 1]

type Head = &'b A

type Tail = &'b [A; 0]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a &'b [A; 2]

type Head = &'b A

type Tail = &'b [A; 1]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a &'b [A; 3]

type Head = &'b A

type Tail = &'b [A; 2]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a &'b [A; 4]

type Head = &'b A

type Tail = &'b [A; 3]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a &'b [A; 5]

type Head = &'b A

type Tail = &'b [A; 4]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a &'b [A; 6]

type Head = &'b A

type Tail = &'b [A; 5]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a &'b [A; 7]

type Head = &'b A

type Tail = &'b [A; 6]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a &'b [A; 8]

type Head = &'b A

type Tail = &'b [A; 7]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a &'b [A; 9]

type Head = &'b A

type Tail = &'b [A; 8]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a &'b [A; 10]

type Head = &'b A

type Tail = &'b [A; 9]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a &'b (A,)

type Head = &'b A

type Tail = ()

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a mut &'b [A; 1]

type Head = &'b A

type Tail = &'b [A; 0]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a mut &'b [A; 2]

type Head = &'b A

type Tail = &'b [A; 1]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a mut &'b [A; 3]

type Head = &'b A

type Tail = &'b [A; 2]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a mut &'b [A; 4]

type Head = &'b A

type Tail = &'b [A; 3]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a mut &'b [A; 5]

type Head = &'b A

type Tail = &'b [A; 4]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a mut &'b [A; 6]

type Head = &'b A

type Tail = &'b [A; 5]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a mut &'b [A; 7]

type Head = &'b A

type Tail = &'b [A; 6]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a mut &'b [A; 8]

type Head = &'b A

type Tail = &'b [A; 7]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a mut &'b [A; 9]

type Head = &'b A

type Tail = &'b [A; 8]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a mut &'b [A; 10]

type Head = &'b A

type Tail = &'b [A; 9]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A> Cons for &'a mut &'b (A,)

type Head = &'b A

type Tail = ()

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B> Cons for &'a &'b (A, B)

type Head = &'b A

type Tail = (&'b B,)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B> Cons for &'a mut &'b (A, B)

type Head = &'b A

type Tail = (&'b B,)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B, C> Cons for &'a &'b (A, B, C)

type Head = &'b A

type Tail = (&'b B, &'b C)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B, C> Cons for &'a mut &'b (A, B, C)

type Head = &'b A

type Tail = (&'b B, &'b C)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B, C, D> Cons for &'a &'b (A, B, C, D)

type Head = &'b A

type Tail = (&'b B, &'b C, &'b D)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B, C, D> Cons for &'a mut &'b (A, B, C, D)

type Head = &'b A

type Tail = (&'b B, &'b C, &'b D)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B, C, D, E> Cons for &'a &'b (A, B, C, D, E)

type Head = &'b A

type Tail = (&'b B, &'b C, &'b D, &'b E)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B, C, D, E> Cons for &'a mut &'b (A, B, C, D, E)

type Head = &'b A

type Tail = (&'b B, &'b C, &'b D, &'b E)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B, C, D, E, F> Cons for &'a &'b (A, B, C, D, E, F)

type Head = &'b A

type Tail = (&'b B, &'b C, &'b D, &'b E, &'b F)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B, C, D, E, F> Cons for &'a mut &'b (A, B, C, D, E, F)

type Head = &'b A

type Tail = (&'b B, &'b C, &'b D, &'b E, &'b F)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B, C, D, E, F, G> Cons for &'a &'b (A, B, C, D, E, F, G)

type Head = &'b A

type Tail = (&'b B, &'b C, &'b D, &'b E, &'b F, &'b G)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B, C, D, E, F, G> Cons for &'a mut &'b (A, B, C, D, E, F, G)

type Head = &'b A

type Tail = (&'b B, &'b C, &'b D, &'b E, &'b F, &'b G)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B, C, D, E, F, G, H> Cons for &'a &'b (A, B, C, D, E, F, G, H)

type Head = &'b A

type Tail = (&'b B, &'b C, &'b D, &'b E, &'b F, &'b G, &'b H)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B, C, D, E, F, G, H> Cons for &'a mut &'b (A, B, C, D, E, F, G, H)

type Head = &'b A

type Tail = (&'b B, &'b C, &'b D, &'b E, &'b F, &'b G, &'b H)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B, C, D, E, F, G, H, I> Cons for &'a &'b (A, B, C, D, E, F, G, H, I)

type Head = &'b A

type Tail = (&'b B, &'b C, &'b D, &'b E, &'b F, &'b G, &'b H, &'b I)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B, C, D, E, F, G, H, I> Cons for &'a mut &'b (A, B, C, D, E, F, G, H, I)

type Head = &'b A

type Tail = (&'b B, &'b C, &'b D, &'b E, &'b F, &'b G, &'b H, &'b I)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B, C, D, E, F, G, H, I, J> Cons for &'a &'b (A, B, C, D, E, F, G, H, I, J)

type Head = &'b A

type Tail = (&'b B, &'b C, &'b D, &'b E, &'b F, &'b G, &'b H, &'b I, &'b J)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, 'b, A, B, C, D, E, F, G, H, I, J> Cons for &'a mut &'b (A, B, C, D, E, F, G, H, I, J)

type Head = &'b A

type Tail = (&'b B, &'b C, &'b D, &'b E, &'b F, &'b G, &'b H, &'b I, &'b J)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a [A; 1]

type Head = &'a A

type Tail = &'a [A; 0]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a [A; 2]

type Head = &'a A

type Tail = &'a [A; 1]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a [A; 3]

type Head = &'a A

type Tail = &'a [A; 2]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a [A; 4]

type Head = &'a A

type Tail = &'a [A; 3]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a [A; 5]

type Head = &'a A

type Tail = &'a [A; 4]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a [A; 6]

type Head = &'a A

type Tail = &'a [A; 5]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a [A; 7]

type Head = &'a A

type Tail = &'a [A; 6]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a [A; 8]

type Head = &'a A

type Tail = &'a [A; 7]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a [A; 9]

type Head = &'a A

type Tail = &'a [A; 8]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a [A; 10]

type Head = &'a A

type Tail = &'a [A; 9]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a [A]

We treat slices as infinite lists of Option<Item>s.

type Head = Option<&'a A>

type Tail = &'a [A]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a (A,)

type Head = &'a A

type Tail = ()

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a mut [A; 1]

type Head = &'a mut A

type Tail = &'a mut [A; 0]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a mut [A; 2]

type Head = &'a mut A

type Tail = &'a mut [A; 1]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a mut [A; 3]

type Head = &'a mut A

type Tail = &'a mut [A; 2]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a mut [A; 4]

type Head = &'a mut A

type Tail = &'a mut [A; 3]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a mut [A; 5]

type Head = &'a mut A

type Tail = &'a mut [A; 4]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a mut [A; 6]

type Head = &'a mut A

type Tail = &'a mut [A; 5]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a mut [A; 7]

type Head = &'a mut A

type Tail = &'a mut [A; 6]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a mut [A; 8]

type Head = &'a mut A

type Tail = &'a mut [A; 7]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a mut [A; 9]

type Head = &'a mut A

type Tail = &'a mut [A; 8]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a mut [A; 10]

type Head = &'a mut A

type Tail = &'a mut [A; 9]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a mut [A]

We treat slices as infinite lists of Option<Item>s.

type Head = Option<&'a mut A>

type Tail = &'a mut [A]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A> Cons for &'a mut (A,)

type Head = &'a mut A

type Tail = ()

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B> Cons for &'a (A, B)

type Head = &'a A

type Tail = (&'a B,)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B> Cons for &'a mut (A, B)

type Head = &'a mut A

type Tail = (&'a mut B,)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B, C> Cons for &'a (A, B, C)

type Head = &'a A

type Tail = (&'a B, &'a C)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B, C> Cons for &'a mut (A, B, C)

type Head = &'a mut A

type Tail = (&'a mut B, &'a mut C)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B, C, D> Cons for &'a (A, B, C, D)

type Head = &'a A

type Tail = (&'a B, &'a C, &'a D)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B, C, D> Cons for &'a mut (A, B, C, D)

type Head = &'a mut A

type Tail = (&'a mut B, &'a mut C, &'a mut D)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B, C, D, E> Cons for &'a (A, B, C, D, E)

type Head = &'a A

type Tail = (&'a B, &'a C, &'a D, &'a E)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B, C, D, E> Cons for &'a mut (A, B, C, D, E)

type Head = &'a mut A

type Tail = (&'a mut B, &'a mut C, &'a mut D, &'a mut E)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B, C, D, E, F> Cons for &'a (A, B, C, D, E, F)

type Head = &'a A

type Tail = (&'a B, &'a C, &'a D, &'a E, &'a F)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B, C, D, E, F> Cons for &'a mut (A, B, C, D, E, F)

type Head = &'a mut A

type Tail = (&'a mut B, &'a mut C, &'a mut D, &'a mut E, &'a mut F)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B, C, D, E, F, G> Cons for &'a (A, B, C, D, E, F, G)

type Head = &'a A

type Tail = (&'a B, &'a C, &'a D, &'a E, &'a F, &'a G)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B, C, D, E, F, G> Cons for &'a mut (A, B, C, D, E, F, G)

type Head = &'a mut A

type Tail = (&'a mut B, &'a mut C, &'a mut D, &'a mut E, &'a mut F, &'a mut G)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B, C, D, E, F, G, H> Cons for &'a (A, B, C, D, E, F, G, H)

type Head = &'a A

type Tail = (&'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B, C, D, E, F, G, H> Cons for &'a mut (A, B, C, D, E, F, G, H)

type Head = &'a mut A

type Tail = (&'a mut B, &'a mut C, &'a mut D, &'a mut E, &'a mut F, &'a mut G, &'a mut H)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B, C, D, E, F, G, H, I> Cons for &'a (A, B, C, D, E, F, G, H, I)

type Head = &'a A

type Tail = (&'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B, C, D, E, F, G, H, I> Cons for &'a mut (A, B, C, D, E, F, G, H, I)

type Head = &'a mut A

type Tail = (&'a mut B, &'a mut C, &'a mut D, &'a mut E, &'a mut F, &'a mut G, &'a mut H, &'a mut I)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B, C, D, E, F, G, H, I, J> Cons for &'a (A, B, C, D, E, F, G, H, I, J)

type Head = &'a A

type Tail = (&'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'a, A, B, C, D, E, F, G, H, I, J> Cons for &'a mut (A, B, C, D, E, F, G, H, I, J)

type Head = &'a mut A

type Tail = (&'a mut B, &'a mut C, &'a mut D, &'a mut E, &'a mut F, &'a mut G, &'a mut H, &'a mut I, &'a mut J)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A> Cons for &'a mut &'b mut [A; 1]

type Head = &'b mut A

type Tail = &'b mut [A; 0]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A> Cons for &'a mut &'b mut [A; 2]

type Head = &'b mut A

type Tail = &'b mut [A; 1]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A> Cons for &'a mut &'b mut [A; 3]

type Head = &'b mut A

type Tail = &'b mut [A; 2]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A> Cons for &'a mut &'b mut [A; 4]

type Head = &'b mut A

type Tail = &'b mut [A; 3]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A> Cons for &'a mut &'b mut [A; 5]

type Head = &'b mut A

type Tail = &'b mut [A; 4]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A> Cons for &'a mut &'b mut [A; 6]

type Head = &'b mut A

type Tail = &'b mut [A; 5]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A> Cons for &'a mut &'b mut [A; 7]

type Head = &'b mut A

type Tail = &'b mut [A; 6]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A> Cons for &'a mut &'b mut [A; 8]

type Head = &'b mut A

type Tail = &'b mut [A; 7]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A> Cons for &'a mut &'b mut [A; 9]

type Head = &'b mut A

type Tail = &'b mut [A; 8]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A> Cons for &'a mut &'b mut [A; 10]

type Head = &'b mut A

type Tail = &'b mut [A; 9]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A> Cons for &'a mut &'b mut (A,)

type Head = &'b mut A

type Tail = ()

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A, B> Cons for &'a mut &'b mut (A, B)

type Head = &'b mut A

type Tail = (&'b mut B,)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A, B, C> Cons for &'a mut &'b mut (A, B, C)

type Head = &'b mut A

type Tail = (&'b mut B, &'b mut C)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A, B, C, D> Cons for &'a mut &'b mut (A, B, C, D)

type Head = &'b mut A

type Tail = (&'b mut B, &'b mut C, &'b mut D)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A, B, C, D, E> Cons for &'a mut &'b mut (A, B, C, D, E)

type Head = &'b mut A

type Tail = (&'b mut B, &'b mut C, &'b mut D, &'b mut E)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A, B, C, D, E, F> Cons for &'a mut &'b mut (A, B, C, D, E, F)

type Head = &'b mut A

type Tail = (&'b mut B, &'b mut C, &'b mut D, &'b mut E, &'b mut F)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A, B, C, D, E, F, G> Cons for &'a mut &'b mut (A, B, C, D, E, F, G)

type Head = &'b mut A

type Tail = (&'b mut B, &'b mut C, &'b mut D, &'b mut E, &'b mut F, &'b mut G)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A, B, C, D, E, F, G, H> Cons for &'a mut &'b mut (A, B, C, D, E, F, G, H)

type Head = &'b mut A

type Tail = (&'b mut B, &'b mut C, &'b mut D, &'b mut E, &'b mut F, &'b mut G, &'b mut H)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A, B, C, D, E, F, G, H, I> Cons for &'a mut &'b mut (A, B, C, D, E, F, G, H, I)

type Head = &'b mut A

type Tail = (&'b mut B, &'b mut C, &'b mut D, &'b mut E, &'b mut F, &'b mut G, &'b mut H, &'b mut I)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<'b, 'a: 'b, A, B, C, D, E, F, G, H, I, J> Cons for &'a mut &'b mut (A, B, C, D, E, F, G, H, I, J)

type Head = &'b mut A

type Tail = (&'b mut B, &'b mut C, &'b mut D, &'b mut E, &'b mut F, &'b mut G, &'b mut H, &'b mut I, &'b mut J)

fn uncons(self) -> (Self::Head, Self::Tail)

impl<A> Cons for [A; 1]

type Head = A

type Tail = [A; 0]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<A> Cons for [A; 2]

type Head = A

type Tail = [A; 1]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<A> Cons for [A; 3]

type Head = A

type Tail = [A; 2]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<A> Cons for [A; 4]

type Head = A

type Tail = [A; 3]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<A> Cons for [A; 5]

type Head = A

type Tail = [A; 4]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<A> Cons for [A; 6]

type Head = A

type Tail = [A; 5]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<A> Cons for [A; 7]

type Head = A

type Tail = [A; 6]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<A> Cons for [A; 8]

type Head = A

type Tail = [A; 7]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<A> Cons for [A; 9]

type Head = A

type Tail = [A; 8]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<A> Cons for [A; 10]

type Head = A

type Tail = [A; 9]

fn uncons(self) -> (Self::Head, Self::Tail)

impl<A> Cons for (A,)

type Head = A

type Tail = ()

fn uncons(self) -> (Self::Head, Self::Tail)

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

type Head = A

type Tail = (B,)

fn uncons(self) -> (Self::Head, Self::Tail)

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

type Head = A

type Tail = (B, C)

fn uncons(self) -> (Self::Head, Self::Tail)

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

type Head = A

type Tail = (B, C, D)

fn uncons(self) -> (Self::Head, Self::Tail)

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

type Head = A

type Tail = (B, C, D, E)

fn uncons(self) -> (Self::Head, Self::Tail)

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

type Head = A

type Tail = (B, C, D, E, F)

fn uncons(self) -> (Self::Head, Self::Tail)

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

type Head = A

type Tail = (B, C, D, E, F, G)

fn uncons(self) -> (Self::Head, Self::Tail)

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

type Head = A

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

fn uncons(self) -> (Self::Head, Self::Tail)

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

type Head = A

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

fn uncons(self) -> (Self::Head, Self::Tail)

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

type Head = A

type Tail = (B, C, D, E, F, G, H, I, J)

fn uncons(self) -> (Self::Head, Self::Tail)

Implementors