On 02/04/2012 08:51 PM, Era Scarecrow wrote:
If I'm reading how pure works, my original example was likely broken as
it was part of a struct that returned a state value (although the
contract constraints meaning was still valid).
So is pure fully usable or is it not yet ready? Makes me think that pure
should have further constraints/limits, if it's part of a class/struct
it should either require or automatically be static (no state access)
and if it accesses any global variables, they must be immutable.
int x;
immutable int y = 10;
pure int test(int z) {
int t = z + x; //should error
t += y; //fine, globally immutable.
return t;
}
struct X {
int s_x;
static int s_st_x;
immutable int s_y;
static immutable int s_st_y = 100;
pure int test(int z) {
int t = x + z; //should error
t += s_x; //error, mutable external state
t += s_st_x; //error, mutable external state (static)
t += s_y; //error, not statically immutable, mathematically impure.
t += y; //fine, global immutable
t += s_st_y; //fine, statically immutable.
return t;
}
}
Errors I get currently are these:
test(int):
Error: pure function 'test' cannot access mutable static data 'x'
X.test(int):
Error: pure function 'test' cannot access mutable static data 'x'
Error: pure function 'test' cannot access mutable static data 's_st_x'
If I understand pure correctly, I should get two more, for s_x and s_y.
Pure does not imply const in D. If you want stronger guarantees, just
turn 'test' into a const (or immutable) member function. In D, a
function can change anything that is mutable and reachable through its
parameters, this includes the implicit 'this' pointer. The reason for
this design is simple: There is no need to be overly restrictive,
because the additional restrictions are already trivially expressed in
the type system. Furthermore, any mutation of a parameter can be turned
into a less efficient protocol that only requires a const pure function,
so there would be no gain if pure implied const, it would only make pure
less useful.
void foo(int* x)pure{*x+=2;}
int bar(const(int)*x)pure{return *x+2;}
void main() pure{
int x, y;
foo(&x); // those two lines have
y = bar(&y); // equivalent functionality!
}
