変更ログ 2.065.0

Posixシステムでは、拡張子なしファイルの先頭にshebang行があると便利なことが多い、 Posixシステムでは、スクリプトのコンパイルに使用したツールを示すshebang行を拡張子なしファイルの先頭に置くと便利なことがよくある。このテクニックをDでも使えるようになった。 以下は、"my-script" というファイル名のDソース・ファイルである:

#!rdmd

void main()
{
}

注釈:Dソースファイルは適切なD識別子である必要があるため、任意の拡張子を使用することはできない。

注釈:Windowsには拡張子のない実行ファイルがないため、この機能はWindowsでは利用できない。

注釈:コンパイル時に、デフォルトの動作である を生成するデフォルトの動作を避けるためである。 を生成するデフォルトの動作を避けるため、コンパイラーは代わりに"a.out"を生成する。

非常に長い間、以下のコードは誤って許可されていたが、現在は禁止されている:

import std.stdio;

void main()
{
    goto Label; // エラー: gotoは変数vの宣言をスキップする

    int v = 42;

Label:
    writeln(v);
}

関数がどのように直接、間接的にインスタンス化されたかに関係なく、その属性は推論される:

struct S(T)
{
    T square(T x)
    {
        T calc()
        {
            return x * x;
        }
        return calc();
    }

    static double pi() { return 3.141592; }
}

void main() pure @safe nothrow
{
    S!int s;

    // S!int.squareとその入れ子関数calcはインスタンス化された関数であるため、
    // それらの属性は純粋でmain()から呼び出し可能であると推測される。
    assert(s.square(2) == 4);  // OK

    // staticメンバ関数の属性も推論されるようになった
    auto pi = typeof(s).pi();
}

これまでは、immutable(T) とinout(T) の共通型は次のようになっていた。 const(T).しかし、これではinout の情報が失われ、有効なコードが拒否される可能性がある。 現在では、型はinout(const(T)) となり、適切な型修飾子を意味を持って伝播する。

inout(const(int))[] foo(bool condition, inout(int)[] x, immutable(int)[] y)
{
    static assert(is(typeof(condition ? x : y) == inout(const(int))[]));
    return condition ? x : y;
}

void main()
{
    int[] marr = [1,2,3];
    const(int)[] carr = [4,5,6];
    immutable(int)[] iarr = [7,8,9];

    // inout(const(int))[]は、const(int)[]またはimmutable(int)[]に戻ることができる。
    static assert(is(typeof(foo(true, marr, iarr)) == const(int)[]));
    static assert(is(typeof(foo(true, carr, iarr)) == const(int)[]));
    static assert(is(typeof(foo(true, iarr, iarr)) == immutable(int)[]));
}

Bugzilla 8244型が有効な場所では'[]'でタプルをスライスすることはできない:

import std.typetuple;
alias Types = TypeTuple!(int, double, string);

// 2.064ではエラーだったが、2.065からは許されるようになった。
alias Types2 = Types[];
static assert(is(Types == Types2));

Bugzilla 9081:モジュールは型を持つべきではない。

import std.stdio;

// 2.064ではどちらも'void'と表示されていた。
// 2.065からはどちらも"has no type"エラーになる。
pragma(msg, typeof(std));
pragma(msg, typeof(std.stdio));

変化することによって、かつて使われていた慣用句が機能するようになった。 is(typeof(package_or_module_name)) が使えないように変更された。代わりに次のように使う:__traits(compiles, package_or_module_name).

最終的には、オブジェクトのスペースを占有するために変更されるだろう。そのようなフィールドはenumかstaticに変更すべきである。 2.063のリリースノートも参照のこと。

これに関連して、voidで初期化されたconstフィールドや不変のフィールドが、予定よりも早くオブジェクト・インスタンス内のスペースを占めるようになった。 は、オブジェクト・インスタンス内のスペースを予定より早く占有するようになる:

struct S
{
    const int[1000] x = void;

    this(int n)
    {
        // 2.064では許可されていなかった。
        // 2.065からxはランタイム・オブジェクトのフィールドになった。
        x[] = n;
    }
}

// 2.064では、S.sizeofは1であった。
// 2.065から、フィールドs.xはオブジェクトのスペースを占める。
static assert(S.sizeof == int.sizeof * 1000);

void main()
{
    S s = S(3);

    foreach (e; s.x)
    {
        assert(e == 3); // OK
    }
}

Bugzilla 10369:非順序浮動小数点比較の廃止

Bugzilla 10439:float.min, double.min, real.min を非推奨とする。

コード例:

union U
{
    size_t x;
    int* y;
}

bool test()
{
    U u;
    assert(u.x == 0);
    // ここで、u.yを読むとCTFEエラーになる。

    u.y = [1,2,3].ptr;
    // オーバーラップしたフィールドu.yに値を書き込むと、対応するフィールドu.xが無効になる。

    assert(u.y[0..3] == [1,2,3]);
    // u.yは有効なフィールドを保持しており、読み出しは許可されている
    // ここで、u.xを読むとCTFEエラーになる。

    u.x = 10;
    // u.xに値を設定し直す。
    assert(u.x == 10);  // OK
    // ここでu.yを読むとCTFEエラーになる。

    return true;
}
static assert(test());  // CTFEを実行する

CTFE中、オーバーラップした2つの共用体フィールドを用いたビットイメージの再解釈は許されない。

新しいgetAliasThis 特性は、集約型のサブタイプとしてマークされたフィールド名のタプルを返す。 フィールド名のタプルを返す。 例:

struct S
{
    string var;
    alias var this;
}

static assert(__traits(getAliasThis, S)[0] == "var");

注釈:Dでは多重部分型はまだ実装されていないため、このトレイトは常に長さ1のタプルを返す。 長さ1のタプルを返す。

これは正しく実装されておらず、曖昧さの原因となっていた。

例: 構造体コンストラクタとstatic opCallを混在させることはできなくなった:

struct S
{
    this(int i) {}

    static S opCall()   // コンストラクタにより許可されない
    {
        return S.init;
    }
}

注釈:static opCall を使って、引数のない構造体コンストラクタをシミュレートすることができる。 コンストラクタを引数なしでシミュレートするために使うこともできるが、これは推奨されない。 推奨されない。その代わりに、構造体インスタンスを生成するファクトリー関数 関数を使うことである。

次のような関数がある。 any, all, canFind そして equalなどの関数がテンプレートになった。 他のテンプレートへの述語として使用することができ、また、ユーザーがそのようなテンプレートのインスタンス化のエイリアスを作成することもできる。 ユーザー・コードでどのように構文を変化させることができるかの例として、次の例を挙げよう。 プログラマーは、文字列配列のすべての文字列が少なくとも1つのASCII桁を持つかどうかをチェックしたい:

import std.algorithm : all;
import std.ascii : isDigit;

void main()
{
    string[] inputs = ["foo1", "bar2"];

    bool allContainDigit;
    foreach (input; inputs)
    {
        if (!any!isDigit(input))  // どの文字もASCII数字ではない
        {
            allContainDigit = false;
            break;
        }
    }
}

しかし、any テンプレートそのものを述語として使う方が単純になった。 別の便利なテンプレート、all テンプレートの述語にすることができる:

import std.algorithm : any, all;
import std.ascii : isDigit;

void main()
{
    string[] inputs = ["foo1", "bar2"];
    bool allContainDigit = all!(any!isDigit)(inputs);
}

これらの関数が述語になることに加えて、エイリアスもできるようになった、 これにより、関数をより理解しやすくすることができる:

import std.algorithm : any, all;
import std.ascii : isDigit;

void main()
{
    alias isAnyDigit = any!isDigit;  // 視覚的ノイズが少なく、自己記述関数である

    string[] inputs = ["foo1", "bar2"];
    bool allContainDigit = all!isAnyDigit(inputs);  // 理解しやすくなる

    alias doAllContainDigits = all!isAnyDigit;  // または、アルゴリズム全体を1つのシンボルにまとめる!

    assert( doAllContainDigits(["1", "a 1", "b 2"]));  // 自己記述コード
    assert(!doAllContainDigits(["c", "a 1", "b 2"]));
}

もちろん、all とany 、さまざまな組み合わせが可能だ。例: を逆にして、代わりに文字列配列中の文字列のどれかがすべての数字を含むかどうかをチェックしたい場合、コードは次のようになる。 の文字列がすべての数字を含むかどうかをチェックしたい場合、コードは次のようになる:

import std.algorithm : any, all;
import std.ascii : isDigit;

void main()
{
    alias areAllDigits = all!isDigit;

    alias areAnyIntegrals = any!areAllDigits;

    assert( areAnyIntegrals(["123", "456"]));
    assert( areAnyIntegrals(["abc", "123"]));  // "123"は数字である
    assert(!areAnyIntegrals(["abc", "def123"])); // "def123"は実際には数字ではない
}

一方、文字列配列のすべての文字列がすべての数字を含むようにしたい場合は、次のようになる。 を含むようにしたい場合は、次のようになる:

import std.algorithm : any, all;
import std.ascii : isDigit;

void main()
{
    alias areAllDigits = all!isDigit;

    alias allStringsDigits = all!areAllDigits;

    assert( allStringsDigits(["123", "456"]));
    assert(!allStringsDigits(["abc", "123"]));  // "123"は数字だが、"abc"は数字ではない
}

に暗黙的に変換される範囲内の全ての項目にマッチさせたい場合、述語を渡す必要がなくなる。 true に暗黙的に変換する:

import std.algorithm;

void main()
{
    auto arr1 = [true, true, true];
    assert( all(arr1));  // すべての値が真である

    auto arr2 = [false, true, true];
    assert(!all(arr2));  // すべての値は真ではない

    auto arr3 = [1, 2, 3];
    assert( all(arr3));  // すべての値が真に変換される

    auto arr4 = [0, 2, 3];
    assert(!all(arr4));  // すべての値は真に変換されない
}

補完的な高次の範囲で、graphemesに対する範囲操作を可能にする:

import std.array : array;
import std.range : retro;
import std.string : text;
import std.uni : byCodePoint, byGrapheme;

void main()
{
    string s = "noe\u0308l"; // noël
    // 逆にし、結果をUTF-8に戻す
    string reverse = s.byGrapheme()
        .array() // 注釈: byGraphemeは将来双方向性をサポートする予定である
        .retro()
        .byCodePoint()
        .text();

    assert(reverse == "le\u0308on"); // lëon
}

onlyを複数の引数で使えるようにした:

import std.algorithm : joiner;
import std.range : equal, only;

void main()
{
    assert(only("one", "two", "three").joiner(" ").equal("one two three"));
}

さらに、only() 、空のレンジを手に入れることができるようになった。

win32でデフォルトのOptlinkリンカーを使用する場合(32ビット・オブジェクト・ファイルと実行可能ファイルをリンクする場合)、 /LARGEADDRESSAWARE オプションは、アプリケーションが2ギガバイト以上のアドレスを扱えることをリンカに知らせる。 これは Visual C のこれはVisual Cの の同名のリンカー・オプションと同等である。 これはオペレーティング・システムの機能であり、実行ファイルに特定のフラグを設定することで有効になる。