*Memo:
<ParamSpec (base)>:
from collections.abc import Callable
''' Type statement '''
type TA1[**P1, **P2=[None]] = Callable[P1, Callable[P2, None]]
''' Type statement '''
''' TypeAliasType '''
# from typing import ParamSpec, TypeAliasType
# P1 = ParamSpec('P1')
# P2 = ParamSpec('P2', default=[None])
# TA1 = TypeAliasType('TA1', value=Callable[P1, Callable[P2, None]],
# type_params=(P1, P2)) # Error for mypy
''' TypeAliasType '''
''' Assignment statement '''
# TA1[**P1, **P2=[None]] = Callable[P1, Callable[P2, None]] # Error
''' Assignment statement '''
''' TypeAlias '''
# from typing import ParamSpec, TypeAlias
# P1 = ParamSpec('P1')
# P2 = ParamSpec('P2', default=[None])
# TA1: TypeAlias = Callable[P1, Callable[P2, None]]
''' TypeAlias '''
lam = lambda x, y: lambda z: None
v1_1: TA1[[int, str]] = lam
# v1_1: TA1[[int, str], [None]] = lam
# v1_1: TA1[[], []] = lam # Error
# v1_1: TA1[] = lam # Error
# v1_1: TA1[int] = lam # Error
# v1_1: TA1[int, str] = lam # Error
# v1_1: TA1[int, str, None] = lam # Error
v1_1(100, 'A')(None) # No error
v1_1(None, 100)('A') # Error
v1_1('A', None)(100) # Error
v1_2: TA1[[None, int], [str]] = lam
v1_2(100, 'A')(None) # Error
v1_2(None, 100)('A') # No error
v1_2('A', None)(100) # Error
v1_3: TA1[[str, None], [int]] = lam
v1_3(100, 'A')(None) # Error
v1_3(None, 100)('A') # Error
v1_3('A', None)(100) # No error
v1_4: TA1[..., ...] = lam
v1_4(100, 'A')(None) # No error
v1_4(None, 100)('A') # No error
v1_4('A', None)(100) # No error
type TA2[**P1=..., **P2=...] = TA1[P1, P2]
v2_1: TA2 = lam
# v2_1: TA2[..., ...] = lam
# v2_1: TA2[] = lam # Error
v2_1(100, 'A')(None) # No error
v2_1(None, 100)('A') # No error
v2_1('A', None)(100) # No error
v2_2: TA2[[int, str], [None]] = lam
v2_2(100, 'A')(None) # No error
v2_2(None, 100)('A') # Error
v2_2('A', None)(100) # Error
v2_3: TA2[[None, int], [str]] = lam
v2_3(100, 'A')(None) # Error
v2_3(None, 100)('A') # No error
v2_3('A', None)(100) # Error
v2_4: TA2[[str, None], [int]] = lam
v2_4(100, 'A')(None) # Error
v2_4(None, 100)('A') # Error
v2_4('A', None)(100) # No error
# For the new syntax, Python interpreter and type checkers
# don't support `bound`, `covariant` and `contravariant`.
type TA[**P:[float, str]] = Callable[P, None] # Error
# For the old syntax, type checkers don't support
# `bound`, `covariant` and `contravariant`.
from typing import ParamSpec
P1 = ParamSpec('P1', bound=[float, str]) # Error
P2 = ParamSpec('P2', covariant=True) # Error
P3 = ParamSpec('P3', contravariant=True) # Error
# Run without `--strict`
# No type arguments make the type parameters without default types `Any`.
from collections.abc import Callable
from typing import reveal_type
type TA[**P] = Callable[P, None]
v: TA = lambda x, y, z: print(x, y, z)
reveal_type(v)
# def (*Any, **Any)
Variance:
from collections.abc import Callable
''' Type statement '''
type TA1[**P] = Callable[[], Callable[P, None]] # Covariant
type TA2[**P] = tuple[Callable[P, None], ...] # Covariant
type TA3[**P] = Callable[P, None] # Covariant
type TA4[**P] = Callable[P, Callable[P, None]] # Covariant
type TA5[**P] = list[Callable[P, None]] # Invariant
''' Type statement '''
''' TypeAliasType '''
# from typing import ParamSpec, TypeAliasType
# P = ParamSpec('P')
# Error for mypy
# TA1 = TypeAliasType('TA1', value=Callable[[], Callable[P, None]],
# type_params=(P,)) # Covariant
# TA2 = TypeAliasType('TA2', value=tuple[Callable[P, None], ...],
# type_params=(P,)) # Covariant
# TA3 = TypeAliasType('TA3', value=Callable[P, None],
# type_params=(P,)) # Contravariant
# TA4 = TypeAliasType('TA4', value=Callable[P, Callable[P, None]],
# type_params=(P,)) # Invariant
# TA5 = TypeAliasType('TA5', value=list[Callable[P, None]],
# type_params=(P,)) # Invariant
''' TypeAliasType '''
lam = lambda x, y: None
v1: TA1[float, float] = lambda: lam
# Covariant
a1: TA1[object, object] = v1 # Error
b1: TA1[complex, complex] = v1 # Error
c1: TA1[float, float] = v1 # No error
d1: TA1[int, int] = v1 # No error
e1: TA1[bool, bool] = v1 # No error
v2: TA2[float, float] = (lam, lam)
# Covariant
a2: TA2[object, object] = v2 # Error
b2: TA2[complex, complex] = v2 # Error
c2: TA2[float, float] = v2 # No error
d2: TA2[int, int] = v2 # No error
e2: TA2[bool, bool] = v2 # No error
v3: TA3[float, float] = lambda x, y: None
# Covariant
a3: TA3[object, object] = v3 # Error
b3: TA3[complex, complex] = v3 # Error
c3: TA3[float, float] = v3 # No error
d3: TA3[int, int] = v3 # No error
e3: TA3[bool, bool] = v3 # No error
v4: TA4[float, float] = lambda x, y: lam
# Covariant
a4: TA4[object, object] = v4 # Error
b4: TA4[complex, complex] = v4 # Error
c4: TA4[float, float] = v4 # No error
d4: TA4[int, int] = v4 # No error
e4: TA4[bool, bool] = v4 # No error
v5: TA5[float, float] = [lam, lam]
# Invariant
a5: TA5[object, object] = v5 # Error
b5: TA5[complex, complex] = v5 # Error
c5: TA5[float, float] = v5 # No error
d5: TA5[int, int] = v5 # Error
e5: TA5[bool, bool] = v5 # Error
from collections.abc import Callable
''' Type statement '''
type TA1[**P] = Callable[[], Callable[P, None]] # Covariant
type TA2[**P] = tuple[Callable[P, None], ...] # Covariant
type TA3[**P] = Callable[P, None] # Covariant
type TA4[**P] = Callable[P, Callable[P, None]] # Covariant
type TA5[**P] = list[Callable[P, None]] # Invariant
''' Type statement '''
''' TypeAliasType '''
# from typing import ParamSpec, TypeAliasType
# P = ParamSpec('P')
# Error for mypy
# TA1 = TypeAliasType('TA1', value=Callable[[], Callable[P, None]],
# type_params=(P,)) # Covariant
# TA2 = TypeAliasType('TA2', value=tuple[Callable[P, None], ...],
# type_params=(P,)) # Covariant
# TA3 = TypeAliasType('TA3', value=Callable[P, None],
# type_params=(P,)) # Contravariant
# TA4 = TypeAliasType('TA4', value=Callable[P, Callable[P, None]],
# type_params=(P,)) # Invariant
# TA5 = TypeAliasType('TA5', value=list[Callable[P, None]],
# type_params=(P,)) # Invariant
''' TypeAliasType '''
class A: ...
class B(A): ...
class C(B): ...
class D(C): ...
class E(D): ...
lam = lambda x, y: None
v1: TA1[C, C] = lambda: lam
# Covariant
a1: TA1[A, A] = v1 # Error
b1: TA1[B, B] = v1 # Error
c1: TA1[C, C] = v1 # No error
d1: TA1[D, D] = v1 # No error
e1: TA1[E, E] = v1 # No error
v2: TA2[C, C] = (lam, lam)
# Covariant
a2: TA2[A, A] = v2 # Error
b2: TA2[B, B] = v2 # Error
c2: TA2[C, C] = v2 # No error
d2: TA2[D, D] = v2 # No error
e2: TA2[E, E] = v2 # No error
v3: TA3[C, C] = lambda x, y: None
# Covariant
a3: TA3[A, A] = v3 # Error
b3: TA3[B, B] = v3 # Error
c3: TA3[C, C] = v3 # No error
d3: TA3[D, D] = v3 # No error
e3: TA3[E, E] = v3 # No error
v4: TA4[C, C] = lambda x, y: lam
# Covariant
a4: TA4[A, A] = v4 # Error
b4: TA4[B, B] = v4 # Error
c4: TA4[C, C] = v4 # No error
d4: TA4[D, D] = v4 # No error
e4: TA4[E, E] = v4 # No error
v5: TA5[C, C] = [lam, lam]
# Invariant
a5: TA5[A, A] = v5 # Error
b5: TA5[B, B] = v5 # Error
c5: TA5[C, C] = v5 # No error
d5: TA5[D, D] = v5 # Error
e5: TA5[E, E] = v5 # Error
<TypeVar, TypeVarTuple & ParamSpec (base)>:
from collections.abc import Callable
''' Type statement '''
type TA[**P, *Ts, T] = Callable[P, Callable[[*Ts, T], None]]
''' Type statement '''
''' TypeAliasType '''
# from typing import ParamSpec, TypeAliasType, TypeVar, TypeVarTuple, Unpack
# P = ParamSpec('P')
# Ts = TypeVarTuple('Ts')
# T = TypeVar('T')
# TA = TypeAliasType('TA', value=Callable[P, Callable[[Unpack[Ts], T], None]],
# type_params=(P, Ts, T)) # Error for mypy
''' TypeAliasType '''
''' Assignment statement '''
# TA[**P, *Ts, T] = Callable[P, Callable[[*Ts, T], None]] # Error
''' Assignment statement '''
''' TypeAlias '''
# from typing import (ParamSpec, TypeAlias, TypeAliasType,
# TypeVar, TypeVarTuple, Unpack)
# P = ParamSpec('P')
# Ts = TypeVarTuple('Ts')
# T = TypeVar('T')
# TA: TypeAlias = Callable[P, Callable[[Unpack[Ts], T], None]]
''' TypeAlias '''
v: TA[[int, str], *tuple[int, str], int] = lambda w, x: lambda *y, z: None
Top comments (0)