How do "pure" member functions work?

[Timon Gehr]

On 08/20/2011 06:24 PM, Sean Eskapp wrote:
> == Quote from David Nadlinger (see at klickverbot.at)'s article
>> On 8/20/11 5:13 PM, Sean Eskapp wrote:
>>> Does marking a member function as pure mean that it will return the same
>>> result given the same parameters, or that it will give the same result, given
>>> the same parameters and given the same class/struct members?
>> The second one, the implicit this parameter is just considered a normal
>> argument as far as purity is concerned.
>> David
>
> Wait, references and pointers are now valid for pure function arguments?

There are different forms of pure functions:

weakly pure:
no mutable globals are read or written. the function may however change 
its arguments. weakly pure functions are useful mainly for the 
implementation of functions with stronger purity guarantees.

const pure/strongly pure:
All function arguments are values or const/immutable.

 From the type signature of a function, you can always tell which form 
of pure function it is:

int foo(ref int, int) pure; // weakly pure, could change first argument
int bar(const(int)*, int) pure; // const pure
int qux(immutable(int)*, int) pure; // strongly pure


Weakly pure member functions can therefore change the other members:

struct S{
     int x;
     int foo() pure; // weakly pure, could change x
     int bar() pure const; // const pure, cannot change x
     int qux() pure immutable; // strongly pure, only works with 
immutable instances
}

The rationale of this:
Consider

int baz(int x) pure{
     S s=S(x);
     S.foo();
     return s;
}

This is clearly strongly pure code. If we had no weakly pure, this could 
not be written in that way.