import std.stdio;

​

struct Foo

{

    private int _foo;

    this(int i)

    {

        _foo = i;

    }

    @property foo() { return _foo; }

    auto opBinary(string op, T)(const T rhs) const

    {

        import std.traits;

        static if(is(T == Unqual!(typeof(this))))

        {

            writeln("normative case");

            static if (op == "+") return T(_foo + rhs._foo);

            else static if (op == "-") return T(_foo - rhs._foo);

            else static assert(0, "Operator "~op~" not implemented");

        }

        else

        {

            writeln("cool case");

            static assert( __traits(getAliasThis, T).length == 1); 

            // multiple alias this are not implemented (yet!)

            auto f = __traits(getMember, rhs, __traits(getAliasThis, T)[0]);

            return T(mixin("this" ~ op ~ "f")); 

        }

    }

}

​

struct Bar

{

    Foo f;

    alias f this;

    int ku; 

    //alias ku this; 

    this(Foo f)

    {

        this.f = f;

    }

}

​

void main(string[] args)

{   

    auto v5norm = Foo(2) - Foo(3);

    pragma(msg, typeof(v5norm));

    writefln("v5norm = %s", v5norm);

    auto v5 = Bar(Foo(2)) - Bar(Foo(3));

    pragma(msg, typeof(v5));

    writefln("v5 = %s", v5);        

}