Head Const

[Bottled Gin via Digitalmars-d]

Too illustrate how headconst can help with multithreading (shared 
memory) code, I have created this small snippet. In my 
experience, there are lots of *effectively immutable* objects 
(like Foo.bar in the code snippet). If these variables can be 
declared headconst, a lot of hierarchical synchronization locking 
(and therefor deadlock situations) can be saved. In the present 
Dlang semantics we do not have any specifier to make *effective 
mutability* effective. So presently I have to create a naming and 
coding discipline when declaring and using effectively mutable 
hierarchical objects.


class Bar {
   void funcBar() { }
}

class Frop {
   void funcFrop() { }
}

class Foo {
   this() {
     synchronized(this) {
       bar = new Bar();
     }
   }

   void setFrop() {
     frop = new Frop();
   }

   headconst Bar bar;		// effectively immutable
   Frop frop;			// mutable

   void funcBar() {		// no locking required
     bar.funcBar();		// since bar is effectively immutable
   }

   void funcFrop() {
     synchronized(this) {	// lock necessary since frop
       frop.funcFrop();		// is mutable
     }
   }
}

void main() {
   Foo foo = new Foo();
   // yield for other threads
   // foo.setFrop();    // in some other thread
   foo.funcBar();
   foo.funcFrop();
}