Proposal: Relax rules for 'pure'

[Don]

Jesse Phillips wrote:
> Steven Schveighoffer Wrote:
>> If we can define weakly pure functions this way, they most likely will be  
>> way more common than unpure functions.  I know I avoid accessing global  
>> variables in most of my functions.  Think about a range, almost all the  
>> methods in a range can be weakly pure.  So that means you need to mark  
>> every function as pure.

I think that's true. I/O is impure, but most other things are not.

>>
>> Would it not be less tedious to mark unpure functions instead of pure  
>> functions?  Or am I just going too far with this?

You can use
pure:
at the top of the file.
The problem is that there's no syntax for impure, so it can't be used if 
you have a single impure function (which does logging, for example).
You can also wrap a bunch of functions in pure {}.

>> OR, maybe we could say, mark strongly pure functions as pure, mark  
>> functions that access global data as something else (global?) and weakly  
>> pure functions just aren't marked.
>>
>> -Steve
> 
> This is interesting, I'm not sure if either of these approaches could make it into D2, though a conservative approach was originally taken only because it was the most easy to prove.
> 
> I also find it interesting that D actually takes the 3-stage approach to several things. mutable, const, immutable; @safe, @trusted, @system. And this being unpure, contained, pure.
> 
> D recognizes the importance of these stages in other areas, so I feel it would be a miss if there is not a good reason the proposal doesn't work. Sadly what you learn from one of the stated areas (mutability, safety, purity) can't be applied to the other. But the pattern is there.

Interestingly, 'pure' is much simpler.

A weakly pure function can modify only the mutable parameters it was 
given. There's no need for a different language syntax for strongly 
pure, because it's just the case where the number of mutable parameters 
it was given are zero.

The point is that weakly pure and strongly pure are almost the same.

int weakfoo(ref int x) pure;

is exactly the same as strongly pure, except that it can also modify one 
single int, which you specify. Whereas

int impurefoo(int x);

could be doing _anything_.