I just want to share a view lines of code.
The availability of operator overloading can result in very short and precise code for linear algebra.
To test/explore it a little I just modified the alias this example:

#!/usr/bin/env rdmd
struct Point
{
    double[2] p;
    // Forward all undefined symbols to p
    alias p this;
    auto opBinary(string op)(Point rhs)
    {
        static if (op == "+")
        {
            Point ret;
            ret[0] = p[0] + rhs.p[0];
            ret[1] = p[1] + rhs.p[1];
            return ret;
        }
        else static if (op == "-")
        {
            Point ret;
            ret[0] = p[0] - rhs.p[0];
            ret[1] = p[1] - rhs.p[1];
            return ret;
        }
        else static if (op == "*")
            return p[0] * rhs.p[0] + p[1] * rhs.p[1];
        else
            static assert(0, "Operator " ~ op ~ " not implemented");
    }
}

void main()
{
    import std.stdio;// : writefln,write;

    // Point behaves like a `double[2]` ...
    Point p1, p2;
    p1 = [2, 1], p2 = [1, 1];
    // ... but with extended functionality
    writef("p1*(p1 + p2) = %s*(%s + %s) =", p1, p1, p2);
    write(p1 * (p1 + p2)); // compare this to code without operator overload:
}

Compare: p1 * (p1 + p2) to something with a structure like dot(p1,(add(p1,p2)).
(With the Dlangs UFCS it might become: p1.dot(p1.add(p2)) )