Not coalescing around None-aware

My problem with these operators (and a lot of what already happened to Python in the last few releases) is that it is similar to the Java discussion on the checked exceptions: it is completely dominated by people who didn’t understand the problem and they are trying to get rid of something which they consider just an annoyance.

For me all those if foo is None are code smell: a sign of poorly created API (perhaps unavoidable, because introduced from an external library). Similarly to the checked exceptions, when you start to look for improved syntax which would get rid of if is None then reconsider whole code around the problem and you may find that you need restructure it to express your algorithm better.

I think this particular example comes from a language design anti-pattern, where, in order to introduce a feature, you present the simplest case in which you could use it. It seems like an easy way to show what the feature can do, but changing the language is not worthwhile just to make a simple statement slightly simpler. There's a value in not repeating an expression, but it's hard to appreciate if the example expression is a single-character variable name.

Consider: "if we're told to check size limits, and the size of the message's header, if any, plus the size of the message's body, if any, is greater than the limit, raise an exception". (And the message representation might be using complicated objects for header and body that may be expensive to get the length of if it isn't needed, and want to clearly distinguish the case of not having a body or header in other places by using None to represent this situation.) That's:

if check_size_limits and (len(message.header ?? "") +
                          len(message.body ?? "")) > limit:
    raise Exception()

With the feature, and:

if check_size_limits:
    header_length = 0
    if message.header is not None:
        header_length = len(message.header)
    body_length = 0
    if message.body is not None:
        body_length = len(message.body)
    if header_length + body_length > limit:
        raise Exception()

Or:

if check_size_limits and ((len(message.header) if message.header is not None else 0) +
                          (len(message.body) if message.body is not None else 0)) > limit:
    raise Exception()

With the feature, you can write something much closer to the specification, and if the next version of the code has to add "likewise for the message's footer", the programmer who copies the "header" section and changes "header" to "footer" can't miss the second place that "header" appeared. Furthermore, the first one consists entirely of text you'd want to read in order to understand what it's doing, while the others have portions you'd skim, and hope that they correctly implement "if necessary". Similarly, "(some long but descriptive expression)?.attribute" is much easier to understand than "(some long but descriptive expression).attribute if (probably the same thing but maybe not) is not None else None", while "x.y if x is not None else None" isn't worth the trouble.

That said, I find the operator "??" doesn't feel Pythonic to me, and I think some short word would fit the Python better, but I can't think of a word that would suit; "?." also seems weird, but I can't think how to avoid using a weird symbol when the basic expression uses as operator already.