Probably the restriction was lifted after TDPL was out.
Yes. The compiler will only reorder/run in parallel/optimize if
it is safe (not changing execution semantics). Pure can be used
to prove that certain optimizations are safe. If a pure
function only takes const or immutable arguments, the compiler
has more guarantees and can do more things. If a pure function
takes mutable arguments, it can be used as a component of other
pure functions (important!), but the kind of optimizations that
can be performed directly on them are a lot more limited.
'Pure' means that the behavior of the function does not change
between invocations with the same/equivalent arguments. This
can include mutating actions on the arguments, if those are
typed mutable.
Even if you changed the signature of the pure function to 'pure
int squaredPlus(immutable int);' you'd have the same problem;
Because the int argument it receives is a copy so it won't matter
if it was mutable or not. (If it were an object, then it would be
more enforced).
I'll refer to the language specs to see if I can find an answer
on this, but it feels wrong allowing access to 'this' on mutable
data; I thought it could only mutate it's own data in regards to
local variables and arguments it owned.
