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
123
124
125
126
127
128
129
130
131
132
133
134
135
|
template AliasSeq(T...) { alias AliasSeq = T; }
template Unqual(T)
{
static if (is(T U == const U))
alias Unqual = U;
else static if (is(T U == immutable U))
alias Unqual = U;
else
alias Unqual = T;
}
template staticMap(alias F, T...)
{
alias A = AliasSeq!();
static foreach (t; T)
A = AliasSeq!(A, F!t); // what's tested
alias staticMap = A;
}
alias TK = staticMap!(Unqual, int, const uint);
//pragma(msg, TK);
static assert(is(TK == AliasSeq!(int, uint)));
/**************************************************/
template reverse(T...)
{
alias A = AliasSeq!();
static foreach (t; T)
A = AliasSeq!(t, A); // what's tested
alias reverse = A;
}
enum X2 = 3;
alias TK2 = reverse!(int, const uint, X2);
//pragma(msg, TK2);
static assert(TK2[0] == 3);
static assert(is(TK2[1] == const(uint)));
static assert(is(TK2[2] == int));
/**************************************************/
template Tp(Args...)
{
alias Tp = AliasSeq!(int, 1, "asd", Args);
static foreach (arg; Args)
{
Tp = AliasSeq!(4, Tp, "zxc", arg, Tp, 5, 4, int, Tp[0..2]);
}
}
void fun(){}
alias a1 = Tp!(char[], fun, x => x);
static assert(
__traits(isSame, a1, AliasSeq!(4, 4, 4, int, 1, "asd", char[], fun,
x => x, "zxc", char[], int, 1, "asd", char[], fun, x => x,
5, 4, int, int, 1, "zxc", fun, 4, int, 1, "asd", char[],
fun, x => x, "zxc", char[], int, 1, "asd", char[], fun,
x => x, 5, 4, int, int, 1, 5, 4, int, 4, int, "zxc", x => x,
4, 4, int, 1, "asd", char[], fun, x => x, "zxc", char[],
int, 1, "asd", char[], fun, x => x, 5, 4, int, int, 1,
"zxc", fun, 4, int, 1, "asd", char[], fun, x => x, "zxc",
char[], int, 1, "asd", char[], fun, x => x, 5, 4, int, int,
1, 5, 4, int, 4, int, 5, 4, int, 4, 4)));
template Tp2(Args...)
{
alias Tp2 = () => 1;
static foreach (i; 0..Args.length)
Tp2 = AliasSeq!(Tp2, Args[i]);
}
const x = 8;
static assert(
__traits(isSame, Tp2!(2, float, x), AliasSeq!(() => 1, 2, float, x)));
enum F(int i) = i * i;
template staticMap2(alias fun, args...)
{
alias staticMap2 = AliasSeq!();
static foreach (i; 0 .. args.length)
staticMap2 = AliasSeq!(fun!(args[i]), staticMap2, fun!(args[i]));
}
enum a2 = staticMap2!(F, 0, 1, 2, 3, 4);
struct Cmp(T...){}
// isSame sucks
static assert(is(Cmp!a2 == Cmp!(16, 9, 4, 1, 0, 0, 1, 4, 9, 16)));
template Tp3()
{
alias aa1 = int;
static foreach (t; AliasSeq!(float, char[]))
aa1 = AliasSeq!(aa1, t);
static assert(is(aa1 == AliasSeq!(int, float, char[])));
alias aa2 = AliasSeq!int;
static foreach (t; AliasSeq!(float, char[]))
aa2 = AliasSeq!(aa2, t);
static assert(is(aa2 == AliasSeq!(int, float, char[])));
alias aa3 = AliasSeq!int;
aa3 = AliasSeq!(float, char);
static assert(is(aa3 == AliasSeq!(float, char)));
}
alias a3 = Tp3!();
template Tp4() // Uses slow path because overload
{
alias AliasSeq(T...) = T;
alias AliasSeq(alias f, T...) = T;
alias aa4 = int;
aa4 = AliasSeq!(aa4, float);
static assert(is(aa4 == AliasSeq!(int, float)));
}
alias a4 = Tp4!();
template Tp5() // same tp overloaded, still uses fast path
{
alias AliasSeq2(T...) = T;
alias AliasSeq = AliasSeq2;
alias AliasSeq = AliasSeq2;
alias aa5 = int;
aa5 = AliasSeq!(aa5, float);
static assert(is(aa5 == AliasSeq!(int, float)));
}
alias a5 = Tp5!();
|
