On Sun, Apr 15, 2018 at 12:19 PM, Kirill Balunov
<kirillbalu...@gmail.com> wrote:
> 2018-04-15 6:08 GMT+03:00 Nick Coghlan <ncogh...@gmail.com>:

>> P.S. The pros and cons of the current syntax proposals, as I see them:
>> === Expression first, 'as' keyword ===
>>     while (read_next_item() as value) is not None:
>>         ...
>> Pros:
>>   * typically reads nicely as pseudocode
>>   * "as" is already associated with namebinding operations
> I understand that this list is subjective. But as for me it will be huge PRO
> that the expression comes first.
>> === Expression first, '->' symbol ===
>>     while (read_next_item() -> value) is not None:
>>         ...
>> Pros:
>>   * avoids the syntactic ambiguity of "as"
>>   * "->" is used for name bindings in at least some other languages
>> (but this is irrelevant to users for whom Python is their first, and
>> perhaps only, programming language)
>>   * invites the question "Why doesn't this use the 'as' keyword?"
> All forms invites this question :)))

Exactly, all forms invites this and other questions.

First of all, coming back to original spelling choice arguments
[Sorry in advance if I've missed some points in this huge thread]

citation from PEP:
  "Differences from regular assignment statements" [...]
  "Otherwise, the semantics of assignment are unchanged by this proposal."

So basically it's the same Python assignment?
Then obvious solution seems just to propose "=".
But I see Chris have put this in FAQ section:
"The syntactic similarity between ``if (x == y)`` and ``if (x = y)`` ...."

So IIUC, the *only* reason is to avoid '==' ad '=' similarity?
If so, then it does not sound convincing at all.
Of course Python does me a favor showing an error,
when I make a typo like this:
if (x = y)

But still, if this is the only real reason, it is not convincing.
Syntactically seen, I feel strong that normal '=' would be the way to go.

Just look at this:
y = ((eggs := spam()), (cheese := eggs.method())
y = ((eggs = spam()), (cheese = eggs.method())

The latter is so much cleaner, and already so common to any
old or new Python user. And does not raise a
question what this ":=" should really mean.
(Or probably it should raise such question?)

Given the fact that the PEP gives quite edge-case
usage examples only, this should be really more convincing.
And as a side note: I personally find the look of ":=" a bit 'noisy'.

Another point:

*Target first  vs  Expression first*

Well, this is nice indeed. Don't you find that first of all it must be
decided what should be the *overall tendency for Python*?
Now we have common "x = a + b" everywhere. Then there
are comprehensions (somewhat mixed direction) and
"foo as bar" things.
But wait, is the tendency to "give the freedom"? Then you should
introduce something like "<--" in the first place so that we can
write normal assignment in both directions.
Or is the tendency to convert Python to the "expression first" generally?

So if this question can be answered first, then I think it will be
more constructive to discuss the choice of particular spellings.

Python-ideas mailing list
Code of Conduct: http://python.org/psf/codeofconduct/

Reply via email to