変更ログ 2.064

module libweb.client;

void runClient() { }

module libweb.server;

void runServer() { }

module libweb;

public import libweb.client;
public import libweb.server;

module test;

import libweb;

void main()
{
    startServer();
    startClient();
}

module libweb.utils;  // "utils"だけでなく、パッケージの完全修飾名を指定する!

// 'libweb.utils'パッケージからモジュールをpublicインポートする。
public import libweb.utils.conv;
public import libweb.utils.text;

module test;

import libweb.utils;

void main()
{
}

template Tuple(T...) { alias Tuple = T; }

template isIntOrFloat(T)
{
    static if (is(T == int) || is(T == float))
        enum isIntOrFloat = true;
    else
        enum isIntOrFloat = false;
}

void main()
{
    alias Tup = Tuple!(int, float, string);
    static assert(isIntOrFloat!(Tup[0]));  // intはintまたはfloatである
    static assert(isIntOrFloat!(Tup[1]));  // floatはintまたはfloatである
    static assert(!isIntOrFloat!(Tup[2])); // stringはintでもfloatでもない
}

alias Tuple(T...) = T;

enum isIntOrFloat(T) = is(T == int) || is(T == float);

void main()
{
    alias Tup = Tuple!(int, float, string);
    static assert(isIntOrFloat!(Tup[0]));  // intはintまたはfloatである
    static assert(isIntOrFloat!(Tup[1]));  // floatはintまたはfloatである
    static assert(!isIntOrFloat!(Tup[2])); // 文字列はintでもfloatでもない
}

class Server
{
    this(string[] args) { }
    void run() { }
}

void main(string[] args)
{
    (new Server(args)).run();
}

class Server
{
    this(string[] args) { }
    void run() { }
}

void main(string[] args)
{
    new Server(args).run();
}

class Server
{
    this() { }
    void run() { }
}

void main()
{
    new Server.run();    // エラー
    new Server().run();  // OK
}

IFTIが改良され、以下のようなコードが書けるようになった:

struct A
{
    struct Foo { }
}

struct B
{
    struct Foo { }
}

/**
テンプレート化された関数で、
第2引数が'T'型にネストされた'Foo'型であることを想定している。
*/
void call(T)(T t, T.Foo foo) { }

void main()
{
    auto a = A();
    auto a_f = A.Foo();
    call(a, a_f);  // OK

    auto b = B();
    auto b_f = B.Foo();
    call(b, b_f);  // OK

    call(a, b_f);  // 失敗: b_fはA.FooではなくB.Fooとして型付けされている
}

このIFTI機能により、シンボルのモジュールを、型パラメータではなくalias このIFTI機能により、型パラメータではなくテンプレート・パラメータを使ってシンボルのモジュールを取得することもできる:

module my_module;

struct A
{
    struct B { }
}

void foo(alias Mod)(Mod.A, Mod.A.B)
{
    // 'Mod'は構造体'A'を囲むモジュール'my_module'であると推論される
    static assert(__traits(isSame, Mod, my_module));
}

void main()
{
    A a;
    A.B b;
    foo(a, b);  // OK
}

これはドキュメント化された関数の例で、パラメータ名が間違ってドキュメント化されている:

/**
    これがsum関数である。

    params:
        x = 1番目のパラメータ
        y = 2番目のパラメータ
*/
int sum(int a, int b)
{
    return a + b;
}

警告を有効にしてドキュメントを生成すると、次のようになる:

dmd -D -c -w test.d

test.d(8): Warning: Ddoc: function declaration has no parameter 'x'
test.d(8): Warning: Ddoc: function declaration has no parameter 'y'

この機能は、ライブラリ・コードのドキュメントを常に最新に保つのに役立つ。

注釈: -D スイッチを使ってドキュメントを作成する場合は、-w スイッチを使うことを忘れないこと。 を使用することを忘れないこと。

文字列をヌル終端ポインタとして期待するCライブラリとのやりとりを容易にする、 文字列をヌル終端ポインタとして期待する C ライブラリとの相互作用を容易にするために、文字列literals (変数ではない!) をスライスすると、そのようなポインタへの暗黙の変換が可能になった:

extern(C) void call(const(char)* str) { }

void main()
{
    const(char)* abc = "abc";
    call(abc);  // 以前は許可されていた

    const(char)* ab = "abc"[0 .. 2];
    call(ab);   // 2.064では許可されている
}

auto foo(int n) { return 1; }
auto foo(T)(T t) { return 2; }

void main()
{
    assert(foo(100) == 1);
    assert(foo("a") == 2);

    // 整数リテラル10Lは、精度を失うことなくintに変換できる。
    // そして、呼び出しはfoo(int n)にマッチする。
    assert(foo(10L) == 1);

    // long型の実行時変数'num'は暗黙的にint型に変換できない。
    // この場合、呼び出しはfoo(T)(T t)にマッチする。
    long num = 10L;
    assert(foo(num) == 2);
}

テンプレート化された関数は、通常の関数宣言と同様にオーバーロードできるようになった。複数のモジュールの名前が一致するテンプレートは、オーバーロードセットを導入する:

module a;

template Traits(T) if (is(T == double))
{
    enum Traits = "abc";
}

auto func(T, A...)(A args) if (is(T == double))
{
    return 1;
}

module b;

template Traits(T) if (is(T == string))
{
    enum Traits = "def";
}

auto func(T, A...)(A args) if (is(T == string))
{
    return 2;
}

module c;
import a, b;
static assert(Traits!double == "abc");  // a.Traitsにマッチする
static assert(Traits!string == "def");  // b.Traitsにマッチする
void main()
{
    assert(func!double(1, "msg") == 1);  // a.func(T, A...)にマッチする
    assert(func!string(1, "msg") == 2);  // b.func(T, A...)にマッチする
}

制限事項:

エイリアス宣言を使ったテンプレートのオーバーロード・セットのマージは現在サポートされていない。 この制限は将来のリリースで解除される予定だ。

ファイル名を指定しなくても-deps スイッチを使えるようになった。 依存関係は標準出力に出力され、ユーザーとツールの両方が出力から依存関係を調べることができる。 が出力される。

出力される依存関係の型は以下の通りである:

depsImport:モジュールのインポートが見つかった (-deps=file 出力と同じ。ただし、先頭に depsImport が付く)。

depsVersion:バージョン(標準のものとモジュール自体に設定されているものを除く。)

depsFile:見つかったインポート文字列(例:string x = import("foo.txt");

depsLib:で指定されたライブラリpragma(lib) statement

depsDebug:見つかったdebug() 文(モジュール自体に設定されているものを除く)

新しいgetUnitTests 特性を使うと、モジュールや集合体のすべてのユニテストを検索し、手動でテストを実行することができる。 のすべての unittest を取得し、手動でテストを実行することができる。以下は、カスタムの実行例である。 を実装した例である:

import core.runtime;
import core.exception;
import std.stdio;

shared static this()
{
    // これは、デフォルトのDランタイムのユニットテストのランナー関数をオーバーライドする、
    // __traitsベースのものをメイン関数で提供しているからだ。
    Runtime.moduleUnitTester = { return true; };
}

unittest
{
    assert(1);  // 合格。
}

unittest
{
    assert(0);  // 失敗。
}

unittest
{
    assert(1);  // 合格。
}

void main()
{
    Throwable[] errors;  // スローされた例外をすべて収集する。
    size_t passCount;    // 合格したユニットテストの数を数える。

    // 各ユニテストを繰り返し処理する(これはタプルになる)。
    foreach (test; __traits(getUnitTests, my_module))
    {
        try
        {
            test();
            passCount++;
        }
        catch (Throwable error)
        {
            errors ~= error;
        }
    }

    // エラーや統計情報を出力する。
    if (errors.length)
    {
        writeln("Some unittests failed:\n");
        foreach (error; errors)
            writeln(error);
    }
    else
    {
        writefln("All unittests passed. Passed unittest count: %s", passCount);
    }
}

注釈:ユニテストを取得できるようにするには、-unittest フラグを付けてコンパイルする必要がある。

注釈:デフォルトでは、Dランタイムは独自のユニテスト実行関数を提供する。 実行時に(main関数が呼ばれる前に)この関数が呼び出されるのを避けたい場合は、以下のようにカスタム関数を設定する必要がある。 モジュールのコンストラクタでRuntime.moduleUnitTester 。 上記のテストケースで使われているものは、単にtrue を返すだけで、main 関数を呼び出すことができる。 関数が呼び出されるようにする。

注釈: getUnitTests トレイトは再帰的ではない。つまり、モジュール を呼び出すと、そのモジュール内のアグリゲートにネストされたユニテストは取得できない。

この trait を使用すると、仮想メソッドテーブル内の仮想メソッドのインデックスを取得できる:

class C
{
    void foo() { }
    void bar() { }
}

class D : C
{
    void doo() { }
    void doo(int) { }
    void doo(double) { }
}

void main()
{
    /**
        各クラスは暗黙のうちにObjectクラスを継承しているため、
        以下のクラスはインデックス0で始まらない可能性が高いことに注意しよう。
    */
    pragma(msg, __traits(getVirtualIndex, D.foo));
    pragma(msg, __traits(getVirtualIndex, D.bar));

    /**
        オーバーロードを扱う場合、getOverloadsトレイトを使えば、
        特定のメソッドをインデックスすることができる
    */
    pragma(msg, __traits(getVirtualIndex, __traits(getOverloads, D, "doo")[0]));
    pragma(msg, __traits(getVirtualIndex, __traits(getOverloads, D, "doo")[1]));
    pragma(msg, __traits(getVirtualIndex, __traits(getOverloads, D, "doo")[2]));
}

class Base
{
    void foo() { }
}

class Foo : Base
{
    override void foo() { }
    void bar() { }
}

static assert (__traits(isOverrideFunction, Base.foo) == false);
static assert (__traits(isOverrideFunction, Foo.foo)  == true);
static assert (__traits(isOverrideFunction, Foo.bar)  == false);

特定のインターフェイスの引数型を期待する関数でクラスが使えるようにしたいが、必ずしもそのインターフェイスを継承するようにクラスを編集したくない場合がある。 しかし、必ずしもそのインターフェイスを継承するようにクラスを編集したいわけではない。 また、そのクラスはソースコードを持っていない別のライブラリで実装されている可能性もある、 つまり、そのクラスの継承リストを編集することはできない。

新しい "wrap "関数を使えば、構造キャストを行うことができる。 あたかも別の型のオブジェクトであるかのように振る舞うことができる。例: (注釈: 今のところ、コンパイル時に-allinstフラグをdmdに渡してほしい):

import std.typecons;

interface IDrawable
{
    void drawLine(int x1, int y1, int x2, int y2);
}

class ImageDraw  // 注釈: IDrawableを継承しない。
{
    void drawLine(int x1, int y1, int x2, int y2) { }
}

/** Draw a rectangle outline. */
void drawRect(IDrawable draw)
{
    draw.drawLine(  0,   0, 100,   0);
    draw.drawLine(100,   0, 100, 100);
    draw.drawLine(  0, 100, 100, 100);
    draw.drawLine(  0,   0,   0, 100);
}

void main()
{
    auto imageDraw = new ImageDraw();
    drawRect(imageDraw);  // エラー: ImageDrawはIDrawableではないので呼び出せない。

    // 構造キャストを行う。
    IDrawable i = wrap!IDrawable(imageDraw);
    drawRect(i);  // これでimageDrawはIDrawableとして動作できる。
}

wrap 関数は、例えばopDispatch 関数を定義しているクラスでも使うことができる:

import std.typecons;

interface IDrawable
{
    void drawLine(int x1, int y1, int x2, int y2);
    void drawRect(int x, int y, int width, int height);
}

class ImageDraw
{
    void opDispatch(string name, Args...)(Args args)
        if (name == "drawLine")
    {
        // ...
    }

    void opDispatch(string name, Args...)(Args args)
        if (name == "drawRect")
    {
        // ...
    }
}

/** いくつかの図形を描く。 */
void drawShapes(IDrawable draw)
{
    draw.drawLine(0, 100, 100, 0);
    draw.drawRect(0, 0, 100, 100);
}

void main()
{
    auto imageDraw = new ImageDraw();
    IDrawable i = wrap!IDrawable(imageDraw);
    drawShapes(i);
}

構造キャストされたオブジェクトをアンラップして元の型に戻すことができる:

interface IDrawable
{
    void drawLine(int x1, int y1, int x2, int y2);
}

class ImageDraw
{
    void drawLine(int x1, int y1, int x2, int y2) { }
}

void main()
{
    auto imageDraw = new ImageDraw();

    // 構造キャストを実行する(単純なUFCS構文であることに注意)。
    IDrawable i = imageDraw.wrap!IDrawable;

    // 元の型を取得する(UFCS構文を使用して、同様)。
    ImageDraw draw = i.unwrap!ImageDraw;
}

また、複数のインターフェイス型に構造キャストすることもできる:

import std.typecons;

unittest
{
    interface IStoppable { void stop(); }
    interface IRunnable { void run(); }

    class Timer
    {
        void run() { }
        void stop() { }
    }

    auto timer = new Timer();
    auto obj = timer.wrap!(IStoppable, IRunnable);

    // ラップされた型から
    // 構造キャストされた型を取り出す。
    IStoppable iStop = obj;
    IRunnable  iRun  = obj;

    iRun.run();
    iStop.stop();
}

2.064以降、純粋関数はto とformat を利用できる。例:

import std.conv;
import std.string;

void main() pure  // このmainは純粋関数である。
{
    string date = format("%s.%s.%s", 2013, 12, 10);
    int one = to!int(1.0);
}

新しい汎用ストリップ関数を使えば、文字列だけでなく、その他の入力範囲もストリップできる。 (stripLeft) や双方向範囲 (strip/stripRight) もストリップできる:

import std.algorithm;

void main()
{
    // 空白を取り除く。
    assert("  foobar  ".strip!(a => a == ' ')() == "foobar");

    // 音声波形を取り出す。
    float[] data = [0.0, 0.0, 0.1, 0.5, 0.2];

    // 波形の先頭の無音部分を取り除く。
    assert(data.strip!(a => a < 0.1)().length == 3);
}

暗黙のメモリ割り当てを回避するため、translate のオーバーロードを導入した。 を取ることができるオーバーロードが追加された。例::

import std.array;
import std.string;

void main()
{
    dchar[dchar] transTable = ['a' : '1', 'b' : '2', 'c': '3'];

    // PhobosのAppenderを使って出力範囲を作成する。
    auto buffer = appender!(dchar[])();

    auto toRemove = null;  // 文字を削除しない。

    translate("abcdef", transTable, toRemove, buffer);
    assert(buffer.data == "123def");

    // もしくは、ヒープ割り当てを避けるために静的配列を使う。
    // 注釈: バッファが小さすぎると例外がスローされる。
    dchar[6] dbuffer;
    translate("abcdef", transTable, toRemove, dbuffer[]);
    assert(dbuffer == "123def");
}

thisExePath 関数を使用すると、現在の実行可能パスを取得できる:

import std.file;
import std.stdio;

void main(string[] args)
{
    // 現在実行中の実行ファイルのフルパスを表示する。
    // 注釈: これはargs[0]と同じかもしれないし、そうでないかもしれない。
    // args[0]の内容はアプリケーションの起動方法に依存するが、thisExePath()
    // は依存しない。また、コードのmain以外の部分からthisExePath()に
    // アクセスすることも可能である。
    writeln(thisExePath());
}

g"(=グローバル)フラグに基づく古いAPIは、混乱を招き、エラーを起こしやすかった。 さらに、"g"(=global)フラグがすでに関数によってオーバーライドされている場合もあった。 std.regex.splitter のように、すでに関数によってオーバーライドされている場合もあった。

新しいバージョンは、操作とその関数を結びつける。 新しいバージョンは、操作と関数を結びつけている。今のところ、"g"フラグはそのまま使用されている。 しかし新しいAPIは、適用可能な場合には常にそれを上書きする。新しい 新しいAPIに追加されたもう1つの機能は、replace 関数のオーバーロードである。 出力範囲を直接操作するためのオーバーロードである。

APIの違いを理解するために、以下の2つのサンプルを比較してみよう。

2.064以前

void main()
{
    import std.regex, std.algorithm, std.range, std.stdio, std.string;
    auto m = "3.141592".match(`(\d+)\.(\d+)`);
    // mは範囲である
    assert(m.front.equal(["3.141592", "3", "141592"]));

    // グローバル vs 非グローバル
    auto word = regex(`(\w)\w*`);
    auto gword = regex(`(\w)\w*`, "g");
    auto list = "tomatoes, potatoes, pineapple";
    // これは'tomatoes'だけを表示する、これは多くの問題を引き起こした
    foreach(item; list.match(word))
        writeln(item.hit);

    // while this will print each of them
    foreach(item; list.match(gword))
        writeln(item.hit);

    auto justFirst = replace!(m => toUpper(m[1]) ~ m[0].drop(1))(list, word);
    assert(justFirst == "Tomatoes, potatoes, pineapple");
    auto allOfThem = replace!(m => toUpper(m[1]) ~ m[0].drop(1))(list, gword);
    assert(allOfThem == "Tomatoes, Potatoes, Pineapple");
}

2.064以降:

void main()
{
    import std.regex, std.algorithm, std.range, std.stdio, std.string;
    auto m = "3.141592".matchFirst(`(\d+)\.(\d+)`);
    // mは単純にサブマッチの範囲である
    assert(m.equal(["3.141592", "3", "141592"]));

    auto word = regex(`(\w)\w*`);
    auto list = "tomatoes, potatoes, pineapple";
    // サブマッチを反復するので、2行表示される:
    // tomatoes
    // t
    foreach(item; list.matchFirst(word))
        writeln(item);
    // というように、マッチ全体を表示する:
    assert(list.matchFirst(word).hit == "tomatoes");

    // "g"オプションがあるかどうかをチェックする必要はない
    // 関数名を見れば一目瞭然だ
    foreach(item; list.matchAll(word))
        writeln(item.hit);

    auto justFirst = replaceFirst!(m => toUpper(m[1]) ~ m[0].drop(1))(list, word);
    assert(justFirst == "Tomatoes, potatoes, pineapple");
    auto allOfThem = replaceAll!(m => toUpper(m[1]) ~ m[0].drop(1))(list, word);
    assert(allOfThem == "Tomatoes, Potatoes, Pineapple");

    // 新機能 -  アロケートする必要がない場合、結果の文字列
    // 置換は直接ワイヤ(OutputRange)に送られる
    auto sink = stdout.lockingTextWriter();
    replaceAllInto!(m => toUpper(m[1]) ~ m[0].drop(1))(sink, list, word);
}

最終的には非推奨となる予定だが、古いAPIはまだ動作する。 また、*Into関数の形で、置換を出力範囲に直接転送する新しい機能にも注釈が必要である。 置換を直接出力範囲に転送し、ヒープへの余分な負荷を回避する *Into 関数という形の新機能にも注目してほしい。

ctRegex では、文字クラス内の集合代数を除き、ランタイムと同じ構文をすべてサポートしている。 代数を除いて、実行時の構文スペクトルをすべてサポートするようになった。例えば、以下のようにコンパイルして パスする:

void main()
{
    import std.regex;
    // 単語だが、タイトルケースのASCIIではない
    // ()内の?<!は"負のルックビハインド"を意味する
    auto pat = ctRegex!`\w+(?<![A-Z][a-z]*)`;
    assert(!"Hello".match(pat));
    assert("good_bay".match(pat));
}