structural 0.4.3

Field accessor traits,and emulation of structural types.
Documentation 
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

/**

Type macro for a type-list.

This macro creates an ordered sequence of types,

# Example

This example is equivalent to `TList<String,TList<&'a str,TList<Cow<'a,str>,Nil>>>`.

```ignore
use structural::TList;

use std::borrow::Cow;

type StringsTypes<'a>=TList![ String,&'a str,Cow<'a,str> ];

# fn main(){}

```

*/
#[doc(hidden)]
macro_rules! TList {
    () => { $crate::type_level::TNil };
    (..$rest:ty) => { $rest };
    ($current:ty) => { TList![$current,] };
    ($elem_0:ty,$elem_1:ty,$elem_2:ty,$elem_3:ty,$elem_4:ty, $($rest:tt)*) => {
        $crate::type_level::TList<
            $elem_0,
            $crate::type_level::TList<
                $elem_1,
                $crate::type_level::TList<
                    $elem_2,
                    $crate::type_level::TList<
                        $elem_3,
                        $crate::type_level::TList<
                            $elem_4,
                            TList![$($rest)*]
                        >
                    >
                >
            >
        >
    };
    ($elem_0:ty,$elem_1:ty,$elem_2:ty,$elem_3:ty, $($rest:tt)*) => {
        $crate::type_level::TList<
            $elem_0,
            $crate::type_level::TList<
                $elem_1,
                $crate::type_level::TList<
                    $elem_2,
                    $crate::type_level::TList<
                        $elem_3,
                        TList![$($rest)*]
                    >
                >
            >
        >
    };
    ($elem_0:ty,$elem_1:ty,$elem_2:ty, $($rest:tt)*) => {
        $crate::type_level::TList<
            $elem_0,
            $crate::type_level::TList<
                $elem_1,
                $crate::type_level::TList<
                    $elem_2,
                    TList![$($rest)*]
                >
            >
        >
    };
    ($elem_0:ty,$elem_1:ty, $($rest:tt)*) => {
        $crate::type_level::TList<
            $elem_0,
            $crate::type_level::TList<
                $elem_1,
                TList![$($rest)*]
            >
        >
    };
    ($current:ty, $($rest:tt)*) => {
        $crate::type_level::TList<$current,TList![$($rest)*]>
    };
}

/**

Instantiates a type-list,
which is a zero-sized-type which does not contain instances of the types it lists.

# Example

```ignore
use structural::{tlist,TList};

use std::borrow::Cow;

fn main(){

    const STRINGS:
        TList![ String,&str,Cow<str> ]=
        tlist![ String,&str,Cow<str> ];

}

```


*/
#[macro_export]
#[doc(hidden)]
macro_rules! tlist {
    ($($all:tt)*) => {
        <TList!($($all)*)>::NEW
    };
}