Is This a Bug

[Jonathan M Davis]

On Tuesday, October 25, 2011 10:34 Gor Gyolchanyan wrote:
> I thought pure functions can't modify their parameters (along with any
> other non-local variables).
> if the pure function can't modify anything non-local, why should it
> care whether it's getting called from a shared context or not?

No. The _only_ direct effects that pure has on a function is that it can't 
access any module-level or static variables which can ever be mutated over the 
course of the program (so, if they're immutable or if they're const value 
types, then they can be used, but otherwise not) and that it can't call impure 
functions. Previously, it was required that all of the parameters to a pure 
function be either immutable or implicitly convertible to immutable (and I 
believe that that's what TDPL states), which would make it impossible to alter 
the function's arguments, but the result was that pure was too restrictive to 
be of much use. So, it was changed.

Now, any function which doesn't access any module-level or static variables 
which can be modified during the course of the program and which doesn't call 
any impure functions can be pure, but unlike before, purity is not enough for 
a function call to be optimized out when it's called multiple times within an 
expression. It can only be optimized out when the compiler can guarantee that 
none of the function's arguments can be altered by that pure function, which 
currently means that only functions whose arguments are all either immutable 
or implicitly convertible to immutable can be optimized in that manner - just 
like it was before. However, this makes it possible to have far more functions 
be pure, so pure functions which do have parameters which are immutable or 
implicitly convertible to immutable can call many more functions and do much 
more. Being able to  optimize out based on purity is therefore purely a
compiler optimization which it does when it can instead of always applying
to pure functions.

- Jonathan M Davis