変更ログ 2.072.0

カンマ式はしばしば混乱やバグの原因となることが判明している。 例はこちらを参照のこと。

カンマ式の結果を使用すると、非推奨メッセージが表示されるようになった。

例:":

void main () {
  // OK、インクリメントの結果は直接使用されない
  for (int i, j; i != 3; i++, j++) {...}

  auto r1 = getRange!int, r2 = getRange!int;
  // OK
  for (; !r1.empty && !r2.empty; r1.popFront, r2.popFront) {...}
  // 非推奨 - ループ条件が常に使われる
  for (; !r1.empty, !r2.empty; r1.popFront, r2.popFront) {...}

  MyContainerClass mc;
  // OK - 表現式、結果は使用されない
  if (!mc)
    (mc = new MyContainerClass), mc.append(new Entry);

  int i;
  // 非推奨
  mc = (i++, new MyContainerClass);
}

暗黙のcatch文は、型を指定しないcatch文である。 これらはデフォルトでThrowable をキャッチする。

例:":

int[] arr = new int[](10);
// これはRangeErrorをスローする
try { arr[42]++; }
catch { writeln("An error was caught and ignored"); }
// 前の行は以下と等価である:
// catch (Throwable) { writeln("An error was caught and ignored"); }

文字列リテラルの暗黙的な連結は非常に初期の機能であり、現在では連結演算子('~')に取って代わられている。 連結演算子('~')に取って代わられた。

その結果、配列式でカンマを見逃してしまうという見つけにくいバグが発生する可能性がある:

void foo ()
{
  string[] arr = [ "Hello", "buggy" "World" ];
  assert(arr.length == 3); // 失敗、配列の長さは2、中身は[ "Hello", "buggyWorld" ]
}

ポストブリット(this(this))、デストラクタ( )、または不変量( )を持つフィールドをユニオンの中に持つことができるようになった、 デストラクタ(~this())、または不変量(invariant())を持つフィールドを共用体に持つことが許されるようになった。 実際に正しいフィールドをデストラクトまたはブリットするのはプログラマーの義務である。 プログラマーの義務である。

例:

struct S { this(this) {} ~this() {} }
union U
{
    int var;
    S s;
}

unittest
{
    U u; // uがスコープ外に出てもs.~thisを呼び出さない
    u = U(); // メモリをコピーするだけなので、代わりにフィールド単位の代入を使う
    u.s = S(); // 通常の構造体代入のように動作する
    destroy(u.s); // 現在使われているフィールドを破棄する
}

例:

version (D_LP64)
    enum n = 8;
else
    enum n = 4;
align (n) struct Data
{
align (n == 8 ? 2 : 1):
    ubyte[3] buffer;
    int flags;
}

version (D_LP64)
    static assert(Data.flags.offsetof == 4);
else
    static assert(Data.flags.offsetof == 3);

間接表現を持たないコピーされた値パラメータに対して、scope のストレージクラスが無視されるようになった。

例::

import std.traits;
void valueParam(scope int param);
static assert(ParameterStorageClassTuple!valueParam[0] == ParameterStorageClass.none);
void scopeParam(scope int* param);
static assert(ParameterStorageClassTuple!scopeParam[0] == ParameterStorageClass.scope_);

コンパイラがアップデートされ、OS Xの64ビット版コンパイル時にネイティブのスレッド・ローカル・ストレージ (TLS) を使用するように更新された。つまり C/C++のTLS変数とリンクできることを意味する。この変更はABI を破壊する変更であり、ライブラリーの再コンパイルが必要になる。

コンパイラと生成されたバイナリを実行するために最低限必要なバージョンは、Mac OS X Lion (10.7)である。 Mac OS X Lion (10.7)である。

Xcode 7.3には、いくつかのTLS変数に対してリンカー・エラーを引き起こすバグがある。 Xcode 7.3.1ではこのバグが修正されている。7.3より古いバージョンでも同様に動作する。

例:

module lib;
template ExpensiveApiImpl(int ver)
{
    ...
    void func() {}
    pragma(msg, "instantiated ExpensiveApiImpl ", ver);
}
alias api1 = ExpensiveApiImpl!(1);
alias api2 = ExpensiveApiImpl!(2);

import lib;
void main()
{
    // OK、"instantiated ExpensiveApiImpl 1"と表示される
    api1.func();

    // インスタンス化された"instantiated ExpensiveApiImpl 2"と表示されない、
    // エイリアス名'api2'が使われていないからだ。
}

特殊キーワード"__FILE_FULL_PATH__"は、コンパイラによって現在のソース・ファイルの絶対パスに置き換えられる。 に置き換えられる。

例:":

import std.stdio;
import std.path;
import std.file;
void main()
{
    writeln("The main source file lives here: ", __FILE_FULL_PATH__);
    writeln("The contents are:");
    foreach(line; File(__FILE_FULL_PATH__, "r").byLine) {
        writeln(line);
    }
    writeln();
    writeln("Other files in the same directory are:");
    foreach(entry; dirEntries(__FILE_FULL_PATH__.dirName, SpanMode.shallow)) {
        writefln("  - %s", entry.name);
    }
}

次のような投機的コンパイルによるエラーを表示する:

void foo(int i)
{
    int p;
    bool b = __traits(compiles, { p = &i; });
}

通常は表示されない:

(spec:1) test.d(13): Error: cannot implicitly convert expression (& i) of type int* to int

spec: の後の数字は、投機的コンパイルのネストである。

これは、TypeInfo.init を削除するためのステップである。 型プロパティinitとの名前の衝突を解決するために必要である。

代わりにTypeInfo.initializerを使用する。

モジュールのサイクルが検出されたときのデフォルトの動作は、サイクルを表示し、実行を中断することである。 を表示し、実行を中断することである。しかし、多くの場合、サイクル は有害ではない。新しい--DRT-oncycle スイッチを使えば、サイクルが検出されたときに サイクルが検出されたときに

--DRT-oncycle=abort

これはデフォルトの動作であり、最初のサイクルが検出されると、stderr にサイクルを表示して中断する。

--DRT-oncycle=print

検出されたすべてのサイクルをstderr にプリントするが、実行は停止しない。初期化の順序は、バイナリ内のモジュールの順序に基づいて任意に選択される。

--DRT-oncycle=ignore

何も表示せず、実行を停止しない。初期化の順序は、バイナリ内のモジュールの順序に基づいて任意に選択される。

extern(C) __gshared string[] rt_options = [ "oncycle=ignore" ];

std.digest.murmurhashの実装が追加された。MurmurHashは 一般的なハッシュベースの検索に適した非暗号化ハッシュ関数である。これは に最適化されている。

// 便利なダイジェストテンプレートを使って、int型配列の32ビットハッシュ値を計算する。
import std.digest.murmurhash;

ubyte[4] hashed = digest!MurmurHash3_32_opt32([1, 2, 3, 4]);

以前のPosixシステムでは、 が存在しない場合、3から最大ファイル記述子番号までのすべてのファイル記述子を閉じようとしていた。 inheritFDs を閉じようとする。 がspawnProcess 、pipeProcess などで指定されていない場合、Posixシステムは3から最大ファイル記述子番号までのすべてのファイル記述子を閉じようとした。 std.process現在は、poll() を使用して、どのディスクリプタを閉じる必要があるかを判断する。 ディスクリプタをクローズする必要がある。

std.algorithm.iteration.cumulativeFold入力範囲の連続する を返す。

assert([1, 2, 3, 4, 5].cumulativeFold!((a, b) => a + b).array == [1, 3, 6, 10, 15]);
assert([1, 2, 3].cumulativeFold!((a, b) => a + b)(100).array == [101, 103, 106]);

std.range.padLeftそして std.range.padRightは以下の関数である。 は、指定された要素を使用して指定された長さに範囲をパディングする関数である。

import std.range;
import std.algorithm.comparison;

assert([1, 2, 3, 4, 5].padLeft(0, 7).equal([0, 0, 1, 2, 3, 4, 5]));

assert("Hello World!".padRight('!', 15).equal("Hello World!!!!"));

import std.regex;
// マルチパターン正規表現
auto multi = regex([`\d+,\d+`,`(a-z]+):(\d+)`]);
auto m = "abc:43 12,34".matchAll(multi);
assert(m.front.whichPattern == 2);
assert(m.front[1] == "abc");
assert(m.front[2] == "43");
m.popFront();
assert(m.front.whichPattern == 1);
assert(m.front[1] == "12");

import std.regex;
import std.algorithm.comparison : equal;

auto pattern = regex(`([\.,])`);
assert("2003.04.05"
    .splitter!(No.keepSeparators)(pattern)
    .equal(["2003", "04", "05"]));
assert("2003.04.05"
    .splitter!(Yes.keepSeparators)(pattern)
    .equal(["2003", ".", "04", ".", "05"]));

std.numeric.findLocalMin実関数f(x) の実数最小値を括弧付けによって求める。

import std.numeric, std.math;

auto ret = findLocalMin((double x) => (x-4)^^2, -1e7, 1e7);

assert(ret.x.approxEqual(4.0));
assert(ret.y.approxEqual(0.0));

ptr プロパティは、 'の下位ポインタや範囲にアクセスできる。 プロパティを使う前に の の内部バイナリ表現を参照すること。 プロパティはSlice std.experimental.ndslice.slice.Slice ptr "@property"で使用される。 プロパティを使用する。 Mirのdeveloper mirrorは LDC(LLVMのDコンパイラ)がDバージョン2.072をサポートし次第、Mirのdeveloper mirrorは削除される。 ndslice

Slice 、パブリックコンストラクタが追加された。 std.experimental.ndslice 統合 を追加した。

import std.experimental.ndslice;

// ハッシュ値は、割り当てられたデータでも生成されたデータでも同じである
auto a = iotaSlice(3, 7);
auto b = iotaSlice(3, 7).slice;

assert(a.toHash == b.toHash);

これらのユーティリティ関数は次のように追加された。 std.experimental.ndslice:

• std.experimental.ndslice.slice.makeNdarray,
• std.experimental.ndslice.slice.makeSlice,
• std.experimental.ndslice.slice.makeUninitializedSlice,
• std.experimental.ndslice.slice.ndarray,
• std.experimental.ndslice.slice.shape,
• std.experimental.ndslice.slice.slice,
• std.experimental.ndslice.slice.uninitializedSlice.

例":を使った一般的な2次元配列の転置ndslice

import std.experimental.ndslice;

auto ar = [[0, 1, 2], [3, 4, 5]];

auto sh = ar.shape;         // [2, 3]型のsize_t[2]は、
auto sl = slice!int(sh);    // 対応する形状のスライスを確保する
sl[] = ar;                  // arからの値でslを埋める
ar = sl.transposed.ndarray; // 共通の2次元配列を確保する

assert(ar == [[0, 3], [1, 4], [2, 5]]);

import std.experimental.ndslice;

auto matrix = slice!double([2, 2], 0);
auto stringMatrixView = matrix.as!string;
assert(stringMatrixView ==
        [["0", "0"],
         ["0", "0"]]);

matrix.diagonal[] = 1;
assert(stringMatrixView ==
        [["1", "0"],
         ["0", "1"]]);

std.experimental.ndslice.selection.iotaSlice は最速である 。Slice

import std.experimental.ndslice;

auto sl = iotaSlice([2, 3], 10);

assert(sl.transposed == [[10, 13],
                         [11, 14],
                         [12, 15]]);

import std.experimental.ndslice;

auto slice = indexSlice(2, 3);

assert(slice == [[[0, 0], [0, 1], [0, 2]],
                 [[1, 0], [1, 1], [1, 2]]]);

import std.experimental.ndslice;

auto sl = iotaSlice(3).repeatSlice(4);
assert(sl == [[0, 1, 2],
              [0, 1, 2],
              [0, 1, 2],
              [0, 1, 2]]);

auto m = 4.repeatSlice(2, 3);
assert(m == [[4, 4, 4],
             [4, 4, 4]]);

import std.experimental.ndslice;

auto s = iotaSlice(2, 3).mapSlice!(a => a * a);
assert(s == [[ 0,  1,  4],
             [ 9, 16, 25]]);

import std.experimental.ndslice;

auto sl = iotaSlice(3, 4);

assert(sl[2, 3] == 11); // DとCのインデックス順序
assert(sl(3, 2) == 11); // MathとFortranのインデックス順序

std.algorithm.mutation.swapAtの要素を入れ替えることができる。 の要素を入れ替えることができる。

std.range.iota'の.length プロパティは常に次のように返されるようになった。 size_t. つまり、32ビットCPUで を使用している場合、長さはsize_t に切り捨てられる。 非リリースモードでは、 への呼び出しで長さが size_t.max iota を超えると例外が発生する。

std.algorithm.searching.minElementそして std.algorithm.searching.maxElement は範囲の最小値と最大値を検索する関数である。 要素を検索する関数である。これらはカスタムアクセサ(map )をサポートしている。

import std.algorithm.searching;
import std.range;
import std.typecons;
assert([3, 1, 4].minElement == 1);
assert([4, 7, 5].enumerate.maxElement!`a.value` == tuple(1, 7));

std.math.quantizeある数値の最も近い倍数に丸める。 特徴

• 丸め方はrfunc パラメータで指定できる。デフォルトでは デフォルトでは、現在の丸めモードが使用される。 「である。
• ある基数のN桁目を丸める一般的なケースについては、オーバーロードが含まれている。 桁に丸める場合のオーバーロードが含まれている。
• コンパイル時に基数と指数(桁数)がわかっていれば、テンプレート・パラメータとして与えることができる。 をテンプレート・パラメータとして与えることができる。

import std.math;

assert(12345.6789L.quantize(20.0L) == 12340.0L);
assert(12345.6789L.quantize!(10, -2) == 12345.68L);
assert(12345.6789L.quantize!(10, floor)(-2) == 12345.67L);

std.traits.isType, std.traits.isFunctionおよび std.traits.isFinalがstd.traits に追加された。

import std.traits;

static assert(isType!int);

struct S {}
class C {}
interface I {}

static assert(isType!S);
static assert(isType!C);
static assert(isType!I);

import std.traits;

void func(){}
struct S
{
    @property int prop(){ return 0; }
}

static assert(isFunction!func);
static assert(isFunction!(S.prop));

// デリゲート型であり、関数型ではない
static assert(!isFunction!(typeof(&S.prop)));

import std.traits;

class C
{
    void nf() {}
    final void ff() {}
}
final class FC {}

static assert(!isFinal!(C));
static assert( isFinal!(FC));
static assert(!isFinal!(C.nf));
static assert( isFinal!(C.ff));

std.range.generateが呼び出されるたびに異なる値を返すように設定されていた。 front さらに、popFront は何もしなかった。これはつまり のような操作関数は何もしなかった。 std.range.dropなどの操作関数は何もしなかった。新しい 新しいバージョンでは、範囲定義の期待に応えるため、1要素のキャッシュを使用している。 定義の期待に応えるために1要素のキャッシュを使用する。また、ジェネレーターのref-nessも維持している。

std.experimental.typecons.Finalは直接変異させることはできない。 しかし、参照は元の変異可能性で型付けされる。 これは Javaのfinal 、C#のreadonly に相当する。

auto a = makeFinal([1, 2, 3]);
assert(a[0] == 1);

// a = [2, 3]; // 再代入は不正である、
a[0] = 42; // 要素やフィールドは依然として変更可能である。

assert(a[0] == 42);

他のクラスの内部に入れ子になっている(関数の内部にはない)クラスは、 シンボルを定義していない。 outer シンボルを定義していないクラスは、outer フィールドを持つ。 フィールドがあり、入れ子になっている外側のクラスのインスタンスを取得したり、設定したりすることができる。 std.traits.isInnerClassこれにより、それらを識別することができる。を満たす "型"のサブセットである。 isInnerClass を満たす型は、isNested を満たす型のサブセットである。 を満たす型のサブセットである。後者には、outer を再定義したり、関数の中に入れ子になったクラスや構造体が含まれる。

class Outer
{
    class Inner1 { }
    class Inner2
    {
        int outer; // outerを再定義しているため、Outerインスタンスにはアクセスできない
    }
    static class Inner3 {}  // 静的なので入れ子にならない
}
static assert(isInnerClass!(Outer.Inner1));
static assert(!isInnerClass!(Outer.Inner2));
static assert(!isInnerClass!(Outer.Inner3));

クラスが他のクラスの中に入れ子になっている場合(新しいトレイトがある std.traits.isInnerClassがある)、emplace 。 が必須パラメータとして追加された。この この変更以前は、配置にこのパラメータは必要なく、外側のクラスの変数にアクセスするとセグメンテーション・フォールトが発生した。 の変数にアクセスすると、セグメンテーション・フォールトが発生した。

class Outer
{
    int x;
    class Inner
    {
        auto getX() { return x; }
    }
}
Outer outer = new Outer();

// auto inner = buf.emplace!(Outer.Inner)();   // これはもう許されない
auto inner = buf.emplace!(Outer.Inner)(outer); // 代わりにこれを使う

auto x = inner.getX();  // これはsegmentation faultを引き起こしていた;
                        // 現在は期待通りに動作する

これにより、プログラム起動時にGCを選択できるようになった。

./my_d_exe --DRT-gcopt=gc:conservative # use conservative GC (default)
./my_d_exe --DRT-gcopt=help # list available GC options

gcoptの詳細についてはgc_configを参照のこと。

将来のリリースでは、別のGCとリンクすることで を拡張できるはずである。

--DRT-gc=gc:manual オプションを使用して手動 GC を選択する。

このGCはmallocとfreeの薄いラッパーであり、ガベージを収集しない。 ガベージを収集しない。このGCは GC.free. 配列やデリゲートのような、GCメモリを確保する可能性のある組込みの言語構文は、リークする可能性がある。 のような組み込みの言語構造はリークする可能性がある。 これはgcstubの実装に取って代わるものである。

手動GCは、メモリを決定論的に制御するアプリケーションに有用である。 リークする可能性のある隠れた割り当てを追跡するには、dmdの-vgc スイッチを使う。

valgrindのようなツールでメモリ破壊を見つけるのにも役に立つ。