The Python steering council and the broader developer community are currently evaluating a transformative proposal that seeks to redefine the capabilities of type annotations within the language. PEP 849, authored by Imogen Hergeth and sponsored by Jelle Zijlstra, proposes a significant overhaul of how the Python interpreter handles type expressions. By introducing a new mechanism to capture the Abstract Syntax Tree (AST) of annotations at runtime, the proposal aims to unlock a level of expressiveness previously reserved for static analysis tools, potentially bringing Python’s type system closer to the flexibility found in languages like TypeScript.
The Evolution of Python Type Annotations
To understand the necessity of PEP 849, one must look at the history of type hinting in Python. Introduced in PEP 484, type hints were originally intended primarily for static type checkers like MyPy. However, the ecosystem quickly adapted these hints for runtime use. Frameworks such as Pydantic, FastAPI, and SQLAlchemy began using annotations to perform data validation, serialization, and database mapping.
This dual-use nature of annotations—serving both static linters and runtime logic—created a fundamental tension. Currently, Python evaluates type annotations as standard expressions. If a developer writes x: list[int], the Python interpreter executes that expression and stores the resulting object. While this works for simple types, it fails for more complex logic. Because these expressions are evaluated using standard Python semantics, many potential type-system features are impossible to implement because the resulting value loses the original "intent" of the expression. PEP 849 seeks to resolve this by providing a way to access the structure of the expression itself, rather than just its final evaluated result.
The Core Proposal: Transitioning to AST-Based Introspection
The technical heart of PEP 849 is the introduction of a new format for the __annotate__ function. In recent versions of Python, specifically following the implementation of PEP 649 and PEP 749, the interpreter moved toward using a special __annotate__ method to handle the deferred evaluation of annotations. PEP 849 builds upon this infrastructure by adding Format.AST to the annotationlib.Format enumeration.
Under the current system, calling an annotation function typically returns a dictionary of evaluated objects (e.g., 'a': int). Under the proposed PEP 849 system, a consumer can request the AST format. This returns an AnnotationAST object containing two critical pieces of data: the AST of the expression (as defined in Python’s ast module) and the namespace in which the expression was defined.
By capturing the AST, runtime libraries can "see" the original code written by the developer. For example, if a developer writes a union of literals such as 1 | 2 | 3, a standard Python evaluation would simply return the integer 3 (the result of bitwise OR operations). However, with the AST format, a library can inspect the tree, see that the developer used the pipe operator between three literal integers, and correctly interpret the intent as a type union of specific values.
Motivation: Solving the "Literal" and "Conditional" Problems
The proposal highlights several concrete use cases that are currently hindered by Python’s evaluation model. One of the most prominent is the syntax for Literal types. Currently, developers must write Literal[1, 2, 3]. There is a strong desire within the community to use the more concise 1 | 2 | 3. However, because | is the bitwise OR operator for integers, the expression collapses into a single value before any type checker or runtime tool can see the individual components. Furthermore, Python’s compiler performs "constant folding," meaning the expression 1 | 2 | 3 might be replaced by the value 3 in the bytecode, making the original source invisible to reflection.
Another significant motivator is the implementation of conditional types. A proposed (though not yet implemented) feature involves types that change based on a condition, similar to a ternary operator: TypeA if Condition else TypeB. In the current Python runtime, only one branch of a ternary operator is evaluated. The branch not taken is effectively deleted from the execution path, making it impossible for a runtime tool to inspect the full logic of the type annotation.
PEP 849 also addresses the potential for "TypedDict comprehensions." Developers have long requested the ability to define complex dictionary types using comprehension-like syntax, such as K: NotRequired[T] for K, T in BaseDict. Currently, type objects are not iterable in this manner, and the interpreter would throw a TypeError. By capturing the AST, the typing module could interpret this comprehension syntax as a set of rules for generating a new type, rather than trying to execute it as standard Python code.
Performance Implications and Comparative Data
The authors of PEP 849 acknowledge that such a fundamental change requires careful performance analysis. Type annotations are optional, and any feature that penalizes users who do not use them—or even those who only use them for static analysis—is likely to face resistance.
According to the reference implementation data provided in the PEP, the impact is categorized into three groups:
- Non-users: For modules that contain no type annotations, there is no measurable impact on import time or memory usage.
- Static-only users: For modules with annotations that are never inspected at runtime, the proposal actually offers a slight improvement. Import times were found to be "moderately faster," and the memory footprint was reduced by a few percentage points because the binary AST data is more compact than the bytecode required to evaluate complex expressions.
- Runtime consumers: This is where the trade-off is most apparent. For libraries that actively evaluate annotations (like Pydantic or dataclasses), the evaluation time can increase significantly. In the worst-case scenario—where every name in an annotation is defined and a full value-format dictionary is requested—the evaluation can be up to seven times slower than the current method.
However, the authors argue that this slowdown is comparable to the existing overhead when Python encounters undefined forward references or strings in annotations. Since the performance penalty is localized to the moment of evaluation—usually occurring only once during class definition or application startup—the trade-off is deemed acceptable for the sake of the new functionality provided.
Timeline and Chronology of the Proposal
The journey of PEP 849 began in late 2025, reflecting a multi-year effort to modernize Python’s internals.
- November 5, 2025: The initial idea for simpler and more expressive type annotations was posted to the Python Discourse, sparking a lengthy debate among core developers.
- September 2, 2026: A formal draft of the PEP was introduced, focusing on the technical mechanism of AST capture.
- September 20, 2026: PEP 849 was officially created and assigned its number.
- September 22, 2026: The proposal moved into active discussion on the Standards Track, targeting Python version 3.16.
The proposal is currently in the "Draft" status, meaning it is subject to revision based on feedback from the community and the Steering Council. If accepted, it would likely be one of the headline features of Python 3.16.
Official Responses and Community Reactions
While the PEP is still in its discussion phase, initial reactions from the community have been a mix of excitement and caution. Maintainers of major runtime-typing libraries have expressed support for the increased flexibility. The ability to implement complex type logic without "hacks" or string-based forward references is seen as a major win for the ecosystem’s ergonomics.
Conversely, some core developers have raised concerns about the complexity of adding an AST-dependent feature to the runtime. Historically, Python has tried to keep the ast module and the execution runtime somewhat separate. PEP 849 ties them together more closely. There are also ongoing discussions about the deprecation of typing.get_type_hints. The PEP suggests that this venerable function should be replaced by typing.get_type_annotations, a move that would require thousands of libraries to update their codebases to support the new standard.
Broader Impact and Industry Implications
If PEP 849 is adopted, the implications for the Python industry are profound. It would essentially pave the way for a "Type Language" within Python that is syntactically identical to Python but semantically independent.
For Web Development, this means frameworks could support much more complex validation logic directly in function signatures. For Data Science, it could allow for more descriptive tensor shapes and data constraints to be embedded in types, which could then be used by compilers like XLA or TorchScript to optimize code.
Furthermore, the proposal includes a "backwards compatibility" safeguard. Future additions to the typing spec that utilize this new AST format will not break existing code. If a user does not opt-in to the new AST-based evaluation, the interpreter will continue to treat the annotations as it always has. This "gradual adoption" model is designed to ensure that the transition to more expressive types does not cause a repeat of the difficult Python 2 to 3 migration.
Ultimately, PEP 849 represents a maturing of Python’s type system. It acknowledges that annotations are no longer just "hints," but are a core part of the language’s metadata infrastructure. By giving the runtime the ability to understand the structure of code rather than just its result, Python 3.16 may well become the most expressive version of the language to date.
