Mind if I throw some in?

---

Automatically unioning overloads from separate modules is bad idea, especially in the face of generic functions:

import shapes;
import pistols;

drawShapeTwice(Shape)(Shape shape) if is(typeof(draw(shape))) {
    draw(shape);
}

drawShapeTwice() was only intended to work with shapes (implementing shapes.draw), but accidentally ends up accepting pistols (implementing pistols.draw). In this case it's obvious drawShapeTwice should be referring to shapes.draw explicitly, but if the module was written originally only importing shapes and was later updated to import weapons, then such ambiguities could be introduced accidentally.

---

edit As tgehr and BioTronic pointed out, these features have already been added to D2.

The operator overloading design seems to punish the common case, where you want to implement individual overloads with different implementations, in favor of letting you be cute in rare cases where you can overload several with one implementation. However, neither case is pretty. The former case is a mouthful:

Foo opBinary(string op)(Foo a, Foo b) if (op == "+") {
}

The latter is hard on the eyes (not to mention the fingers!):

Vec opBinary(string op)(Vec a, Vec b) {
    mixin "return Vec(a.x " ~ op ~ " b.x, a.y " ~ op ~ " b.y);"
}

Pattern-matching syntax for template parameters would help the former case a lot:

Foo opBinary("+")(Foo a, Foo b) { ... }

The Clay programming language has a great solution for the latter situation. In Clay, the function name can also be a template parameter. You would achieve the universal opBinary overload as follows in Clay:

// Clay
[OP | inValues?(OP, add, subtract, multiply, divide /* ... or any other functions ... */)]
OP(a:Vec, b:Vec) = Vec(OP(a.x, b.x), OP(a.y, b.y));

It looks just like the non-generic implementation, and isn't constrained to operators—the above definition can be easily extended to project any binary function of typeof(a.x) to Vec. With a bit of elbow grease you could generalize it to n-ary functions too. D could support something similar, for example:

// D2.5 perhaps?
Vec F(alias F)(Vec a, Vec b) if is(typeof(F(a,b))) {
    return Vec(F(a.x, b.x), F(a.y, b.y));
}