mirror of
https://github.com/dlang/dmd.git
synced 2025-04-26 21:21:48 +03:00
135 lines
3.5 KiB
D
135 lines
3.5 KiB
D
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!();
|