Non-null objects, the Null Object pattern, and T.init

[Meta]

On Friday, 17 January 2014 at 01:42:38 UTC, Andrei Alexandrescu 
wrote:
> Walter and I were talking today about the null pointer issue 
> and he had the following idea.
>
> One common idiom to replace null pointer exceptions with milder 
> reproducible errors is the null object pattern, i.e. there is 
> one object that is used in lieu of the null reference to 
> initialize all otherwise uninitialized references. In D that 
> would translate naturally to:
>
> class Widget
> {
>     private int x;
>     private Widget parent;
>     this(int y) { x = y; }
>     ...
>     // Here's the interesting part
>     static Widget init = new Widget(42);
> }
>
> Currently the last line doesn't compile, but we can make it 
> work if the respective constructor is callable during 
> compilation. The compiler will allocate a static buffer for the 
> "new"ed Widget object and will make init point there.
>
> Whenever a Widget is to be default-initialized, it will point 
> to Widget.init (i.e. it won't be null). This beautifully 
> extends the language because currently (with no init 
> definition) Widget.init is null.
>
> So the init Widget will satisfy:
>
> assert(x == 42 && parent is Widget.init);
>
> Further avenues are opened by thinking what happens if e.g. 
> init is private or @disable-d.
>
> Thoughts?
>
>
> Andrei

Throwing out some more ideas, though non of this compiles right 
now (and I managed to make the compiler ICE).

class Widget
{
	private int x;
	this(int y) { x = y; }
	
	public @property int halfOfX() { return x / 2; }
	
	public void printHello() { std.stdio.writeln("Hello"); }
	
         //Error: 'this' is only defined in non-static member 
functions,
         //not Widget
	static Widget init = new class Widget
	{	
		@disable public override @property int halfOfX();
		
		@disable public override void printHello();
		
		this() { super(int.init); }
	};
}

Another idea that unfortunately doesn't work due to the way 
static assert works:

class Widget
{
	private int x;
	this(int y) { x = y; }
	
	public @property int halfOfX() { return x / 2; }
	
	public void printHello() { std.stdio.writeln("Hello"); }
	
	static Widget init = new class Widget
	{	
                 //Error: static assert  "Tried to access halfOfX
                 //property of null Widget"
		override @property int halfOfX()
                 {
                     static assert(false,
                         "Tried to access halfOfX property of null 
Widget");
         }
		
	override void printHello()
         {
             static assert(false,
                 "Tried to access halfOfX property of null 
Widget");
         }
		
		this() { super(int.init); }
	};
}

Is there any way to get around this?

And then there's this, which causes an ICE:

class Widget
{
	private int x;
	this(int y) { x = y; }
	
	public @property int halfOfX() { return x / 2; }
	
	public void printHello() { std.stdio.writeln("Hello"); }
	
	static Widget init = new class Widget
	{	
		this()
		{
		}
	};
}