std.typecons

このモジュールは、様々な型コンストラクタ -- つまり、新しい汎用の型を構築するテンプレートを実装しています。

Synopsis:

// 値タプル
alias Tuple!(float, "x", float, "y", float, "z") Coord;
Coord c;
c.field[1] = 1;  // インデックスによるアクセス
c.z = 1;          // 指定された名前によるアクセス
alias Tuple!(string, string) DicEntry; // 名前は省略可能

// 文字列から/への変換によるenumの定義
mixin(defineEnum!("Openmode", "READ", "WRITE", "READWRITE", "APPEND"));
void foo()
{
    Openmode m = Openmode.READ;
    string s = enumToString(m);
    assert(s == "READ");
    Openmode m1;
    assert(enumFromString(s, m1) && m1 == m);
}

// const/immutableオブジェクトへの、再束縛可能な参照
void bar()
{
    const w1 = new Widget, w2 = new Widget;
    w1.foo();
    // w1 = w2 はダメ; constオブジェクトは再束縛できない
    auto r = Rebindable!(const Widget)(w1);
    // r があたかもWidgetオブジェクトであるかのようにメソッド呼び出し
    r.foo();
    // r が他のオブジェクトを指すよう再束縛
    r = w2;
}

License:
Boost License 1.0.

Authors:
Andrei Alexandrescu, Bartosz Milewski, Don Clugston

struct Unique(T);

リソースの唯一の所有権をカプセル化します。所有権が移動してない限り、型Tを持つリソースが、スコープの終わりと同時に破棄されます。所有権の移動は release による明示も、関数から Unique を返す暗黙の移動も可能です。リソースは多相的に振る舞うクラスオブジェクトであってもよく、その場合は Unique も多相的に振る舞います。

Example:

this(RefT p);

右辺値をとるコンストラクタ。指定された右辺値が（キャストなどによる）単なる左辺値のビューである場合を除き、 uniqueness を保証します。典型的な使い方:

	Unique!(Foo) f = new Foo;

this(ref RefT p);

左辺値を取るコンストラクタ。コピー元をnullにします。元の左辺値にさらに別のエイリアスが存在しない限り、このnull化によって所有権のuniquenessが保証されます。

Unique release();

ユニークな右辺値を返します。Uniqueオブジェクトの保持する内容はnullになります。

RefT opDot();

保持するオブジェクトへのメンバアクセスを転送します。

struct Tuple(T...);

値のタプル。例えば Tuple!(int, string) は int と string を格納したレコードです。Tuple は複数の値をまとめて、特に関数から複数の値を返すのに使うことができます。obj がタプルなら、個々のメンバは先頭要素なら obj.field[0]、次の要素なら obj.field[1] 、等々の構文でアクセスできます。

１始まりではなく０始まりの記法を選択した理由は、タプルをコンパイル時のループ対象として（型タプル上のiterationのように）自然に扱えるようにするためです。

Example:

Tuple!(int, int) point;
// 座標を代入
point.field[0] = 5;
point.field[1] = 6;
// 座標の読み取り
auto x = point.field!(0);
auto y = point._1;

Tuple のメンバには名前をつけることができます。名前ありと名前無しのメンバを混ぜても構いません。この場合も、上記の添え字によるアクセスは常に全てのフィールドについて可能です。

Example:

alias Tuple!(int, "index", string, "value") Entry;
Entry e;
e.index = 4;
e.value = "Hello";
assert(e.field[1] == "Hello");
assert(e.field[0] == 4);

名前付きタプルと名前なしタプルは異なる型として扱われます。つまり、フィールドの名前が違うと違うタプル型になります。フィールド名だけが違うタプルも、構造自体は同じですが、型としては違う物になります。

Example:

Tuple!(int, "x", int, "y") point1;
Tuple!(int, int) point2;
assert(!is(typeof(point1) == typeof(point2))); // passes

alias Types;

タプルの要素型のリスト（型タプル）です。

template __ctor(U...) if (U.length == Types.length)

フィールドそれぞれにつき１つずつ値を受け取るコンストラクタです。各々の引数は対応する要素型に代入可能である必要があります。

template __ctor(U)

互換性のある別のタプルを受け取るコンストラクタです。対応する要素それぞれが代入可能である必要があります。

template opEquals(T) if (is(typeof(T.field)))

同値性判定。

bool opEquals(T rhs);: 同値性判定。

template opCmp(T) if (is(typeof(T.field)))

順序判定

int opCmp(T rhs);: 順序判定

template opAssign(U) if (is(typeof(U.init.field[0])))

別のタプルからの代入。変換元のタプルのそれぞれの要素が、変換先の対応するフィールドへ代入可能である必要があります。

void opAssign(U rhs);: 別のタプルからの代入。変換元のタプルのそれぞれの要素が、変換先の対応するフィールドへ代入可能である必要があります。

template slice(uint from,uint to)

タプルのスライスを取得します。

Example:

Tuple!(int, string, float, double) a;
a.field[1] = "abc";
a.field[2] = 4.5;
auto s = a.slice!(1, 3);
static assert(is(typeof(s) == Tuple!(string, float)));
assert(s.field[0] == "abc" && s.field[1] == 4.5);

string toString();

文字列への変換。

Tuple!(T) tuple(T...)(T args);

渡された引数でインスタンス化および初期化された Tuple オブジェクトを返します。

Example:

auto value = tuple(5, 6.7, "hello");
assert(value.field[0] == 5);
assert(value.field[1] == 6.7);
assert(value.field[2] == "hello");

template defineEnum(string name,T...)

真の名前付き列挙値を、 parseと文字列化のプリミティブ付きで定義します。

Example:

mixin(defineEnum!("Abc", "A", "B", 5, "C"));

これは以下のコードと同等です:

enum Abc { A, B = 5, C }
string enumToString(Abc v) { ... }
Abc enumFromString(string s) { ... }

enumToString 関数は、列挙値の被修飾名 "A", "B", "C" などを生成します。enumFromString 関数は "A", "B", "C" を受け取るとその値を返し、それ以外の文字列に対しては例外を投げます。

基底型は次のように指定します:

mixin(defineEnum!("Abc", ubyte, "A", "B", "C", 255));

この場合、生成された enum は ubyte 表現を持つことになります。

template Rebindable(T) if (is(T : Object) || isArray!(T))

Rebindable!(T) は、 T 型のオブジェクトと同じように振る舞うシンプルで効率的なラッパです。ただし、Rebindableは途中で別のオブジェクトを指すように再代入が可能です。完全性を期すために、T が非constオブジェクト型の場合は、 Rebindable!(T) は単なる T へのaliasとなります。 T がそもそもクラス型でない場合は、Rebindable!(T) はコンパイルエラーとなります。

通常の const オブジェクト参照は再代入ができません：

class Widget { int x; int y() const { return a; } }
const a = new Widget;
a.y();          // 大丈夫
a.x = 5;        // エラー。const a は変更できない
a = new Widget; // エラー。const a は変更できない

しかしここで、Rebindable!(Widget) は最代入可能で、その他の場面では const Widget とまったく同様に振る舞います:

auto a = Rebindable!(const Widget)(new Widget);
a.y();          // 大丈夫
a.x = 5;        // エラー。const a は変更できない
a = new Widget; // 大丈夫

const オブジェクトへの書き換え可能な参照が必要な場合に、Rebindable を使用すると良いでしょう。たとえば、 inplace でconst参照をsortしたい場合などです。Rebindable が D の型システムの健全性を壊すことはなく、 cast の使用などに見られる類の危険もありません。

char[] alignForSize(E...)(string[E.length] names);

指定されたメンバ宣言リストを、alignmentを保ったままでサイズが最小になるように並び替えます。 mixinできる宣言リストを返します。

Example:

struct Banner {
  mixin(alignForSize!(byte[6], double)(["name", "height"]));
}

80-bit 実数と、align(1) で宣言された構造体に関しては、必ずしも最適な整列を行うとは限りません。

BUG:
bugzilla 2029 のため、(string[] names...) という引数リスト宣言ができません。このため、現在のところ醜い配列リテラルを使う必要があります。