Proposal: Elvis and Other Null-Safe Operators

[Stephen Colebourne]

Jeremy Manson wrote:
>> The principle perceived disadvantage, however, is that it encourages,
>> rather than discourages, the use of null values in APIs.
> 
> I would think that the principle disadvantage would be not that it
> encourages use of null values (which, as you point out, is fine in
> some contexts), but that it encourages programmers not to think about
> what happens when there is a null value.

But that is exactly what already happens today. Most developers are very 
poor at thinking through the null consequences of a method - the happy 
day scenario is the one focussed on.

> I can easily imagine
> programmers using this all of the time without thinking about it, and
> then being surprised when a null ends up in the wrong place and not
> knowing how it got there.  Even with a simple example:
> 
> public String someFunction(String a, String b) {
>   String s = a?.concat("foo");
>   String t = b?.concat(a);
>   return myHashMap?.get(t);
> }
> 
> Now, someFunction returns null.  Is it because a was null?  Or b was
> null?  Or myHashMap was null?  Or there was no mapping for t in
> myHashMap?

Or perhaps it doesn't matter, and thats why the code was written that 
way. Null as 'don't know' or 'don't care' is incredibly common.

> If you want to cut down on
> extraneous if-testing, I would use JSR-305's Nullity annotations
> instead.

What does this code do when passed null?

Foo f = new Foo(null);
int v = f.value;

public class Foo {
   public final Integer value;
   public Foo(@Nonnull Integer value) {
     this.value = value;
   }
}

There is a NPE at f.value, not at new Foo(null).

You would think that you could never construct an instance of Foo with a 
val of null, but you can. The @Nonnull annotation doesn't have any real 
meaning unless it is checked using a tool, and javac isn't such a tool. 
This will be very confusing when you use Foo from another part of your 
application and expect the value to be non-null and get a NPE. In fact 
the @Nonnull is positvely misleading.

Basically, you can't rely on JSR-305. The information needs to be 
rechecked. Thus, whats the point in using it at all?!! Documentation 
perhaps? Annotations are not suitable for handling language level issues 
like nulls.

Stephen