unittest
{
    alias Options = NamedArgsT!(NamedArg!(TypeT, "T"), NamedArg!(TypeT, "T2",
            float), NamedArg!(int, "t1", 0), NamedArg!(string, "t2", null),
            NamedArg!(AliasT, "t3", Alias!0));
    static assert(!Options.Complete);
    static assert(!__traits(hasMember, Options, "T"));
    static assert(is(Options.T2 == float));
    static assert(Options.t1 == 0);
    static assert(Options.t2 == null);
    static assert(Options.t3 == 0);
    alias Opt1 = Options.set_T!int.set_t1!(4).set_t3!(Alias!20);
    static assert(Opt1.Complete);
    static assert(is(Opt1.T == int));
    static assert(is(Opt1.T2 == float));
    static assert(Opt1.t1 == 4);
    static assert(Opt1.t2 == null);
    static assert(Opt1.t3 == 20);
}

import std.traits;
import std.meta;

struct NamedArg(specs...)
{
    enum Instantiated = false;
    static assert(specs.length == 2 || specs.length == 3);
    static assert(is(specs[0]));
    alias Type = specs[0];
    static assert(is(typeof(specs[1]) == string));
    enum Name = specs[1];
    static if (specs.length == 3)
    {
        enum HasValue = true;
        static if (is(Type == AliasT) || is(Type == TypeT))
        {
            alias Value = specs[2];
        }
        else
        {
            enum Value = specs[2];
        }
    }
    else
    {
        enum HasValue = false;
    }
}

struct InstantiatedNamedArg(specs...)
{
    enum Instantiated = true;
    enum HasValue = true;
    static assert(specs.length == 3);
    static assert(is(specs[0]));
    alias Type = specs[0];
    static assert(is(typeof(specs[1]) == string));
    enum Name = specs[1];
    static if (is(Type == AliasT) || is(Type == TypeT))
    {
        alias Value = specs[2];
    }
    else
    {
        enum Value = specs[2];
    }
}

struct AliasT;
struct TypeT;

mixin template NamedArgMembers(Arg)
{
    static if (Arg.HasValue)
    {
        static if (is(Arg.Type == AliasT) || is(Arg.Type == TypeT))
        {
            mixin("alias " ~ Arg.Name ~ " = " ~ fullyQualifiedName!Arg ~ ".Value;");
        }
        else
        {
            mixin("enum " ~ Arg.Name ~ " = " ~ fullyQualifiedName!Arg ~ ".Value;");
        }
    }
}

struct NamedArgsT(Args...)
{
    private template IsNotT(T)
    {
        private enum IsNotT(U) = !is(T == U);
    }

    static foreach (i, Arg; Args)
    {
        mixin NamedArgMembers!Arg;
        static if (!Arg.Instantiated)
        {
            static if (is(Arg.Type == TypeT))
            {
                mixin("alias set_" ~ Arg.Name ~ "(__setNamedArgVal) = NamedArgsT!(InstantiatedNamedArg!("
                        ~ fullyQualifiedName!(Arg) ~ ".Type, " ~ fullyQualifiedName!(
                            Arg) ~ ".Name, __setNamedArgVal), Filter!(IsNotT!(" ~ fullyQualifiedName!(
                            Arg) ~ "), Args));");
            }
            else static if (is(Arg.Type == AliasT))
            {
                mixin("alias set_" ~ Arg.Name ~ "(alias __setNamedArgVal) = NamedArgsT!(InstantiatedNamedArg!("
                        ~ fullyQualifiedName!(Arg) ~ ".Type, " ~ fullyQualifiedName!(
                            Arg) ~ ".Name, __setNamedArgVal), Filter!(IsNotT!(" ~ fullyQualifiedName!(
                            Arg) ~ "), Args));");
            }
            else
            {
                mixin("alias set_" ~ Arg.Name ~ "(" ~ fullyQualifiedName!(
                        Arg) ~ ".Type __setNamedArgVal) = NamedArgsT!(InstantiatedNamedArg!(" ~ fullyQualifiedName!(
                        Arg) ~ ".Type, " ~ fullyQualifiedName!(
                        Arg) ~ ".Name, __setNamedArgVal), Filter!(IsNotT!(" ~ fullyQualifiedName!(
                        Arg) ~ "), Args));");
            }
        }
    }

    private enum HasValue(T) = T.HasValue;
    enum Complete = allSatisfy!(HasValue, Args);
}