Type alias in Python (6)

#python #typealias #generics #type

*Memo:

My post explains type alias (1).
My post explains type alias (2).
My post explains type alias (3).
My post explains type alias (4).
My post explains type alias (5).

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