Zusammenfassung

Diese PEP schlägt vor, den Operator | für Typen zu überladen, um Union[X, Y] als X | Y zu schreiben, und erlaubt dessen Verwendung in isinstance- und issubclass-Aufrufen.

Motivation

PEP 484 und PEP 526 schlagen eine generische Syntax für die Typisierung von Variablen, Parametern und Funktionsrückgaben vor. PEP 585 schlägt vor, Parameter für Generics zur Laufzeit verfügbar zu machen. Mypy [1] akzeptiert eine Syntax, die aussieht wie

annotation: name_type
name_type: NAME (args)?
args: '[' paramslist ']'
paramslist: annotation (',' annotation)* [',']

• Um eine Disjunktion (Union-Typ) zu beschreiben, muss der Benutzer Union[X, Y] verwenden.

Die Ausführlichkeit dieser Syntax trägt nicht zur Akzeptanz von Typen bei.

Vorschlag

Inspiriert von Scala [2] und Pike [3], fügt dieser Vorschlag den Operator type.__or__() hinzu. Mit diesem neuen Operator ist es möglich, int | str anstelle von Union[int, str] zu schreiben. Zusätzlich zu Annotationen wäre das Ergebnis dieses Ausdrucks dann in isinstance() und issubclass() gültig.

isinstance(5, int | str)
issubclass(bool, int | float)

Wir werden auch in der Lage sein, t | None oder None | t anstelle von Optional[t] zu schreiben.

isinstance(None, int | None)
isinstance(42, None | int)

Spezifikation

Die neue Union-Syntax sollte für Funktions-, Variablen- und Parameterannotationen akzeptiert werden.

# Instead of
# def f(list: List[Union[int, str]], param: Optional[int]) -> Union[float, str]
def f(list: List[int | str], param: int | None) -> float | str:
    pass

f([1, "abc"], None)

# Instead of typing.List[typing.Union[str, int]]
typing.List[str | int]
list[str | int]

# Instead of typing.Dict[str, typing.Union[int, float]]
typing.Dict[str, int | float]
dict[str, int | float]

int | str == typing.Union[int, str]

typing.Union[int, int] == int
int | int == int

(int | str) == (str | int)
(int | str | float) == typing.Union[str, float, int]

None | t == typing.Optional[t]

str(int | list[str])
# int | list[str]

str(int | int)
# int

# valid
isinstance("", int | str)

# invalid
isinstance(2, list[int]) # TypeError: isinstance() argument 2 cannot be a parameterized generic
isinstance(1, int | list[int])

# valid
issubclass(bool, int | float)

# invalid
issubclass(bool, bool | list[int])

Inkompatible Änderungen

In einigen Situationen werden einige Ausnahmen nicht wie erwartet ausgelöst.

Wenn eine Metaklasse den Operator __or__ implementiert, wird sie diesen überschreiben.

>>> class M(type):
...     def __or__(self, other): return "Hello"
...
>>> class C(metaclass=M): pass
...
>>> C | int
'Hello'
>>> int | C
typing.Union[int, __main__.C]
>>> Union[C, int]
typing.Union[__main__.C, int]

Einwände und Antworten

Weitere Details zu den Diskussionen finden Sie unten.

• Diskussion in python-ideas
• Diskussion in typing-sig

>>> from __future__ import annotations
>>> def foo() -> int | str: pass
...
>>> eval(foo.__annotations__['return'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
TypeError: unsupported operand type(s) for |: 'type' and 'type'

isinstance(x, str | int) ==> "is x an instance of str or int"

Referenzimplementierung

Ein neuer integrierter Union-Typ muss implementiert werden, um den Rückgabewert von t1 | t2 zu speichern, und er muss von isinstance() und issubclass() unterstützt werden. Dieser Typ kann im types-Modul platziert werden. Die Interoperabilität zwischen types.Union und typing.Union muss gewährleistet sein.

Sobald die Python-Sprache erweitert ist, müssen mypy [1] und andere Typ-Checker aktualisiert werden, um diese neue Syntax zu akzeptieren.

• Eine vorgeschlagene Implementierung für cpython finden Sie hier.
• Eine vorgeschlagene Implementierung für mypy finden Sie hier.

Referenzen

Urheberrecht

Dieses Dokument wird in die Public Domain oder unter die CC0-1.0-Universal-Lizenz gestellt, je nachdem, welche Lizenz permissiver ist.