[article] Language Design Deal Breakers

[Timon Gehr]

On 05/29/2013 07:35 AM, Walter Bright wrote:
> On 5/28/2013 9:55 PM, Diggory wrote:
>> As a last resort there should be a runtime check available such as
>> assertNotNull(T) which does the conversion.
>
> The idea is to put the check on assignments to NotNull, not on usage of it.

This is like allowing assigning 'Object' references to 'Exception' 
references and adding a runtime check that the dynamic type actually 
conforms to 'Exception'.

The current behaviour is like always allowing assigning 'Object' to 
'Exception' but crashing when a method that is not present in 'Object' 
is called on an 'Exception' reference pointing to an 'Object'.

Obviously both of those behaviours are not very sensible.

What he is suggesting is something like this:

// TODO: Add template constraints

struct AnActual(T){
     private T payload;
     public T _upcastToNullable(){ return payload; }
     alias _upcastToNullable this;
     @disable this();
     private this(T t){ payload = t; }
}

auto match(alias therecase, alias nullcase)(T t){
     if(t != null) return therecase(AnActual!T(t));
     return nullcase();
}

// the following suffers from the inability to use a private
// constructor to build a non-nullable object...
auto New(T,S...)(S args){ return AnActual!T(new T(args)); }


If you put these declarations in their own module, then the guarantee 
that AnActual!T does not contain null can be provided _statically_ 
without any runtime checks. (modulo unsafe constructs, as always.)


This still does not prevent dereferencing nullable pointers.