On 09/28/2015 12:38 PM, Guido van Rossum wrote:
> On Mon, Sep 28, 2015 at 10:38 AM, Carl Meyer <carl@oddbird.net

>     "Propagating" refers to the proposed behavior where use of ?. or ?[
>     "propagates" through the following chain of operations. For example:
>
>         x = foo?.bar.spam.eggs
>
>     Where both `.spam` and `.eggs` would behave like `?.spam` and `?.eggs`
>     (propagating None rather than raising AttributeError), simply because a
>     `.?` had occurred earlier in the chain. So the above behaves differently
>     from:
>
>         temp = foo?.bar
>         x = temp.spam.eggs
>
>     Which raises questions about whether the propagation escapes
>     parentheses, too:
>
>         x = (foo?.bar).spam.eggs
>
> Oh, I see. That's evil.
>
> The correct behavior here is that "foo?.bar.spam.eggs" should mean the
> same as
>
>     (None if foo is None else foo.bar.spam.eggs)
>
> (Stop until you understand that is *not* the same as either of the
> alternatives you describe.)

I see that. The distinction is "short-circuit" vs "propagate."
Short-circuit is definitely more comprehensible and palatable.

[snip]
> It should not escape parentheses.

Good. I assume that the short-circuiting would follow the precedence
order; that is, nothing with looser precedence than member and index
access would be short-circuited. So, for example,

    foo?.bar['baz'].spam

would short-circuit the indexing and the final member access, translating to

    foo.bar['baz'].spam if foo is not None else None

but

    foo?.bar or 'baz'

would mean

    (foo.bar if foo is not None else None) or 'baz'

and would never evaluate to None. Similarly for any operator that binds
less tightly than member/index access (which is basically all Python
operators).

AFAICS, under your proposed semantics what I said above is still true, that

    x = foo?.bar.baz

would necessarily have a different meaning than

    temp = foo?.bar
    x = temp.baz

Or put differently, that whereas these two are trivially equivalent (the
definition of left-to-right binding within a precedence class):

    foo.bar.baz
    (foo.bar).baz

these two are not equivalent:

   foo?.bar.baz
   (foo?.bar).baz

I'm having trouble coming up with a parallel example where the existing
short-circuit operators break "extractibility" of a sub-expression like
that.

I guess this is because the proposed short-circuiting still "breaks out
of the precedence order" in a way that the existing short-circuiting
operators don't. Both member access and indexing are within the same
left-to-right binding precedence class, but the new operators would have
a short-circuit effect that swallows operations beyond where normal
left-to-right binding would suggest their effect should reach.

Are there existing examples of behavior like this in Python that I'm
missing?