> Both languages don't do much about Tony Hoare's Billion Dollar Mistake, and to me that's an immediate black mark on type safety, though they fail in this regard in distinct ways.
Java is well on its way to alleviating the problem. [1]
Java is well on its way to alleviating the problem. [1]
In Dart[1] and Vlang[2], for example, "non-nullable" is the default. Vlang doesn't allow null or nil to be used, unless code is marked as unsafe, and primarily only for compatibility with languages that do (like C). In Dart, nullable variables have `?` added to the end of them.
[1]: https://en.wikipedia.org/wiki/Dart_(programming_language)
If you have something like
Map<Integer, Optional<Integer>> map;
var foo = map.get(1);
If the new null restricted stuff makes it in, you can express this as
Map<Integer, Optional<Integer>!> map;
var foo = map.get(1);
At best, that will prevent you from doing `map.put(1, null);`
Am I missing something?
To be more clear:
Map<K, V>.get(foo)
Optional<V> get(K)
If you had something like:
var x = map.get(k);
The best they could hope for is a signature like `Optional<V> getOpt(K);`. Which wouldn't be terribly bad as Java currently has an annoying get definition in the `Map` interface because it predates generics (The current signature is `V get(Object)`).
Regardless, if they do want to change the interface, it'd probably be best if they waited for Valhalla to land. One of the problems with `Optional` as it stands is it creates a load of GC pressure. If `Optional` is converted into a value class then there will be effectively no overhead to returning it everywhere.