It's not verbose. "Option" is 6 characters. ".map" is 4.
> In Nim, both nil and non-nil vars are at roughly the same reach.. while in Rust non-nil vars are significantly easier work with.
Option values are really easy to work with. Just use map or unwrap if you don't care about handling the null case. If you do care about handling it (which you should, after all!) the code using "if let" is the same as the equivalent "if foo == null".
I just want to note that verbosity isn't just about symbol length, but also about operator noise and the number of available or required commands used to achieve a goal. Just counting these characters isn't very relevant, and isn't even the best Rust can do (as someone pointed out you can use 'Some()' to get an Option var, which is only 4 chars).
That said, I agree this is rather subjective, and can't be well compared outside the context of the rest of the language.
Some() is 6 chars.
let foo = 5; // cannot be null
let bar = Some(5); // technically also can't be null, but could be None
// instead of Some(val)
`foo` has the type `i32` here, and `bar` has the type `Option<i32>`.non-zebra numbers[1] are also very useful. But why have a "non-zebra number" when I can just have plain numbers?
[1] A "number" which is either a number, or a zebra
References are not the zebras. Nil-references are.
We might as well say that the underlying number that the reference are represented by are useful modelling tools, in some circumstances. That doesn't mean that you want pointer arithmetic for references all the time.
There are a number of ways to approach this topic, so I'll just give you one: in languages with more advanced static type systems, you try to encode as much semantic information as possible in the type. As you've said, the idea of null can be useful, so it deserves a place in the type system. You want to separate things that may be null from things that should never be null. This is because not-null is by far the common case. Allowing everything to be nullable by default optimizes for the lesser-used semantic, which is where errors with null come in: you assume that something isn't null, when it actually is.