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.