77b2cee223
This PR adds two new `ty_extensions` functions, `reveal_when_assignable_to` and `reveal_when_subtype_of`. These are closely related to the existing `is_assignable_to` and `is_subtype_of`, but instead of returning when the property (always) holds, it produces a diagnostic that describes _when_ the property holds. (This will let us construct mdtests that print out constraints that are not always true or always false — though we don't currently have any instances of those.) I did not replace _every_ occurrence of the `is_property` variants in the mdtest suite, instead focusing on the generics-related tests where it will be important to see the full detail of the constraint sets. As part of this, I also updated the mdtest harness to accept the shorter `# revealed:` assertion format for more than just `reveal_type`, and updated the existing uses of `reveal_protocol_interface` to take advantage of this.
28 KiB
PEP 695 Generics
[environment]
python-version = "3.13"
PEP 695 and Python 3.12 introduced new, more ergonomic syntax for type variables.
Type variables
Defining PEP 695 type variables
PEP 695 introduces a new syntax for defining type variables. The resulting type variables are
instances of typing.TypeVar, just like legacy type variables.
def f[T]():
reveal_type(type(T)) # revealed: <class 'TypeVar'>
reveal_type(T) # revealed: typing.TypeVar
reveal_type(T.__name__) # revealed: Literal["T"]
Type variables with a default
Note that the __default__ property is only available in Python ≥3.13.
[environment]
python-version = "3.13"
def f[T = int]():
reveal_type(type(T)) # revealed: <class 'TypeVar'>
reveal_type(T) # revealed: typing.TypeVar
reveal_type(T.__default__) # revealed: int
reveal_type(T.__bound__) # revealed: None
reveal_type(T.__constraints__) # revealed: tuple[()]
def g[S]():
reveal_type(S.__default__) # revealed: NoDefault
Using other typevars as a default
[environment]
python-version = "3.13"
class Valid[T, U = T, V = T | U]: ...
reveal_type(Valid()) # revealed: Valid[Unknown, Unknown, Unknown]
reveal_type(Valid[int]()) # revealed: Valid[int, int, int]
reveal_type(Valid[int, str]()) # revealed: Valid[int, str, int | str]
reveal_type(Valid[int, str, None]()) # revealed: Valid[int, str, None]
# error: [unresolved-reference]
class Invalid[S = T]: ...
Type variables with an upper bound
def f[T: int]():
reveal_type(type(T)) # revealed: <class 'TypeVar'>
reveal_type(T) # revealed: typing.TypeVar
reveal_type(T.__bound__) # revealed: int
reveal_type(T.__constraints__) # revealed: tuple[()]
def g[S]():
reveal_type(S.__bound__) # revealed: None
Type variables with constraints
def f[T: (int, str)]():
reveal_type(type(T)) # revealed: <class 'TypeVar'>
reveal_type(T) # revealed: typing.TypeVar
reveal_type(T.__constraints__) # revealed: tuple[int, str]
reveal_type(T.__bound__) # revealed: None
def g[S]():
reveal_type(S.__constraints__) # revealed: tuple[()]
Cannot have only one constraint
TypeVarsupports constraining parametric types to a fixed set of possible types...There should be at least two constraints, if any; specifying a single constraint is disallowed.
# error: [invalid-type-variable-constraints] "TypeVar must have at least two constrained types"
def f[T: (int,)]():
pass
Invalid uses
Note that many of the invalid uses of legacy typevars do not apply to PEP 695 typevars, since the PEP 695 syntax is only allowed places where typevars are allowed.
Displaying typevars
We use a suffix when displaying the typevars of a generic function or class. This helps distinguish different uses of the same typevar.
def f[T](x: T, y: T) -> None:
reveal_type(x) # revealed: T@f
class C[T]:
def m(self, x: T) -> None:
reveal_type(x) # revealed: T@C
Subtyping and assignability
(Note: for simplicity, all of the prose in this section refers to subtyping involving fully static typevars. Unless otherwise noted, all of the claims also apply to assignability involving gradual typevars.)
We can make no assumption about what type an unbounded, unconstrained, fully static typevar will be
specialized to. Properties are true of the typevar only if they are true for every valid
specialization. Thus, the typevar is a subtype of itself and of object, but not of any other type
(including other typevars).
from ty_extensions import reveal_when_assignable_to, reveal_when_subtype_of
class Super: ...
class Base(Super): ...
class Sub(Base): ...
class Unrelated: ...
def unbounded_unconstrained[T, U](t: T, u: U) -> None:
reveal_when_assignable_to(T, T) # revealed: always
reveal_when_assignable_to(T, object) # revealed: always
reveal_when_assignable_to(T, Super) # revealed: never
reveal_when_assignable_to(U, U) # revealed: always
reveal_when_assignable_to(U, object) # revealed: always
reveal_when_assignable_to(U, Super) # revealed: never
reveal_when_assignable_to(T, U) # revealed: never
reveal_when_assignable_to(U, T) # revealed: never
reveal_when_subtype_of(T, T) # revealed: always
reveal_when_subtype_of(T, object) # revealed: always
reveal_when_subtype_of(T, Super) # revealed: never
reveal_when_subtype_of(U, U) # revealed: always
reveal_when_subtype_of(U, object) # revealed: always
reveal_when_subtype_of(U, Super) # revealed: never
reveal_when_subtype_of(T, U) # revealed: never
reveal_when_subtype_of(U, T) # revealed: never
A bounded typevar is assignable to its bound, and a bounded, fully static typevar is a subtype of
its bound. (A typevar with a non-fully-static bound is itself non-fully-static, and therefore does
not participate in subtyping.) A fully static bound is not assignable to, nor a subtype of, the
typevar, since the typevar might be specialized to a smaller type. (This is true even if the bound
is a final class, since the typevar can still be specialized to Never.)
from typing import Any
from typing_extensions import final
def bounded[T: Super](t: T) -> None:
reveal_when_assignable_to(T, Super) # revealed: always
reveal_when_assignable_to(T, Sub) # revealed: never
reveal_when_assignable_to(Super, T) # revealed: never
reveal_when_assignable_to(Sub, T) # revealed: never
reveal_when_subtype_of(T, Super) # revealed: always
reveal_when_subtype_of(T, Sub) # revealed: never
reveal_when_subtype_of(Super, T) # revealed: never
reveal_when_subtype_of(Sub, T) # revealed: never
def bounded_by_gradual[T: Any](t: T) -> None:
reveal_when_assignable_to(T, Any) # revealed: always
reveal_when_assignable_to(Any, T) # revealed: always
reveal_when_assignable_to(T, Super) # revealed: always
reveal_when_assignable_to(Super, T) # revealed: never
reveal_when_assignable_to(T, Sub) # revealed: always
reveal_when_assignable_to(Sub, T) # revealed: never
reveal_when_subtype_of(T, Any) # revealed: never
reveal_when_subtype_of(Any, T) # revealed: never
reveal_when_subtype_of(T, Super) # revealed: never
reveal_when_subtype_of(Super, T) # revealed: never
reveal_when_subtype_of(T, Sub) # revealed: never
reveal_when_subtype_of(Sub, T) # revealed: never
@final
class FinalClass: ...
def bounded_final[T: FinalClass](t: T) -> None:
reveal_when_assignable_to(T, FinalClass) # revealed: always
reveal_when_assignable_to(FinalClass, T) # revealed: never
reveal_when_subtype_of(T, FinalClass) # revealed: always
reveal_when_subtype_of(FinalClass, T) # revealed: never
Two distinct fully static typevars are not subtypes of each other, even if they have the same
bounds, since there is (still) no guarantee that they will be specialized to the same type. This is
true even if both typevars are bounded by the same final class, since you can specialize the
typevars to Never in addition to that final class.
def two_bounded[T: Super, U: Super](t: T, u: U) -> None:
reveal_when_assignable_to(T, U) # revealed: never
reveal_when_assignable_to(U, T) # revealed: never
reveal_when_subtype_of(T, U) # revealed: never
reveal_when_subtype_of(U, T) # revealed: never
def two_final_bounded[T: FinalClass, U: FinalClass](t: T, u: U) -> None:
reveal_when_assignable_to(T, U) # revealed: never
reveal_when_assignable_to(U, T) # revealed: never
reveal_when_subtype_of(T, U) # revealed: never
reveal_when_subtype_of(U, T) # revealed: never
A constrained fully static typevar is assignable to the union of its constraints, but not to any of the constraints individually. None of the constraints are subtypes of the typevar, though the intersection of all of its constraints is a subtype of the typevar.
from ty_extensions import Intersection
def constrained[T: (Base, Unrelated)](t: T) -> None:
reveal_when_assignable_to(T, Super) # revealed: never
reveal_when_assignable_to(T, Base) # revealed: never
reveal_when_assignable_to(T, Sub) # revealed: never
reveal_when_assignable_to(T, Unrelated) # revealed: never
reveal_when_assignable_to(T, Super | Unrelated) # revealed: always
reveal_when_assignable_to(T, Base | Unrelated) # revealed: always
reveal_when_assignable_to(T, Sub | Unrelated) # revealed: never
reveal_when_assignable_to(Super, T) # revealed: never
reveal_when_assignable_to(Unrelated, T) # revealed: never
reveal_when_assignable_to(Super | Unrelated, T) # revealed: never
reveal_when_assignable_to(Intersection[Base, Unrelated], T) # revealed: always
reveal_when_subtype_of(T, Super) # revealed: never
reveal_when_subtype_of(T, Base) # revealed: never
reveal_when_subtype_of(T, Sub) # revealed: never
reveal_when_subtype_of(T, Unrelated) # revealed: never
reveal_when_subtype_of(T, Super | Unrelated) # revealed: always
reveal_when_subtype_of(T, Base | Unrelated) # revealed: always
reveal_when_subtype_of(T, Sub | Unrelated) # revealed: never
reveal_when_subtype_of(Super, T) # revealed: never
reveal_when_subtype_of(Unrelated, T) # revealed: never
reveal_when_subtype_of(Super | Unrelated, T) # revealed: never
reveal_when_subtype_of(Intersection[Base, Unrelated], T) # revealed: always
def constrained_by_gradual[T: (Base, Any)](t: T) -> None:
reveal_when_assignable_to(T, Super) # revealed: always
reveal_when_assignable_to(T, Base) # revealed: always
reveal_when_assignable_to(T, Sub) # revealed: never
reveal_when_assignable_to(T, Unrelated) # revealed: never
reveal_when_assignable_to(T, Any) # revealed: always
reveal_when_assignable_to(T, Super | Any) # revealed: always
reveal_when_assignable_to(T, Super | Unrelated) # revealed: always
reveal_when_assignable_to(Super, T) # revealed: never
reveal_when_assignable_to(Base, T) # revealed: always
reveal_when_assignable_to(Unrelated, T) # revealed: never
reveal_when_assignable_to(Any, T) # revealed: always
reveal_when_assignable_to(Super | Any, T) # revealed: never
reveal_when_assignable_to(Base | Any, T) # revealed: always
reveal_when_assignable_to(Super | Unrelated, T) # revealed: never
reveal_when_assignable_to(Intersection[Base, Unrelated], T) # revealed: always
reveal_when_assignable_to(Intersection[Base, Any], T) # revealed: always
reveal_when_subtype_of(T, Super) # revealed: never
reveal_when_subtype_of(T, Base) # revealed: never
reveal_when_subtype_of(T, Sub) # revealed: never
reveal_when_subtype_of(T, Unrelated) # revealed: never
reveal_when_subtype_of(T, Any) # revealed: never
reveal_when_subtype_of(T, Super | Any) # revealed: never
reveal_when_subtype_of(T, Super | Unrelated) # revealed: never
reveal_when_subtype_of(Super, T) # revealed: never
reveal_when_subtype_of(Base, T) # revealed: never
reveal_when_subtype_of(Unrelated, T) # revealed: never
reveal_when_subtype_of(Any, T) # revealed: never
reveal_when_subtype_of(Super | Any, T) # revealed: never
reveal_when_subtype_of(Base | Any, T) # revealed: never
reveal_when_subtype_of(Super | Unrelated, T) # revealed: never
reveal_when_subtype_of(Intersection[Base, Unrelated], T) # revealed: never
reveal_when_subtype_of(Intersection[Base, Any], T) # revealed: never
Two distinct fully static typevars are not subtypes of each other, even if they have the same constraints, and even if any of the constraints are final. There must always be at least two distinct constraints, meaning that there is (still) no guarantee that they will be specialized to the same type.
def two_constrained[T: (int, str), U: (int, str)](t: T, u: U) -> None:
reveal_when_assignable_to(T, U) # revealed: never
reveal_when_assignable_to(U, T) # revealed: never
reveal_when_subtype_of(T, U) # revealed: never
reveal_when_subtype_of(U, T) # revealed: never
@final
class AnotherFinalClass: ...
def two_final_constrained[T: (FinalClass, AnotherFinalClass), U: (FinalClass, AnotherFinalClass)](t: T, u: U) -> None:
reveal_when_assignable_to(T, U) # revealed: never
reveal_when_assignable_to(U, T) # revealed: never
reveal_when_subtype_of(T, U) # revealed: never
reveal_when_subtype_of(U, T) # revealed: never
A bound or constrained typevar is a subtype of itself in a union:
def union[T: Base, U: (Base, Unrelated)](t: T, u: U) -> None:
reveal_when_assignable_to(T, T | None) # revealed: always
reveal_when_assignable_to(U, U | None) # revealed: always
reveal_when_subtype_of(T, T | None) # revealed: always
reveal_when_subtype_of(U, U | None) # revealed: always
A bound or constrained typevar in a union with a dynamic type is assignable to the typevar:
def union_with_dynamic[T: Base, U: (Base, Unrelated)](t: T, u: U) -> None:
reveal_when_assignable_to(T | Any, T) # revealed: always
reveal_when_assignable_to(U | Any, U) # revealed: always
reveal_when_subtype_of(T | Any, T) # revealed: never
reveal_when_subtype_of(U | Any, U) # revealed: never
And an intersection of a typevar with another type is always a subtype of the TypeVar:
from ty_extensions import Intersection, Not, is_disjoint_from, static_assert
class A: ...
def inter[T: Base, U: (Base, Unrelated)](t: T, u: U) -> None:
reveal_when_assignable_to(Intersection[T, Unrelated], T) # revealed: always
reveal_when_subtype_of(Intersection[T, Unrelated], T) # revealed: always
reveal_when_assignable_to(Intersection[U, A], U) # revealed: always
reveal_when_subtype_of(Intersection[U, A], U) # revealed: always
static_assert(is_disjoint_from(Not[T], T))
static_assert(is_disjoint_from(T, Not[T]))
static_assert(is_disjoint_from(Not[U], U))
static_assert(is_disjoint_from(U, Not[U]))
Equivalence
A TypeVar is always equivalent to itself, but never to another TypeVar, since there is no
guarantee that they will be specialized to the same type. (This is true even if both typevars are
bounded by the same final class, since you can specialize the typevars to Never in addition to
that final class.)
from typing import final
from ty_extensions import is_equivalent_to, static_assert
@final
class FinalClass: ...
@final
class SecondFinalClass: ...
def f[A, B, C: FinalClass, D: FinalClass, E: (FinalClass, SecondFinalClass), F: (FinalClass, SecondFinalClass)]():
static_assert(is_equivalent_to(A, A))
static_assert(is_equivalent_to(B, B))
static_assert(is_equivalent_to(C, C))
static_assert(is_equivalent_to(D, D))
static_assert(is_equivalent_to(E, E))
static_assert(is_equivalent_to(F, F))
static_assert(not is_equivalent_to(A, B))
static_assert(not is_equivalent_to(C, D))
static_assert(not is_equivalent_to(E, F))
TypeVars which have non-fully-static bounds or constraints are also self-equivalent.
from typing import final, Any
from ty_extensions import is_equivalent_to, static_assert
# fmt: off
def f[
A: tuple[Any],
B: tuple[Any],
C: (tuple[Any], tuple[Any, Any]),
D: (tuple[Any], tuple[Any, Any])
]():
static_assert(is_equivalent_to(A, A))
static_assert(is_equivalent_to(B, B))
static_assert(is_equivalent_to(C, C))
static_assert(is_equivalent_to(D, D))
# fmt: on
Singletons and single-valued types
(Note: for simplicity, all of the prose in this section refers to singleton types, but all of the claims also apply to single-valued types.)
An unbounded, unconstrained typevar is not a singleton, because it can be specialized to a non-singleton type.
from ty_extensions import is_singleton, is_single_valued, static_assert
def unbounded_unconstrained[T](t: T) -> None:
static_assert(not is_singleton(T))
static_assert(not is_single_valued(T))
A bounded typevar is not a singleton, even if its bound is a singleton, since it can still be
specialized to Never.
def bounded[T: None](t: T) -> None:
static_assert(not is_singleton(T))
static_assert(not is_single_valued(T))
A constrained typevar is a singleton if all of its constraints are singletons. (Note that you cannot specialize a constrained typevar to a subtype of a constraint.)
from typing_extensions import Literal
def constrained_non_singletons[T: (int, str)](t: T) -> None:
static_assert(not is_singleton(T))
static_assert(not is_single_valued(T))
def constrained_singletons[T: (Literal[True], Literal[False])](t: T) -> None:
static_assert(is_singleton(T))
def constrained_single_valued[T: (Literal[True], tuple[()])](t: T) -> None:
static_assert(is_single_valued(T))
Unions involving typevars
The union of an unbounded unconstrained typevar with any other type cannot be simplified, since there is no guarantee what type the typevar will be specialized to.
from typing import Any
class Super: ...
class Base(Super): ...
class Sub(Base): ...
class Unrelated: ...
def unbounded_unconstrained[T](t: T) -> None:
def _(x: T | Super) -> None:
reveal_type(x) # revealed: T@unbounded_unconstrained | Super
def _(x: T | Base) -> None:
reveal_type(x) # revealed: T@unbounded_unconstrained | Base
def _(x: T | Sub) -> None:
reveal_type(x) # revealed: T@unbounded_unconstrained | Sub
def _(x: T | Unrelated) -> None:
reveal_type(x) # revealed: T@unbounded_unconstrained | Unrelated
def _(x: T | Any) -> None:
reveal_type(x) # revealed: T@unbounded_unconstrained | Any
The union of a bounded typevar with its bound is that bound. (The typevar is guaranteed to be specialized to a subtype of the bound.) The union of a bounded typevar with a subtype of its bound cannot be simplified. (The typevar might be specialized to a different subtype of the bound.)
def bounded[T: Base](t: T) -> None:
def _(x: T | Super) -> None:
reveal_type(x) # revealed: Super
def _(x: T | Base) -> None:
reveal_type(x) # revealed: Base
def _(x: T | Sub) -> None:
reveal_type(x) # revealed: T@bounded | Sub
def _(x: T | Unrelated) -> None:
reveal_type(x) # revealed: T@bounded | Unrelated
def _(x: T | Any) -> None:
reveal_type(x) # revealed: T@bounded | Any
The union of a constrained typevar with a type depends on how that type relates to the constraints. If all of the constraints are a subtype of that type, the union simplifies to that type. Inversely, if the type is a subtype of every constraint, the union simplifies to the typevar. Otherwise, the union cannot be simplified.
def constrained[T: (Base, Sub)](t: T) -> None:
def _(x: T | Super) -> None:
reveal_type(x) # revealed: Super
def _(x: T | Base) -> None:
reveal_type(x) # revealed: Base
def _(x: T | Sub) -> None:
reveal_type(x) # revealed: T@constrained
def _(x: T | Unrelated) -> None:
reveal_type(x) # revealed: T@constrained | Unrelated
def _(x: T | Any) -> None:
reveal_type(x) # revealed: T@constrained | Any
Intersections involving typevars
The intersection of an unbounded unconstrained typevar with any other type cannot be simplified, since there is no guarantee what type the typevar will be specialized to.
from ty_extensions import Intersection
from typing import Any
class Super: ...
class Base(Super): ...
class Sub(Base): ...
class Unrelated: ...
def unbounded_unconstrained[T](t: T) -> None:
def _(x: Intersection[T, Super]) -> None:
reveal_type(x) # revealed: T@unbounded_unconstrained & Super
def _(x: Intersection[T, Base]) -> None:
reveal_type(x) # revealed: T@unbounded_unconstrained & Base
def _(x: Intersection[T, Sub]) -> None:
reveal_type(x) # revealed: T@unbounded_unconstrained & Sub
def _(x: Intersection[T, Unrelated]) -> None:
reveal_type(x) # revealed: T@unbounded_unconstrained & Unrelated
def _(x: Intersection[T, Any]) -> None:
reveal_type(x) # revealed: T@unbounded_unconstrained & Any
The intersection of a bounded typevar with its bound or a supertype of its bound is the typevar
itself. (The typevar might be specialized to a subtype of the bound.) The intersection of a bounded
typevar with a subtype of its bound cannot be simplified. (The typevar might be specialized to a
different subtype of the bound.) The intersection of a bounded typevar with a type that is disjoint
from its bound is Never.
def bounded[T: Base](t: T) -> None:
def _(x: Intersection[T, Super]) -> None:
reveal_type(x) # revealed: T@bounded
def _(x: Intersection[T, Base]) -> None:
reveal_type(x) # revealed: T@bounded
def _(x: Intersection[T, Sub]) -> None:
reveal_type(x) # revealed: T@bounded & Sub
def _(x: Intersection[T, None]) -> None:
reveal_type(x) # revealed: Never
def _(x: Intersection[T, Any]) -> None:
reveal_type(x) # revealed: T@bounded & Any
Constrained typevars can be modeled using a hypothetical OneOf connector, where the typevar must
be specialized to one of its constraints. The typevar is not the union of those constraints,
since that would allow the typevar to take on values from multiple constraints simultaneously. The
OneOf connector would not be a “type” according to a strict reading of the typing spec, since it
would not represent a single set of runtime objects; it would instead represent a set of sets of
runtime objects. This is one reason we have not actually added this connector to our data model yet.
Nevertheless, describing constrained typevars this way helps explain how we simplify intersections
involving them.
This means that when intersecting a constrained typevar with a type T, constraints that are
supertypes of T can be simplified to T, since intersection distributes over OneOf. Moreover,
constraints that are disjoint from T are no longer valid specializations of the typevar, since
Never is an identity for OneOf. After these simplifications, if only one constraint remains, we
can simplify the intersection as a whole to that constraint.
def constrained[T: (Base, Sub, Unrelated)](t: T) -> None:
def _(x: Intersection[T, Base]) -> None:
# With OneOf this would be OneOf[Base, Sub]
reveal_type(x) # revealed: T@constrained & Base
def _(x: Intersection[T, Unrelated]) -> None:
reveal_type(x) # revealed: Unrelated
def _(x: Intersection[T, Sub]) -> None:
reveal_type(x) # revealed: Sub
def _(x: Intersection[T, None]) -> None:
reveal_type(x) # revealed: Never
def _(x: Intersection[T, Any]) -> None:
reveal_type(x) # revealed: T@constrained & Any
We can simplify the intersection similarly when removing a type from a constrained typevar, since this is modeled internally as an intersection with a negation.
from ty_extensions import Not
def remove_constraint[T: (int, str, bool)](t: T) -> None:
def _(x: Intersection[T, Not[int]]) -> None:
reveal_type(x) # revealed: str
def _(x: Intersection[T, Not[str]]) -> None:
# With OneOf this would be OneOf[int, bool]
reveal_type(x) # revealed: T@remove_constraint & ~str
def _(x: Intersection[T, Not[bool]]) -> None:
reveal_type(x) # revealed: T@remove_constraint & ~bool
def _(x: Intersection[T, Not[int], Not[str]]) -> None:
reveal_type(x) # revealed: Never
def _(x: Intersection[T, Not[None]]) -> None:
reveal_type(x) # revealed: T@remove_constraint
def _(x: Intersection[T, Not[Any]]) -> None:
reveal_type(x) # revealed: T@remove_constraint & Any
The intersection of a typevar with any other type is assignable to (and if fully static, a subtype of) itself.
from ty_extensions import reveal_when_assignable_to, reveal_when_subtype_of, Not
def intersection_is_assignable[T](t: T) -> None:
reveal_when_assignable_to(Intersection[T, None], T) # revealed: always
reveal_when_assignable_to(Intersection[T, Not[None]], T) # revealed: always
reveal_when_subtype_of(Intersection[T, None], T) # revealed: always
reveal_when_subtype_of(Intersection[T, Not[None]], T) # revealed: always
Narrowing
We can use narrowing expressions to eliminate some of the possibilities of a constrained typevar:
class P: ...
class Q: ...
class R: ...
def f[T: (P, Q)](t: T) -> None:
if isinstance(t, P):
reveal_type(t) # revealed: P
p: P = t
else:
reveal_type(t) # revealed: Q & ~P
q: Q = t
if isinstance(t, Q):
reveal_type(t) # revealed: Q
q: Q = t
else:
reveal_type(t) # revealed: P & ~Q
p: P = t
def g[T: (P, Q, R)](t: T) -> None:
if isinstance(t, P):
reveal_type(t) # revealed: P
p: P = t
elif isinstance(t, Q):
reveal_type(t) # revealed: Q & ~P
q: Q = t
else:
reveal_type(t) # revealed: R & ~P & ~Q
r: R = t
if isinstance(t, P):
reveal_type(t) # revealed: P
p: P = t
elif isinstance(t, Q):
reveal_type(t) # revealed: Q & ~P
q: Q = t
elif isinstance(t, R):
reveal_type(t) # revealed: R & ~P & ~Q
r: R = t
else:
reveal_type(t) # revealed: Never
If the constraints are disjoint, simplification does eliminate the redundant negative:
def h[T: (P, None)](t: T) -> None:
if t is None:
reveal_type(t) # revealed: None
p: None = t
else:
reveal_type(t) # revealed: P
p: P = t
Callability
A typevar bound to a Callable type is callable:
from typing import Callable
def bound[T: Callable[[], int]](f: T):
reveal_type(f) # revealed: T@bound
reveal_type(f()) # revealed: int
Same with a constrained typevar, as long as all constraints are callable:
def constrained[T: (Callable[[], int], Callable[[], str])](f: T):
reveal_type(f) # revealed: T@constrained
reveal_type(f()) # revealed: int | str
Meta-type
The meta-type of a typevar is the same as the meta-type of the upper bound, or the union of the meta-types of the constraints:
def normal[T](x: T):
reveal_type(type(x)) # revealed: type
def bound_object[T: object](x: T):
reveal_type(type(x)) # revealed: type
def bound_int[T: int](x: T):
reveal_type(type(x)) # revealed: type[int]
def constrained[T: (int, str)](x: T):
reveal_type(type(x)) # revealed: type[int] | type[str]
Cycles
Bounds and constraints
A typevar's bounds and constraints cannot be generic, cyclic or otherwise:
from typing import Any
# TODO: error
def f[S, T: list[S]](x: S, y: T) -> S | T:
return x or y
# TODO: error
class C[S, T: list[S]]:
x: S
y: T
reveal_type(C[int, list[Any]]().x) # revealed: int
reveal_type(C[int, list[Any]]().y) # revealed: list[Any]
# TODO: error
def g[T: list[T]](x: T) -> T:
return x
# TODO: error
class D[T: list[T]]:
x: T
reveal_type(D[list[Any]]().x) # revealed: list[Any]
# TODO: error
def h[S, T: (list[S], str)](x: S, y: T) -> S | T:
return x or y
# TODO: error
class E[S, T: (list[S], str)]:
x: S
y: T
reveal_type(E[int, str]().x) # revealed: int
reveal_type(E[int, str]().y) # revealed: str
# TODO: error
def i[T: (list[T], str)](x: T) -> T:
return x
# TODO: error
class F[T: (list[T], str)]:
x: T
reveal_type(F[list[Any]]().x) # revealed: list[Any]
However, they are lazily evaluated and can cyclically refer to their own type:
class G[T: list[G]]:
x: T
reveal_type(G[list[G]]().x) # revealed: list[G[Unknown]]
Defaults
Defaults can be generic, but can only refer to earlier typevars:
class C[T, U = T]:
x: T
y: U
reveal_type(C[int, str]().x) # revealed: int
reveal_type(C[int, str]().y) # revealed: str
reveal_type(C[int]().x) # revealed: int
reveal_type(C[int]().y) # revealed: int
# TODO: error
class D[T = T]:
x: T
reveal_type(D().x) # revealed: T@D