[Python-ideas] Spelling of Assignment Expressions PEP 572 (was post #4)
steve at pearwood.info
Fri Apr 13 07:04:32 EDT 2018
On Wed, Apr 11, 2018 at 03:32:04PM +1000, Chris Angelico wrote:
> In any context where arbitrary Python expressions can be used, a **named
> expression** can appear. This can be parenthesized for clarity, and is of
> the form ``(target := expr)`` where ``expr`` is any valid Python expression,
> and ``target`` is any valid assignment target.
Have we really decided on spelling this as `target := expression`? You
list this as a rejected spelling:
> 1. ``EXPR as NAME``, with or without parentheses::
> stuff = [[f(x) as y, x/y] for x in range(5)]
but I don't think the objections given should be fatal:
> Omitting the parentheses in this form of the proposal introduces many
> syntactic ambiguities. Requiring them in all contexts leaves open the
> option to make them optional in specific situations where the syntax is
> unambiguous (cf generator expressions as sole parameters in function
> calls), but there is no plausible way to make them optional everywhere.
> With the parentheses, this becomes a viable option, with its own tradeoffs
> in syntactic ambiguity. Since ``EXPR as NAME`` already has meaning in
> ``except`` and ``with`` statements (with different semantics), this would
> create unnecessary confusion or require special-casing.
The special casing you refer to would be to prohibit name binding
expressions in "except" and "with" statements. You should explicitly say
so in the PEP.
I don't think that prohibiting those two forms is a big loss. I think
any form of
except (name := expression) as err:
is going to be contrived. Likewise for `with` statements.
I don't especially dislike := but I really think that putting the
expression first is a BIG win for readability. If that requires parens
to disambiguate it, so be it.
You also missed the "arrow assignment operator" from various languages,
expression -> name
(In an earlier post, I suggested R's other arrow operator, name <- expr,
but of course that already evaluates as unary minus expr.)
I think that there should be more attention paid to the idea of putting
the expression first, rather than the name.
More information about the Python-ideas