39用d编程是表达式

a is b是操作符.is(...)是表达式.
是表达式,确定表达式是否为真.在static if和限制模板时特别有用.
is(T),确定T是个有效类型.

    static if (is (int)) {
        writeln("valid");

    } else {
        writeln("invalid");
    }

整数有效.void不能作为关联类型的键类型.

    static if (is (string[void])) {//假
        writeln("valid");

    } else {//真
        writeln("invalid");
    }

is (T Alias).是T,然后在语句块中用Alias

    static if (is (int NewAlias)) {
        writeln("valid");
        NewAlias var = 42; // int == NewAlias 

    } else {
        writeln("invalid");
    }

在有更复杂的is表达式中有用.
is (T : OtherT),T是否是个OtherT类型,或者T是否能转为OtherT类型.

import std.stdio;

interface Clock {
    void tellTime();
}

class AlarmClock : Clock {
    override void tellTime() {
        writeln("10:00");
    }
}

void myFunction(T)(T parameter) {
    static if (is (T : Clock)) {//如果是个`钟`
        writeln("这是钟;我们可告诉时间");
        parameter.tellTime();

    } else {
        writeln("这不是钟");
    }
}

void main() {
    auto var = new AlarmClock;
    myFunction(var);
    myFunction(42);
}

is (T Alias : OtherT),如果T/Alias可转为OtherT.
is (T == Specifier),如T为限定器类型,精确的类型.

    static if (is (T == Clock)) {//完全相同的钟
        writeln("这是钟;我们可讲时间");
        parameter.tellTime();

    } else {
        writeln("这不是钟");
    }

限定符可为struct union class interface enum function delegate const immutable shared

void myFunction(T)(T parameter) {
    static if (is (T == class)) {
        writeln("这是类类型");

    } else static if (is (T == enum)) {
        writeln("这是枚类型");

    } else static if (is (T == const)) {
        writeln("这是常类型");

    } else {
        writeln("这是其他类型");
    }
}

这是大致的限制.这样模板可根据不同参数类型而变化.
is (T 别名 == Specifier)
Specifier可为struct union class interface super enum function delegate return 双下划线parameters const immutable shared
只要类型满足这些限定符,就可以了.

    auto var = new AlarmClock;
    myFunction(var);

    // (enum WeekDays见下面)
    myFunction(WeekDays.Monday);

    const double number = 1.2;
    myFunction(number);myFunction(42);

定义些结构:

struct Point {
    // ...
}

interface Clock {
    // ...
}

class AlarmClock : Clock {
    // ...
}

enum WeekDays {
    Monday, Tuesday, Wednesday, Thursday, Friday,
    Saturday, Sunday
}

char foo(double d, int i, Clock c) {
    return 'a';
}

然后:

void myFunction(T)(T parameter) {
    static if (is (T LocalAlias == struct)) {
    //用不同限定符,相当于加了句`alias Loc... = T;
        writefln("\n--- struct ---");
        writefln("复制它来构造个新%s对象.",LocalAlias.stringof);
        LocalAlias theCopy = parameter;
    }
    static if (is (T baseTypes == super)) {
        writeln("\n--- super ---");
        //如果T为父(基)类型.
        writefln("class %s has %s base types.",
                 T.stringof, baseTypes.length);

        writeln("所有基: ", baseTypes.stringof);
        writeln("最高基: ", baseTypes[0].stringof);
    }

    static if (is (T ImplT == enum)) {
        writeln("\n--- enum ---");//T为枚举类型
        writefln("The implementation type of enum %s is %s",T.stringof, ImplT.stringof);
    }

    static if (is (T ReturnT == return)) {
        writeln("\n--- return ---");
        //函数返回类型指针
        writefln("带%s返回类型的函数:",ReturnT.stringof);
        writeln("    ", T.stringof);
        write("调用它... ");

        ReturnT result = parameter(1.5, 42, new AlarmClock);
        //T为返回类型
        writefln("结果为'%s'", result);
    }
}
//调用
    myFunction(Point());//构对象
    myFunction(new AlarmClock);// 类引用
    myFunction(WeekDays.Monday);// 枚举
    myFunction(&foo);//函数指针

is (/* ... */ Specifier, TemplateParamList)
四种语法:

is (T : Specifier, TemplateParamList)
is (T == Specifier, TemplateParamList)
is (T identifier : Specifier, TemplateParamList)
is (T identifier == Specifier, TemplateParamList)

:相当于继承,==完全相同,限定符,具体限定类型
模板参数列表,自身也是条件,如条件满足,也可定义额外别名,与推导模板类型一样

    static if (is (T == Value[Key],   // (1)
                   Value,             // (2)
                   Key : string)) {   // (3)

is需要满足是键为串的关联数组.
1,T为值[键]类型.
2,值为类型.
3,键为串类型.
示例:

import std.stdio;
void myFunction(T)(T parameter) {
    writefln("\n--- Called with %s ---", T.stringof);
    static if (is (T == Value[Key],Value,Key : string)) {
        //更多限制(,,,)
        writeln("Yes,满足条件.");
        writeln("value type: ", Value.stringof);
        writeln("key type  : ", Key.stringof);
    } else {
        writeln("No,不满足.");
    }
}

void main() {
    int number;myFunction(number);

    int[string] intTable;myFunction(intTable);

    double[string] doubleTable;
    myFunction(doubleTable);

    dchar[long] dcharTable;
    myFunction(dcharTable);
}