Null references (oh no, not again!)

[BCS]

Reply to Christopher,

> BCS wrote:
> 
>> Hello Christopher,
>> 
>>> BCS wrote:
>>> 
>>>> Your right, but if you switch to a class and factory with no public
>>>> constructor, you can make it work. The problem of perf going down
>>>> the drain is avoidable if you can (in that mode) enforce compile
>>>> time checking of most cases and requiter calls to do run time
>>>> checks for the rest. If the template works right, than flipping
>>>> back to alias/typedef mode leaves the run time checks and leave the
>>>> unchecked code as correct while doing away with the perf problems.
>>>> 
>>> If you use a class, you're begging the question. It's just that
>>> you'll have a null NotNull!(T) rather than a null T.
>>> 
>>> Granted, you can use opAssign(T) instead, but you still need
>>> contracts.
>>> 
>> That won't be an issue because it's a run time concern and I am
>> proposing that the class based version never even run. In fact it
>> could even not be runable. All it does is enforce usage patterns that
>> do work correctly with a different set of definitions.
>> 
> I don't understand what you are saying. If you can't run a program
> that uses NotNull, who in their right mind would use it?
> 

something like this:

version(Enforce)
{
    NotNull!(T) MakeNotNull(T)(T) { assert(false); }
    bool MakeNotNull(T)(T, out NotNull!(T)) { assert(false); }
    class NotNull(T)
    {
       static this(){ assert(fasle);

       // overload to make valid stuff work and invalid not work
    }
}
else
{
    template NotNull(T) // not quier right for classes but oh well
    {
       alias *T NotNull;
    }
    NotNull!(T) MakeNotNull(T)(T t)
    {
         if(t is null) throw new Something();
         return t;
    }
    bool MakeNotNull(T)(T t, out NotNull!(T) tout)
    {
        if(t is null) return false;
        tout = t;
        return true;
    }
}

compile it with -version=Enforce.
If it compiles, recompile without that version and run it
if not, fix it & try again