Proposal: Relax rules for 'pure'

[Steven Schveighoffer]

On Wed, 22 Sep 2010 04:13:34 -0400, Don <nospam at nospam.com> wrote:

> Don wrote:
>> The docs currently state that:
>
>> PROPOSAL:
>> Drop the first requirement. Only one requirement is necessary:
>>  A pure function does not read or write any global mutable state.
>>
>
> Wow. It seems that not one person who has responded so far has  
> understood this proposal! I'll try again. Under this proposal:
>
> If you see a function which has mutable parameters, but is marked as  
> 'pure', you can only conclude that it doesn't use global variables.  
> That's not much use on it's own. Let's call this a 'weakly-pure'  
> function.
>
> However, if you see a function maked as 'pure', which also has only  
> immutable parameters, you have the same guarantee which 'pure' gives us  
> as the moment. Let's call this a 'strongly-pure' function.
>
> The benefit of the relaxed rule is that a strongly-pure function can  
> call a weakly-pure functions, while remaining strongly-pure.
> This allows very many more functions to become strongly pure.
>
> The point of the proposal is *not* to provide the weak guarantee. It is  
> to provide the strong guarantee in more situations.

Yes, this in particular solves a problem I thought of a long time ago --  
modularizing functions.

Let's say you have a function like this:

pure int foo()
{
   ulong[100] x;
   x[0] = 1;
   foreach(uint i; 1..x.length)
     x[i] = x[i-1] * i;
   ...
}

Let's say you have 10 pure functions that initialize x in the same way.   
If you wanted to abstract the initialization of x, you could do:

void initX(ulong[] x)
{
   x[0] = 1;
   foreach(uint i; 1..x.length)
     x[i] = x[i-1] * i;
}

And then you just have:

pure int foo()
{
    ulong[100] x;
    initX(x);
    ...
}

But pure functions can only call pure functions, so we'd have to mark  
initX pure.  Your rules would allow this, and I think they are exactly  
what we need, I think you found the perfect rules to describe it.

-Steve