On Monday, 14 May 2012 at 19:24:15 UTC, Steven Schveighoffer
wrote:
I have never seen this suggested before. I would guess that it
might be considered a bug, since you are accessing the outer
instance via a pointer contained in the inner instance.
But I like the approach (even if it is a bug)!
I was thinking something along these lines last night, although
I couldn't put it quite together, it did end up using alias this.
I forget but someone commented on possibly using a flag that
would let you write to a variable for the first time, and break
if you tried to read from it. A thought that went through my head
would indeed need a little thought, but I couldn't see an easy
way to do it outside of a new keyword. What if .init (or null)
was your flag effectively? Let's assume allowinit (or something
better) to be the keyword. Then...
struct S {
allowinit uint hash;
uint toHash() const {
if (hash == uint.init) { //read always allowed safely within
struct
hash = 1;
}
return hash;
}
void throwtest() {
hash = 2; //might not throw
}
}
func(){
const S s, z;
// writeln(s.hash); //throw!
//throwtest(); //would not throw here
writeln(z.toHash()); //fine
writeln(z.toHash()); //yep still fine
writeln(z.hash); //allowed? technically yes...
throwtest(); //throw!
}
Course these types may cause more problems if outside code had
to do extra checks, so making allowinit forced to be private
would remove that issue leaving it only to within the struct,
making it good for caching results as you could only set it once.
But that only works with const data, immutable being locked in
memory it wouldn't do the job. So the only way to get around that
is to allow a constructor that sets it during construction.
//as above
struct S {
this(uint h) {
hash = h;
}
}
func(){
immutable S i; //compile error! Immutable cannot have allowinit
with default constructor!
immutable S i2 = S(10); //fine
immutable S i2 = S(uint.init); //error! allowinit cannot be
assigned to .init value for immutable!
}
