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);
}