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!();