Nullable!T

[bearophile]

In C#2+ there's the Nullable type, one of its main purposes is to represent null values coming from databases. Another purpose for D is for example find(iterable) can return a Nullable!T instead of throwing an exception (or returning -1) if no item can be found. So if seen as useful D can add a Nullable to Phobos in less than two years from now, when dmd2 has less bugs.

A Nullable struct is not so complex, it can be added to Phobos2. Before creating it some design decisions are necessary, here are three of them:

1) Nullable!(SomeClass) is forbidden in C#. D Nullable can do the same, but this hurts generic code a little. An alternative is in this case to not add the boolean field to the Nullable and make hasValue just look if the reference !is null (so if T is a class then (Nullable!T).sizeof == T.sizeof). If object references are allowed then writing the value field sets the hasValue boolean to true if T is not a class reference.

2) C# forbids Nullable!(Nullable!T), D can do the same or it can make Nullable!(Nullable!T) === Nullable!T  to allow to write simpler generic code.

3) C# uses something similar to valueorInit() that returns T.init if the hasValue property is false. D can do the same, or it can use get(default=T.init) that returns the value if present or the given default (or the default default). This can be a problem if a delegate is taken out of get because in D default values are added at call point, they are not an information stored inside the callee as in Python.


So Nullable can have the methods/properties:
value
@property hasValue
get(defaukt=T.init)
type alias of T


Reading the value if hasValue is false generates a specific exception.


An error for safety:
Nullable!int x;
int y = x; // compile ERROR
int y = x.get(); // OK
int y = x.get(5); // OK
int y = x.hasValue ? x.value : x.type.init; // OK
int y = x.hasValue ? x.value : -1; // OK


Optionally this can be accepted:
Nullable!int x;
if (x) { ...
that is equivalent to:
if (x.hasValue) { ...
But this doesn't look fully tidy to me...

---------------

So far I think Nullable can be implemented with not changes in the language/compiler. Now some small things that can require such changes.

C# has the ?? operator (Elvis operator) that can be used to replace this:
Nullable!int x;
int y = x.hasValue ? x.value : -1; // OK
With:
Nullable!int x;
int y = x ?? -1;


In C# there is a bit of syntax sugar for:
Nullable!int x;
that can be written:
int? x;
This can be done in D too, but this can be added later too. The advantage of this syntax sugar is to encourage programmers to use Nullables.


There is another possible bit of compiler help, to avoid most of those empty Nullable exceptions and make Nullable a bit safer the compiler can refuse code like:
Nullable!int result = foo();
int x = result.value;

And accept code like:
Nullable!int result = foo();
if (result.hasValue) {
  int x = result.value;
  ...
} else {
  ...
}

Bye,
bearophile