Add perchance, a soft keyword for exception-tolerant expressions (PoC)

This introduces an expression-level fallback for exceptions — the thing `dict.get()` does for one specific case, generalized to any fallible expression: `port = int(os.environ["PORT"]) perchance 8080` evaluates the left operand and, if it raises an exception matching the guard (default: `Exception`, never `BaseException`), yields the fallback instead. An explicit guard is spelled `first = seq[0] perchance None from IndexError`, accepting anything an `except` clause accepts. The fallback and guard are lazily evaluated only when an exception occurs, so it short-circuits like `or` but over exceptions rather than falsiness, and chains left-associatively: `d["a"] perchance d["b"] perchance "default"`. This is PEP 463 (exception-catching expressions) with the syntactic objections fixed: no colon inside the expression, no parentheses required, and it reads as English at exactly the point where the program acknowledges chance. The killer use case is comprehensions, where a fallible step today forces a named helper function or an inner try statement: `[int(line) perchance None from ValueError for line in text.splitlines()]`.

There is also a statement form, `perchance FileNotFoundError, PermissionError: os.unlink(tmp)`, which is sugar for `try:`/`except (...): pass` — the pattern the stdlib alone spells out ~1360 times. The exception list is mandatory: there is no bare `perchance:`, so swallowing everything requires writing `perchance Exception:` and owning it in review.

Design decisions worth noting: the exception object is not bindable (no `as`) — if you need it, you need a try statement; this is the lambda principle, keeping the expression form too small to hide logic in. The default guard is loaded via a new `LOAD_COMMON_CONSTANT` slot (`CONSTANT_EXCEPTION`) rather than a name lookup, so a local `Exception = ...` cannot change what gets caught. A swallowed exception rides along as `__context__` if the fallback itself raises. Mixing with a conditional expression requires parentheses. `perchance` is a soft keyword like `match`: juxtaposed NAME NAME is a syntax error today, so no existing code changes meaning, and `perchance` remains usable as an identifier — `x = perchance perchance 0` parses and means what you'd hope.

Implementation: new `Perchance(expr value, expr fallback, expr? guard)` node in Python.asdl; a left-recursive `perchance_expression` grammar rule next to `if_expression`; the statement form is desugared to `Try` directly in the parser action, so it needs no new statement node, symtable, or codegen support. Code generation mirrors `codegen_try_except` and uses the zero-cost exception tables: the happy path executes no extra instructions, with the handler reachable only through the exception table. Both forms are gated with `CHECK_VERSION(16)`. Known wart for a real version: in `raise f() perchance g() from cause`, the `from` binds to the perchance guard, not the raise cause — parenthesize to disambiguate; dedicated invalid-syntax rules with helpful errors are left for later, as are docs and tests.

To sleep, perchance to dream.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: ambv

Grammar/python.gram

@@ -143,6 +143,7 @@ compound_stmt[stmt_ty]:
     | &'try' try_stmt
     | &'while' while_stmt
     | match_stmt
+    | perchance_stmt
 
 # SIMPLE STATEMENTS
 # =================
@@ -481,6 +482,21 @@ finally_block[asdl_stmt_seq*]:
     | invalid_finally_stmt
     | 'finally' &&':' a=block { a }
 
+# Perchance statement
+# -------------------
+# "perchance E1, E2: block" is sugar for "try: block / except (E1, E2): pass"
+# and is desugared to a Try node right here in the parser.
+
+perchance_stmt[stmt_ty]:
+    | "perchance" e=expressions ':' b=block {
+        CHECK_VERSION(stmt_ty, 16, "Perchance statements are",
+            _PyAST_Try(b,
+                CHECK(asdl_excepthandler_seq*, _PyPegen_singleton_seq(p,
+                    CHECK(excepthandler_ty, _PyAST_ExceptHandler(e, NULL,
+                        CHECK(asdl_stmt_seq*, _PyPegen_singleton_seq(p,
+                            CHECK(stmt_ty, _PyAST_Pass(EXTRA)))), EXTRA)))),
+                NULL, NULL, EXTRA)) }
+
 # Match statement
 # ---------------
 
@@ -719,12 +735,18 @@ expression[expr_ty] (memo):
     | invalid_expression
     | invalid_legacy_expression
     | if_expression
+    | perchance_expression
     | disjunction
     | lambdef
 
 if_expression[expr_ty]:
     | a=disjunction 'if' b=disjunction 'else' c=expression { _PyAST_IfExp(b, a, c, EXTRA) }
 
+perchance_expression[expr_ty] (memo):
+    | a=perchance_expression "perchance" f=disjunction g=['from' e=disjunction { e }] {
+        CHECK_VERSION(expr_ty, 16, "Perchance expressions are", _PyAST_Perchance(a, f, g, EXTRA)) }
+    | disjunction
+
 yield_expr[expr_ty]:
     | 'yield' 'from' a=expression { _PyAST_YieldFrom(a, EXTRA) }
     | 'yield' a=[star_expressions] { _PyAST_Yield(a, EXTRA) }

Include/internal/pycore_ast.h

@@ -82,7 +82,8 @@ extern "C" {
 #define CONSTANT_MINUS_ONE 11
 #define CONSTANT_BUILTIN_FROZENSET 12
 #define CONSTANT_EMPTY_TUPLE 13
-#define NUM_COMMON_CONSTANTS 14
+#define CONSTANT_EXCEPTION 14
+#define NUM_COMMON_CONSTANTS 15
 
 /* Values used in the oparg for RESUME */
 #define RESUME_AT_FUNC_START 0

Include/internal/pycore_ast_state.h

@@ -772,6 +772,17 @@ def visit_IfExp(self, node):
             self.set_precedence(_Precedence.TEST, node.orelse)
             self.traverse(node.orelse)
 
+    def visit_Perchance(self, node):
+        with self.require_parens(_Precedence.TEST, node):
+            self.set_precedence(_Precedence.TEST.next(), node.value, node.fallback)
+            self.traverse(node.value)
+            self.write(" perchance ")
+            self.traverse(node.fallback)
+            if node.guard:
+                self.set_precedence(_Precedence.TEST.next(), node.guard)
+                self.write(" from ")
+                self.traverse(node.guard)
+
     def visit_Set(self, node):
         if node.elts:
             with self.delimit("{", "}"):

Include/internal/pycore_opcode_utils.h

@@ -44,7 +44,8 @@
                      builtins.set,
                      # Append-only — must match CONSTANT_* in
                      # Include/internal/pycore_opcode_utils.h.
-                     None, "", True, False, -1, builtins.frozenset, ()]
+                     None, "", True, False, -1, builtins.frozenset, (),
+                     builtins.Exception]
 _nb_ops = _opcode.get_nb_ops()
 
 hascompare = [opmap["COMPARE_OP"]]

Lib/_ast_unparse.py

@@ -63,6 +63,7 @@ module Python
          | UnaryOp(unaryop op, expr operand)
          | Lambda(arguments args, expr body)
          | IfExp(expr test, expr body, expr orelse)
+         | Perchance(expr value, expr fallback, expr? guard)
          | Dict(expr?* keys, expr* values)
          | Set(expr* elts)
          | ListComp(expr elt, comprehension* generators)