Optional-chained operators

[bbrk24]

Related: #897

Here's a situation I've run into before: given an optional array, return one more than its length if it's defined, and some fallback value (e.g. 0) if it isn't. Currently this can be done in two ways:

lenPlusOne := (arr?: number[]) => if arr? then arr.# + 1 else 0
lenPlusOne := (arr?: number[]) => (arr?.# ?? -1) + 1

The first one is a little verbose, especially if it's embedded in a longer expression. The second one is less obvious why it works, and doesn't easily accommodate a configurable fallback value.

C#'s mathematical operators are optional-chained by default, so this can be written as

int LengthPlusOne(List<int>? l) => l?.Count + 1 ?? 0;

While we can't change the behavior of the existing JS operators -- after all, null + '' is still meaningful -- it would be nice for there to be a syntax for this, e.g. ?+.

[edemaine]

So if I understand correctly, the proposal is arr?.# ?+ 1 ?? 0. Looks nice to me! I imagine it could work for custom operators, instanceof, in, etc.

[bbrk24]

A couple notes:

• If the pipe counts as an operator (which it might not — see Cannot create operator with same precedence as pipe #1050), this supersedes Non-null pipe ?|> #897.
• If assignment operators are included in this, the behavior it would imply for ?= is the exact opposite of its current behavior.
• Less of an observation and more of a question: does it make sense to extend this to unary operators? x?++ is reminiscent of optional index access / calls, but ?-x looks a little strange.