Spec#, nullables and more

[Denis Koroskin]

On Sat, 06 Nov 2010 02:41:25 +0300, Walter Bright  
<newshound2 at digitalmars.com> wrote:

> Denis Koroskin wrote:
>> On Fri, 05 Nov 2010 23:44:58 +0300, Walter Bright  
>> <newshound2 at digitalmars.com> wrote:
>>>
>>> To eliminate null pointers is the same as shooting the canary in your  
>>> coal mine because its twitter annoys you.
>>  I'm tired of pointing out that NO ONE is talking about eliminating  
>> null pointers, but rather extending an existing type system to support  
>> non-nulls. Your hate towards non-nullables comes from misunderstanding  
>> of the concept.
>
> Consider non-nullable type T:
>
>    T[] a = new T[4];
>    ... time goes by ...
>    T[1] = foo;
>    T[3] = bar;
>    ... more time goes by ...
>    bar(T[2]);
>
> In other words, I create an array that I mean to fill in later, because  
> I don't have meaningful data for it in advance. What do I use to default  
> initialize it with non-nullable data? And once I do that, should  
> bar(T[2]) be an error? How would I detect the error?
>

How is T non-nullable? By the time you call bar(T[2]) T[2] is not  
initialized yet, i.e. null. As such, T[]
This is clearly not a use-case for non-nullables. In your use case this  
array contains un-initialized values for some time. Non-nullables means  
that there is no such state as unitialized. As such, you use T?[], not T[].

If you need an array of elements that are never null, use the following:

T[] a = [new T1(), new T2(), new T3()];

or the following:

T?[] nullables = ...;
// setup a

T[] nonNullables = toNonnull(nullables); // or cast(T[])nullables;

similar to the way you create mutable objects and then cast to immutable.

> In general, for a non-nullable type, how would I mark an instance as not  
> having meaningful data?

Err... what? By definition, a non-nullable is an object that can NEVER  
hold meaningless data. If T must contain meaningless data, use T?, not T.

>
> For example, an int is a non-nullable type. But there's no int value  
> that means "no meaningful value", and this can hide an awful lot of bugs.
>

Use int?, which is a special type that has an additional "not initialized  
yet" value. This comes at a cost of a larger size though - there is simply  
no other way to do it.

> I'm not sure at all that non-nullable types do more than make easy to  
> find bugs much, much harder to find.

You are simply wrong. You clearly misunderstand the concept.