Re: As discussed in DConf2015: Python-like keyword arguments

[Atila Neves via Digitalmars-d]

Compile-time version for when crazy people like me pass in values 
as template parameters:

import std.stdio;
import std.array;
import std.typetuple;
import std.traits;


struct Foo { int i; }
struct Bar { int i; }
struct Baz { int i; }


void func(Foo foo = Foo(11), Bar bar = Bar(22), Baz baz = 
Baz(33))() {
    writeln("foo is ", foo);
    writeln("bar is ", bar);
    writeln("baz is ", baz);
}

void main() {
    ctKwargs!(func, Bar(2), Baz(3), Foo(1));
    writeln;
    ctKwargs!(func, Baz(3), Foo(1));
}


auto ctKwargs(alias F, T...)() {
    enum strArgs = getStrArgs!(F, T);
    mixin("return F!(" ~ strArgs.join(",") ~ ")();");
}

template typesMatch(alias T) {
    enum isRightType(alias U) = is(typeof(T) == typeof(U));
}


auto getStrArgs(alias F, T...)() {
    string[] strArgs;
    mixin("alias defaults = TemplateArgsOf!(" ~ 
F.stringof[0..$-2] ~ "!());");

    foreach(value; defaults) {
        enum ofRightType = Filter!(typesMatch!value.isRightType, 
T);
        static assert(ofRightType.length == 0 || 
ofRightType.length == 1,
                      text("Invalid type tuple ", T));
        static if(ofRightType.length == 1) {
            strArgs ~= ofRightType[0].stringof;
        } else {
            strArgs ~= value.stringof;
        }
    }

    return strArgs;
}