! operator?

[emil14]

Several statically typed languages have functionality, which tells the compiler to treat a potentially empty value as non-empty. Here are some comparable features in other languages:

• Rust - .unwrap()
• Kotlin - !! non-null assertion
• TypeScript - ! non-null assertion
• Swift - ! forced unwrapping
• Dart - ! null assertion
• C# - ! null-forgiving

Without it you have to always explicitly handle both cases. Example:

value -> switch {
    Maybe::Some -> handle_value
    Maybe::None -> 'no value' -> println
}

With it you can assert that the value is non-empty, otherwise runtime will throw panic

// I'm sure value is non-empty and I'm ready to panic otherwise
value! -> handle_value

Questions

• Do we want this in Neva?
• Does it need syntax construct or should be a component?
• If that's a component, in which package it should be located?

[emil14]

My opinion:

1. This feature is a hack that allows you to avoid using proper data-structures that express your real invariant. On one hand it might lead to less quality code, on the other hand that might be a useful workaround sometimes
2. I'm not sure this needs to be exposed as an operator and instead should be a component you need to import. Perhaps from package like runtime or even unsafe - so the user can immediately see that your code is not fully type-safe

---

Meta: to me it feels like assertive programming is a hack for not type-safe (not "sound" enough) codebases. In perfect world your types express your invariant in a way, that is impossible to get invalid state. However, Neva is not Haskell and its type-system is intentionally limited, so we might need workarounds of this kind