Opt-in non-null class references?

[Jonathan M Davis]

On Wednesday, February 28, 2018 13:43:37 SimonN via Digitalmars-d wrote:
> Answer: Both A?.init and A.init shall be null, then use code-flow
> analysis.

I expect that pretty much anything you propose that requires code flow
analysis is DOA. Walter is almost always against features that require it,
because it's so hard to get right, and the places that D does use it tend to
have problems (e.g. it's actually quite trivial to use a const or immutable
member variable before it's initialized). In fact, IIRC, in the most recent
discussion on having the compiler give an error when it can detect that a
null pointer or reference is being dereferenced, Walter was arguing against
precisely because code-flow analysis is so hard to get right, and encoding
it in the spec is particularly bad (which would be required for anything
involving errors). If non-nullable references were added to D, I expect that
they would have to be like structs marked with

@disable this();

with all of the cons that go with that.

> Argument: It's not worth it.

I'm very much in that camp. I've never understood why some folks have so
many problems with null pointers. Personally, about the worst that I
normally have to deal with is forgetting to initialize class reference or
pointer, and that blows up quite quickly such that it's fixed quite quickly.
And that's in C++, D, Java, or any other language that I've used. Null
pointers/references are simply not something that I've ever seen much of a
problem with even when I use pointers heavily.

And as idiomatic D code tends to use classes rarely, it's that much less
useful for D than it would be for many other languages. I know that some
folks think that null is a huge problem, and some folks use classes or
pointers much more than idiomatic D typically does, but I definitely don't
think that adding a new type of pointer or reference to the language to try
to deal with null pointers/references is worth the extra complication. It's
a huge complication for what I personally believe is a small problem, though
obviously, not everyone agrees on that point. I have no idea what Walter and
Andrei's current stances on such an idea are other than the fact that Walter
is very much against using code-flow analysis for something like verifying
that a pointer or reference has been initialized before it's dereferenced.

- Jonathan M Davis