Working on the new design of
null brought so many challenges that I didn’t implement any special support for them in generic types — the concept is pretty alien to me and I don’t know what to fix because nothing is broken yet.
Skila features stackable
null values with no performance penalty compared to regular values. It means
String does not use magic value
-1 any longer, the pair
first/firstOrDefault of the collection is the pattern of the past. All you need to return is optional value.
You can work with optional values safely:
let i ?Int = null; test(i); // compile error def test(i Int) Void ...
Can you guess why you will get compile error? Type mismatch? Close, but not enough — types do match here but conditionally (there is precisely one level of
Option<T> difference) and this means the entire call is executed conditionally as well. Statement became expression with the outcome failure or success which has to be read or explicitly dropped. Like here:
let i ?Int = null; _ = test(i); def test(i Int) Void ...
For the record there is no magic here, just regular error:
let i ??Int = null; test(i); // classic type mismatch def test(i Int) Void ...
There was no need to introduce special syntax for optional chaining (besides there would be asymmetry between optional caller and optional argument), so instead of clunky “
?.” you write:
var s ?String = null; s = s.toLower();
which is equivalent of:
var s ?String = null; s = s is null ? null : s'value.toLower();
Unlike pre-6.0 C# no exception is thrown, unlike C# 6.0 the syntax is clear, and unlike Icon you cannot simply ignore the optional execution. Time will tell whether such approach is indeed a winner.