flatten 0.2.2

Tuple flatteing for rust.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

#![doc(hidden)]

pub mod fix;
use self::fix::Fix;

/// `Cons` or `Nil`.
pub trait Node: Sized {
    type ConsHead;
    type ConsTail: Node;
}
impl Node for Nil {
    type ConsHead = Nil;
    type ConsTail = Nil;
}
impl<H, T: Node> Node for Cons<H, T> {
    type ConsHead = H;
    type ConsTail = T;
}

pub type AsCons<N> = Cons<<N as Node>::ConsHead, <N as Node>::ConsTail>;

/// Everything **except** `Cons` and `Nil`.
pub auto trait ValidHead {}
impl !ValidHead for Nil {}
impl<H, T> !ValidHead for Cons<H, T> {}

/// Fixed node.
pub trait ValidNode: Node + Fix<Fixed = Self> {}
impl ValidNode for Nil {}
impl<Head: ValidHead, Tail: ValidNode> ValidNode for Cons<Head, Tail> {}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct Cons<H, T: Node> {
    pub head: H,
    pub tail: T,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct Nil;

///Appends a value to end of `Cons`.
///
///# Notes for Nil
///
///As Nil is treated as a something like zero,
///
///```rust,ignore
/// 
/// Nil + Nil = Nil
/// Nil + Cons<H, T> = Cons<H, T>
/// ```
pub trait Append<Tail: ValidNode> {
    type Output: ValidNode;

    fn append(self, tail: Tail) -> Self::Output;
}

impl<T: ValidNode> Append<T> for Nil {
    type Output = T;

    #[inline(always)]
    fn append(self, t: T) -> Self::Output {
        t
    }
}

impl<Head, Tail, NewTail> Append<NewTail> for Cons<Head, Tail>
where
    Head: ValidHead,
    Tail: Node + Append<NewTail>,
    NewTail: ValidNode,
{
    type Output = Cons<Head, Concat<Tail, NewTail>>;
    #[inline(always)]
    fn append(self, tail: NewTail) -> Self::Output {
        Cons {
            head: self.head,
            tail: self.tail.append(tail),
        }
    }
}

impl<Value, Tail> Append<Tail> for Value
where
    Value: ValidHead,
    Tail: ValidNode,
{
    type Output = Cons<Value, Tail>;
    #[inline(always)]
    fn append(self, tail: Tail) -> Self::Output {
        Cons { head: self, tail }
    }
}
pub type Concat<Head, Tail> = <Head as Append<Tail>>::Output;

macro_rules! Cons {
    [
        $t:ty
    ] => {
        $crate::cons::Cons<$t, $crate::cons::Nil>
    };

    [
        $t:ty,
    ] => {
        $crate::cons::Cons<$t, $crate::cons::Nil>
    };

    [
        $t:ty,
        $ ($rest:ty,) *
    ] => {
        Cons<$t, Cons![ $( $rest, )* ]>
    };

    [
        $t:ty,
        $ ($rest:ty), *
    ] => {
        Cons<$t, Cons![ $( $rest, )* ]>
    };
}