What is the reasoning behind the design of std.complex?

Question

unittest
{
  immutable float a = 1.1, b = 1.2;
  auto c1 = complex(a,b);
  auto r1 = c1 + c1;  //  error, not mutable
}

Which means that I can have Complex!(immutable float), but I can never use its opBinary functions against another instance of Complex!(immutable float). So, why is std.complex implemented in such a way?

Here is the opBinary. It calls the opOpAssign, which won't work with immutable, hence the error.

Complex!(CommonType!(T,R)) opBinary(string op, R)(Complex!R z) const
{
    alias typeof(return) C;
    auto w = C(this.re, this.im);
    return w.opOpAssign!(op)(z);
}

Answer 1

I'd say that it's a bug. Certainly, if it's not a bug, it's a bad design. But looking at the code for opOpAssign and how much of it there is, my guess would be that they were trying to avoid code duplication and forgot to take into account that what they were doing wouldn't work with immutable. I'd suggest that you report it as a bug.