On Wed, 22 Sep 2010 04:13:34 -0400, Don <nos...@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
