struct Duration {
    int minute;
}

struct TimeOfDay {
    int hour;
    int minute;

    void increment(Duration duration) {
        minute += duration.minute;

        hour += minute / 60;
        minute %= 60;
        hour %= 24;
    }
}

void main() {
    auto lunchTime = TimeOfDay(12, 0);
    lunchTime.increment(Duration(10));
}

int weight = 50;
weight += 10;                       // 演算子による

auto lunchTime = TimeOfDay(12, 0);
lunchTime.increment(Duration(10));  // メンバー関数によって

lunchTime += Duration(10);          // 演算子による
                                    // (構造体でも)

struct TimeOfDay {
// ...
    ref TimeOfDay opOpAssign(string op)(Duration duration) // (1)
            if (op == "+") {                               // (2)

        minute += duration.minute;
        hour += minute / 60;
        minute %= 60;
        hour %= 24;

        return this;
    }
}

lunchTime += Duration(10);

// 次の行は、前の行と同じ意味である
lunchTime.opOpAssign!"+"(Duration(10));

++weight;

struct Duration {
    int minute;

    ref Duration opUnary(string op)()
            if (op == "++") {
        ++minute;
        return this;
    }
}

auto duration = Duration(20);
++duration;

/* 以前の値はコンパイラによって
 * 自動的にコピーされる: */
Duration __previousValue__ = duration;

/* ++演算子が呼び出される: */
++duration;

/* その後、__previousValue__が
 * 増分演算の値として使用される。 */

/* 式値は以下では使用されない。
 * 式の唯一の効果は'i'を加算することだ。 */
i++;

/* コンパイラが実際に使用する式: */
++i;

totalWeight = boxWeight + chocolateWeight;

x op y

// xが左側にある場合の定義:
x.opBinary!"op"(y);

// yが右側にある場合の定義:
y.opBinaryRight!"op"(x);

auto x = MyInt(42);
x + 1;    // opBinary!"+"を呼び出す
1 + x;    // opBinaryRight!"+"を呼び出す

x op y

struct Duration {
    int minute;

    ref Duration opUnary(string op)()
            if (op == "++") {
        ++minute;
        return this;
    }

    ref Duration opUnary(string op)()
            if (op == "--") {
        --minute;
        return this;
    }

    ref Duration opOpAssign(string op)(int amount)
            if (op == "+") {
        minute += amount;
        return this;
    }

    ref Duration opOpAssign(string op)(int amount)
            if (op == "-") {
        minute -= amount;
        return this;
    }
}

unittest {
    auto duration = Duration(10);

    ++duration;
    assert(duration.minute == 11);

    --duration;
    assert(duration.minute == 10);

    duration += 5;
    assert(duration.minute == 15);

    duration -= 3;
    assert(duration.minute == 12);
}

void main() {
}

struct Duration {
    int minute;

    ref Duration opUnary(string op)()
            if ((op == "++") || (op == "--")) {
        mixin (op ~ "minute;");
        return this;
    }

    ref Duration opOpAssign(string op)(int amount)
            if ((op == "+") || (op == "-")) {
        mixin ("minute " ~ op ~ "= amount;");
        return this;
    }
}

struct Duration {
// ...

    ref Duration opOpAssign(string op)(int amount)
        if ((op == "+") || (op == "-") ||
            (op == "*") || (op == "/")) {
        mixin ("minute " ~ op ~ "= amount;");
        return this;
    }
}

unittest {
    auto duration = Duration(12);

    duration *= 4;
    assert(duration.minute == 48);

    duration /= 2;
    assert(duration.minute == 24);
}

ref Duration opOpAssign(string op)(int amount)
        /* 制約なし */ {
    mixin ("minute " ~ op ~ "= amount;");
    return this;
}

int a = 1;
int b = 2;
int c = a + b;  // cは+演算子の戻り値によって
                // 初期化される

int i = 1;
writeln(++i);    // 2を表示

int i = 1;
writeln("The address of i                : ", &i);
writeln("The address of the result of ++i: ", &(++i));

bool opEquals()(auto ref const TimeOfDay rhs) const {
    // ...
}

x == y;
// 前の式と同等:
x.opEquals(y);

x != y;
// 前の式と同等:
!(x.opEquals(y));

struct TimeOfDay {
    int hour;
    int minute;

    bool opEquals(TimeOfDay rhs) const {
        return hour == rhs.hour;
    }
}
// ...
    assert(TimeOfDay(20, 10) == TimeOfDay(20, 59));

int opCmp()(auto ref const TimeOfDay rhs) const {
    // ...
}

if (x op y) {  // ← opはis、 <、<=、>、または>=

if (x.opCmp(y) op 0) {

if (x <= y) {

if (x.opCmp(y) <= 0) {

int opCmp(TimeOfDay rhs) const {
    /* 注釈: 結果がオーバーフローする場合、ここでは減算はバグになる。
     * (本文の以下の警告を参照のこと。) */

    return (hour == rhs.hour
            ? minute - rhs.minute
            : hour - rhs.hour);
}

struct S {
    int i;

    int opCmp(S rhs) const {
        return i - rhs.i;          // ← バグ
    }
}

void main() {
    assert(S(-2) > S(int.max));    // ← ソート順が間違っている
}

import std.algorithm;

struct S {
    string name;

    int opCmp(S rhs) const {
        return cmp(name, rhs.name);
    }
}

import std.random;
import std.stdio;
import std.string;
import std.algorithm;

struct TimeOfDay {
    int hour;
    int minute;

    int opCmp(TimeOfDay rhs) const {
        return (hour == rhs.hour
                ? minute - rhs.minute
                : hour - rhs.hour);
    }

    string toString() const {
        return format("%02s:%02s", hour, minute);
    }
}

void main() {
    TimeOfDay[] times;

    foreach (i; 0 .. 10) {
        times ~= TimeOfDay(uniform(0, 24), uniform(0, 60));
    }

    sort(times);

    writeln(times);
}

Foo foo;
foo();

struct LinearEquation {
    double a;
    double b;

    double opCall(double x) const {
        return a * x + b;
    }
}

LinearEquation equation = { 1.2, 3.4 };
// オブジェクトは関数のように使用されている:
double y = equation(5.6);

LinearEquation equation = { 0.01, 0.4 };

for (double x = 0.0; x <= 1.0; x += 0.125) {
    writefln("%f: %f", x, equation(x));
}

e = deque[3];                    // インデックス3の要素
e = deque.opIndex(3);            // 上記と同等

deque[5] = 55;                   // インデックス5の要素に55を代入する
deque.opIndexAssign(55, 5);      // 上記と同等

++deque[4];                      // インデックス4の要素を加算する
deque.opIndexUnary!"++"(4);      // 上記と同等

deque[6] += 66;                  // インデックス6の要素に66を追加する
deque.opIndexOpAssign!"+"(66, 6);// 上記と同等

e = deque[$ - 1];                // 最後の要素
e = deque[deque.opDollar() - 1]; // 上記と同等

import std.stdio;
import std.string;
import std.conv;

struct DoubleEndedQueue // デキューとも呼ばれる
{
private:

    /* 要素は2つのメンバースライスの連鎖として表される。
     * ただし、'head'は逆順でインデックス付けされるため、
     * コレクション全体の最初の要素は
     * head[$-1]、2番目の要素はhead[$-2]となる。以下同様:
     *
     * head[$-1], head[$-2], ... head[0], tail[0], ... tail[$-1]
     */
    int[] head;    // 要素の最初のグループ
    int[] tail;    // 要素の2番目のグループ

    /* 指定された要素が実際に存在するスライスを特定し、
     * その参照を返す。 */
    ref inout(int) elementAt(size_t index) inout {
        return (index < head.length
                ? head[$ - 1 - index]
                : tail[index - head.length]);
    }

public:

    string toString() const {
        string result;

        foreach_reverse (element; head) {
            result ~= format("%s ", to!string(element));
        }

        foreach (element; tail) {
            result ~= format("%s ", to!string(element));
        }

        return result;
    }

    /* 注釈: 次の章で説明するように、以下は
     * toString()のより単純で効率的な
     * 実装である。 */
    version (none) {
        void toString(void delegate(const(char)[]) sink) const {
            import std.format;
            import std.range;

            formattedWrite(
                sink, "%(%s %)", chain(head.retro, tail));
        }
    }

    /* コレクションの先頭に新しい要素を追加する。 */
    void insertAtHead(int value) {
        head ~= value;
    }

    /* コレクションの末尾に新しい要素を追加する。
     *
     * サンプル: deque ~= value
     */
    ref DoubleEndedQueue opOpAssign(string op)(int value)
            if (op == "~") {
        tail ~= value;
        return this;
    }

    /* 指定された要素を返す。
     *
     * サンプル: deque[index]
     */
    inout(int) opIndex(size_t index) inout {
        return elementAt(index);
    }

    /* 指定された要素に一項演算を適用する。
     *
     * サンプル: ++deque[index]
     */
    int opIndexUnary(string op)(size_t index) {
        mixin ("return " ~ op ~ "elementAt(index);");
    }

    /* 指定した要素に値を代入する。
     *
     * サンプル: deque[index] = value
     */
    int opIndexAssign(int value, size_t index) {
        return elementAt(index) = value;
    }

    /* 指定した要素と値を二項演算で処理し、
     * その結果を同じ要素に
     * 代入する。
     *
     * サンプル: deque[index] += value
     */
    int opIndexOpAssign(string op)(int value, size_t index) {
        mixin ("return elementAt(index) " ~ op ~ "= value;");
    }

    /* $文字を、コレクションの
     * 長さとして定義する。
     *
     * サンプル: deque[$ - 1]
     */
    size_t opDollar() const {
        return head.length + tail.length;
    }
}

void main() {
    auto deque = DoubleEndedQueue();

    foreach (i; 0 .. 10) {
        if (i % 2) {
            deque.insertAtHead(i);

        } else {
            deque ~= i;
        }
    }

    writefln("Element at index 3: %s",
             deque[3]);    // 要素へのアクセス
    ++deque[4];            // 要素の加算
    deque[5] = 55;         // 要素への代入
    deque[6] += 66;        // 要素への追加

    (deque ~= 100) ~= 200;

    writeln(deque);
}

(deque ~= 100) ~= 200;

deque[] *= 10;    // すべての要素に10を掛ける

// 上記と同等:
{
    auto range = deque.opSlice();
    range.opOpAssign!"*"(10);
}

import std.exception;

struct DoubleEndedQueue {
// ...

    /* すべての要素を表す範囲を返す。
     * ('Range'構造体は以下で定義されている。)
     *
     * サンプル: deque[]
     */
    inout(Range) opSlice() inout {
        return inout(Range)(head[], tail[]);
    }

    /* 一部の要素を表す範囲を返す。
     *
     * サンプル: deque[begin .. end]
     */
    inout(Range) opSlice(size_t begin, size_t end) inout {
        enforce(end <= opDollar());
        enforce(begin <= end);

        /* 'head'と'tail'のうち、指定された範囲に
         * 対応する部分を決定する: */

        if (begin < head.length) {
            if (end < head.length) {
                /* 範囲は'head'の内部に完全に含まれている。 */
                return inout(Range)(
                    head[$ - end .. $ - begin],
                    []);

            } else {
                /* 範囲の一部は'head'の内部にあり、
                 * 残りは'tail'の内部にある。 */
                return inout(Range)(
                    head[0 .. $ - begin],
                    tail[0 .. end - head.length]);
            }

        } else {
            /* 範囲は'tail'内に完全に含まれる。 */
            return inout(Range)(
                [],
                tail[begin - head.length .. end - head.length]);
        }
    }

    /* コレクションの要素の範囲を表す。この
     * 構造体は、opUnary、opAssign、
     * およびopOpAssign演算子を定義する責任を負う。 */
    struct Range {
        int[] headRange;    // 'head'にある要素
        int[] tailRange;    // 'tail'にある要素

        /* 範囲の要素に単項演算を
         * 適用する。 */
        Range opUnary(string op)() {
            mixin (op ~ "headRange[];");
            mixin (op ~ "tailRange[];");
            return this;
        }

        /* 指定した値を、範囲内の
         * 各要素に割り当てる。 */
        Range opAssign(int value) {
            headRange[] = value;
            tailRange[] = value;
            return this;
        }

        /* 各要素と値を二項演算で使用し、
         * その結果をその要素に割り当てる。 */
        Range opOpAssign(string op)(int value) {
            mixin ("headRange[] " ~ op ~ "= value;");
            mixin ("tailRange[] " ~ op ~ "= value;");
            return this;
        }
    }
}

void main() {
    auto deque = DoubleEndedQueue();

    foreach (i; 0 .. 10) {
        if (i % 2) {
            deque.insertAtHead(i);

        } else {
            deque ~= i;
        }
    }

    writeln(deque);
    deque[] *= 10;
    deque[3 .. 7] = -1;
    writeln(deque);
}

target_type opCast(T : target_type)() {
    // ...
}

import std.stdio;
import std.conv;

struct Duration {
    int hour;
    int minute;

    double opCast(T : double)() const {
        return hour + (to!double(minute) / 60);
    }
}

void main() {
    auto duration = Duration(2, 30);
    double d = to!double(duration);
    // ('cast(double)duration'でもよい)

    writeln(d);
}

double d = duration.opCast!double();

struct Duration {
// ...

    bool opCast(T : bool)() const {
        return (hour != 0) || (minute != 0);
    }
}

// ...

    if (duration) {               // コンパイルできる
        // ...
    }

    while (duration) {            // コンパイルできる
        // ...
    }

    auto r = duration ? 1 : 2;    // コンパイルできる

void foo(bool b) {
    // ...
}

// ...

    foo(duration);                // ← コンパイルエラー
    bool b = duration;            // ← コンパイルエラー

エラー: Duration型の式(duration)をboolに暗黙的に
変換できない
エラー: 関数deneme.foo (bool b)は、引数の型(Duration)を使用して
呼び出すことができない

import std.stdio;

struct Foo {
    void opDispatch(string name, T)(T parameter) {
        writefln("Foo.opDispatch - name: %s, value: %s",
                 name, parameter);
    }
}

void main() {
    Foo foo;
    foo.aNonExistentFunction(42);
    foo.anotherNonExistentFunction(100);
}

   switch (name) {
       // ...
   }

if (time in lunchBreak) {

	// 上記と同等:
    if (lunchBreak.opBinaryRight!"in"(time)) {

if (a !in b) {

if (!(a in b)) {    // 上記と同等

import std.stdio;
import std.string;

struct Duration {
    int minute;
}

struct TimeOfDay {
    int hour;
    int minute;

    ref TimeOfDay opOpAssign(string op)(Duration duration)
            if (op == "+") {
        minute += duration.minute;

        hour += minute / 60;
        minute %= 60;
        hour %= 24;

        return this;
    }

    int opCmp(TimeOfDay rhs) const {
        return (hour == rhs.hour
                ? minute - rhs.minute
                : hour - rhs.hour);
    }

    string toString() const {
        return format("%02s:%02s", hour, minute);
    }
}

struct TimeSpan {
    TimeOfDay begin;
    TimeOfDay end;    // endはspanの外側にある

    bool opBinaryRight(string op)(TimeOfDay time) const
            if (op == "in") {
        return (time >= begin) && (time < end);
    }
}

void main() {
    auto lunchBreak = TimeSpan(TimeOfDay(12, 00),
                               TimeOfDay(13, 00));

    for (auto time = TimeOfDay(11, 30);
         time < TimeOfDay(13, 30);
         time += Duration(15)) {

        if (time in lunchBreak) {
            writeln(time, " is during the lunch break");

        } else {
            writeln(time, " is outside of the lunch break");
        }
    }
}

struct Fraction {
    long num;  // 分子
    long den;  // 分母

    /* 便宜上、コンストラクタは分母にデフォルト値の
     * 1を使用する。 */
    this(long num, long den = 1) {
        enforce(den != 0, "The denominator cannot be zero");

        this.num = num;
        this.den = den;

        /* 分母が常に正であることを確認することで
         * 一部の演算子関数の定義を
         * 簡略化できる。 */
        if (this.den < 0) {
            this.num = -this.num;
            this.den = -this.den;
        }
    }

    /* ... 演算子オーバーロードを定義する ... */
}

unittest {
    /* 分母が0の場合は必ずスローする。 */
    assertThrown(Fraction(42, 0));

    /* 1/3から始めよう。 */
    auto a = Fraction(1, 3);

    /* -1/3 */
    assert(-a == Fraction(-1, 3));

    /* 1/3 + 1 == 4/3 */
    ++a;
    assert(a == Fraction(4, 3));

    /* 4/3 - 1 == 1/3 */
    --a;
    assert(a == Fraction(1, 3));

    /* 1/3 + 2/3 == 3/3 */
    a += Fraction(2, 3);
    assert(a == Fraction(1));

    /* 3/3 - 2/3 == 1/3 */
    a -= Fraction(2, 3);
    assert(a == Fraction(1, 3));

    /* 1/3 * 8 == 8/3 */
    a *= Fraction(8);
    assert(a == Fraction(8, 3));

    /* 8/3 / 16/9 == 3/2 */
    a /= Fraction(16, 9);
    assert(a == Fraction(3, 2));

    /* 型'double'の同等の値を生成しなければならない。
     *
     * doubleはすべての値を正確に表現できるわけではないが、
     * 1.5は例外であることに注意。そのため、このテストは
     * この段階で実施されている。 */
    assert(to!double(a) == 1.5);

    /* 1.5 + 2.5 == 4 */
    assert(a + Fraction(5, 2) == Fraction(4, 1));

    /* 1.5 - 0.75 == 0.75 */
    assert(a - Fraction(3, 4) == Fraction(3, 4));

    /* 1.5 * 10 == 15 */
    assert(a * Fraction(10) == Fraction(15, 1));

    /* 1.5 / 4 == 3/8 */
    assert(a / Fraction(4) == Fraction(3, 8));

    /* 0で除算すると例外をスローしなければならない。 */
    assertThrown(Fraction(42, 1) / Fraction(0));

    /* 分子の小さい方が先。 */
    assert(Fraction(3, 5) < Fraction(4, 5));

    /* 分母の大きい方が先。 */
    assert(Fraction(3, 9) < Fraction(3, 8));
    assert(Fraction(1, 1_000) > Fraction(1, 10_000));

    /* 値の小さい方が先。 */
    assert(Fraction(10, 100) < Fraction(1, 2));

    /* 負の値の方が先。 */
    assert(Fraction(-1, 2) < Fraction(0));
    assert(Fraction(1, -2) < Fraction(0));

    /* 値が等しいものは、必ず<=と>=の両方を満たす必要がある。 */
    assert(Fraction(-1, -2) <= Fraction(1, 2));
    assert(Fraction(1, 2) <= Fraction(-1, -2));
    assert(Fraction(3, 7) <= Fraction(9, 21));
    assert(Fraction(3, 7) >= Fraction(9, 21));

    /* 値が等しいものは、等しくなければならない。 */
    assert(Fraction(1, 3) == Fraction(20, 60));

    /* 符号も値も等しいものは、必ず等しくなければならない。 */
    assert(Fraction(-1, 2) == Fraction(1, -2));
    assert(Fraction(1, 2) == Fraction(-1, -2));
}