On 2018-07-18 18:43, Steve Dower wrote:
Possibly this is exactly the wrong time to propose the next big syntax
change, since we currently have nobody to declare on it, but since we're
likely to argue for a while anyway it probably can't hurt (and maybe
this will become the test PEP for whoever takes the reins?).
FWIW, Guido had previously indicated that he was generally favourable
towards most of this proposal, provided we could figure out coherent
semantics. Last time we tried, that didn't happen, so this time I've
made the semantics much more precise, have implemented and verified
them, and made much stronger statements about why we are proposing these.
Additional thanks to Mark Haase for writing most of the PEP. All the
fair and balanced parts are his - all the overly strong opinions are mine.
Also thanks to Nick Coghlan for writing PEPs 531 and 532 last time we
went through this - if you're unhappy with "None" being treated as a
special kind of value, I recommend reading those before you start
repeating them.
There is a formatted version of this PEP at
https://www.python.org/dev/peps/pep-0505/
My current implementation is at
https://github.com/zooba/cpython/tree/pep-505 (though I'm considering
removing some of the new opcodes I added and just generating more
complex code - in any case, let's get hung up on the proposal rather
than the implementation :) )
Let the discussions begin!
[snip]
Grammar changes
---------------
The following rules of the Python grammar are updated to read::
augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' |
'^=' |
'<<=' | '>>=' | '**=' | '//=' | '??=')
power: coalesce ['**' factor]
coalesce: atom_expr ['??' factor]
atom_expr: ['await'] atom trailer*
trailer: ('(' [arglist] ')' |
'[' subscriptlist ']' |
'?[' subscriptlist ']' |
'.' NAME |
'?.' NAME)
The precedence is higher than I expected. I think of it more like 'or'.
What is its precedence in the other languages?
Inserting the ``coalesce`` rule in this location ensures that expressions
resulting in ``None`` are natuarlly coalesced before they are used in
Typo "natuarlly".
operations that would typically raise ``TypeError``. Like ``and`` and ``or``
the right-hand expression is not evaluated until the left-hand side is
determined to be ``None``. For example::
a, b = None, None
def c(): return None
def ex(): raise Exception()
(a ?? 2 ** b ?? 3) == a ?? (2 ** (b ?? 3))
(a * b ?? c // d) == a * (b ?? c) // d
(a ?? True and b ?? False) == (a ?? True) and (b ?? False)
(c() ?? c() ?? True) == True
(True ?? ex()) == True
(c ?? ex)() == c()
Augmented coalescing assignment only rebinds the name if its current
value is
``None``. If the target name already has a value, the right-hand side is not
evaluated. For example::
a = None
b = ''
c = 0
a ??= 'value'
b ??= undefined_name
c ??= shutil.rmtree('/') # don't try this at home, kids
assert a == 'value'
assert b == ''
assert c == '0' and any(os.scandir('/'))
Wouldn't the last assertion fail, because c == 0?
[snip]
_______________________________________________
Python-ideas mailing list
Python-ideas@python.org
https://mail.python.org/mailman/listinfo/python-ideas
Code of Conduct: http://python.org/psf/codeofconduct/
