Here is a preliminary implementation of PEP 463, minus mandatory parentheses and with the most straightforward precedence rule: equal to if-expr -- which means this:

A if C else B except E: D

is parsed as

A if C else (B except E: D)

(because of associativity, not precedence) and not as

(A if C else B) except E: D

as suggested by the PEP with the hand-wavy words 'between lambda and if/else in precedence'. The latter is possible but means a little more hoop-jumping in the grammar.

The tests included are rudimentary (at the end of test_grammar.py) and could probably do with some fleshing out, partially as tests and partially to try out how the precedence rules work out in practice.

http://hg.python.org/features/pep-463-except-expr now contains a version of the patch that makes the parentheses mandatory, similar to generator expressions. (Leaving the old patch for reference.)

One test failing, due to Tools/parser/unparse.py not knowing how to unparse an except expression. Otherwise, test suite passes (with most of the stdlib unchanged). I'm about to try writing an actual conversion script which will rewrite the stdlib, and then see how much of the test suite still passes. (For this, I'll be doing only the easiest/simplest translations - the ones that involve simple or augmented assignment, and return statements - and I'll ignore PEP 8.)

I've applied all the changes my script can find, including ones that are actually quite inappropriate, like:

    try:
        some_function_call()
    except some_exception:
        some_other_function_call()

All tests pass except for one, which I don't fully understand. Attaching patches:

1) make_stuff_work.diff - what it says on the tin. I don't understand everything that's going on in there, but the build process made some changes to tracked files.

2) churn1.diff - mostly-plausible edits. They're unnecessary code churn, and shouldn't be done wholesale like this, but they make the obvious changes.

3) churn2.diff - less plausible edits, in the two-expression form shown above. These definitely shouldn't be done... but they don't break any of the tests, so they're a reasonable proof that the concept works.

4) broken.diff - for some reason that I don't understand, this causes a test failure. Something that's supposed to produce no output now produces a warning. I cannot figure out how there's a difference in there. Advice please?

The broken one is of the inappropriate type, but the fact that it doesn't work seems... indicative, somehow. Indicative of what, I don't know, and it's 8AM after I've been up all night, so I'm not going to try further to figure this out.

It's not part of the PEP, but what happens with the new syntax if there is an existing exception context? Some utilities (e.g. functools.lru_cache) use dict.get over a try/except because they operate under the assumption that they may be invoked within an except block, and must leave the exception context (if any) unmodified.

It seems like something intended to serve as a general replacement for non-exception raising functions like dict.get should have similar exception context preserving semantics.

The implementation in the patch preserves the exception context. It's probably the thing that took the most code, and it's why there's two new opcodes in the patch :) It's covered in the tests, too.

Guido's comment about the PEP is at https://mail.python.org/pipermail/python-dev/2014-March/133118.html

Can we close this and mark PEP 463 as rejected now?