Type alias in Python (4)

Buy Me a Coffee☕

*Memo:

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

Variance:

from collections.abc import Callable

''' Type statement '''
type TA1[*Ts] = Callable[[], tuple[*Ts]]    # Covariant
type TA2[*Ts] = tuple[*Ts]                  # Covariant
type TA3[*Ts] = Callable[[*Ts], None]       # Contravariant
type TA4[*Ts] = Callable[[*Ts], tuple[*Ts]] # Invariant
type TA5[*Ts] = list[tuple[*Ts]]            # Invariant
''' Type statement '''

''' TypeAliasType '''
# from typing import TypeAliasType, TypeVarTuple, Unpack

# Ts = TypeVarTuple('Ts')

# Error for mypy
# TA1 = TypeAliasType('TA1', value=Callable[[], tuple[Unpack[Ts]]],
#                     type_params=(Ts,)) # Covariant
# TA2 = TypeAliasType('TA2', value=tuple[Unpack[Ts]],
#                     type_params=(Ts,)) # Covariant
# TA3 = TypeAliasType('TA3', value=Callable[[Unpack[Ts]], None],
#                     type_params=(Ts,)) # Contravariant
# TA4 = TypeAliasType('TA4', value=Callable[[*Ts], tuple[Unpack[Ts]]],
#                     type_params=(Ts,)) # Invariant
# TA5 = TypeAliasType('TA5', value=list[tuple[Unpack[Ts]]],
#                     type_params=(Ts,)) # Invariant
''' TypeAliasType '''

v1: TA1[float, float] = lambda: (3.14, 2.72)

# Covariant
a1: TA1[object, object] = v1   # No error
b1: TA1[complex, complex] = v1 # No error
c1: TA1[float, float] = v1     # No error
d1: TA1[int, int] = v1         # Error
e1: TA1[bool, bool] = v1       # Error

v2: TA2[float, float] = (3.14, 2.72)

# Covariant
a2: TA2[object, object] = v2   # No error
b2: TA2[complex, complex] = v2 # No error
c2: TA2[float, float] = v2     # No error
d2: TA2[int, int] = v2         # Error
e2: TA2[bool, bool] = v2       # Error

v3: TA3[float, float] = lambda x, y: None

# Contravariant
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: (3.14, 2.72)

# Invariant
a4: TA4[object, object] = v4   # Error
b4: TA4[complex, complex] = v4 # Error
c4: TA4[float, float] = v4     # No error
d4: TA4[int, int] = v4         # Error
e4: TA4[bool, bool] = v4       # Error

v5: TA5[float, float] = [(3.14, 2.72)]

# 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[*Ts] = Callable[[], tuple[*Ts]]    # Covariant
type TA2[*Ts] = tuple[*Ts]                  # Covariant
type TA3[*Ts] = Callable[[*Ts], None]       # Contravariant
type TA4[*Ts] = Callable[[*Ts], tuple[*Ts]] # Invariant
type TA5[*Ts] = list[tuple[*Ts]]            # Invariant
''' Type statement '''

''' TypeAliasType '''
# from typing import TypeAliasType, TypeVarTuple, Unpack

# Ts = TypeVarTuple('Ts')

# Error for mypy
# TA1 = TypeAliasType('TA1', value=Callable[[], tuple[Unpack[Ts]]],
#                     type_params=(Ts,)) # Covariant
# TA2 = TypeAliasType('TA2', value=tuple[Unpack[Ts]],
#                     type_params=(Ts,)) # Covariant
# TA3 = TypeAliasType('TA3', value=Callable[[Unpack[Ts]], None],
#                     type_params=(Ts,)) # Contravariant
# TA4 = TypeAliasType('TA4', value=Callable[[*Ts], tuple[Unpack[Ts]]],
#                     type_params=(Ts,)) # Invariant
# TA5 = TypeAliasType('TA5', value=list[tuple[Unpack[Ts]]],
#                     type_params=(Ts,)) # Invariant
''' TypeAliasType '''

class A: ...
class B(A): ...
class C(B): ...
class D(C): ...
class E(D): ...

v1: TA1[C, C] = lambda: (C(), C())

# Covariant
a1: TA1[A, A] = v1 # No error
b1: TA1[B, B] = v1 # No error
c1: TA1[C, C] = v1 # No error
d1: TA1[D, D] = v1 # Error
e1: TA1[E, E] = v1 # Error

v2: TA2[C, C] = (C(), C())

# Covariant
a2: TA2[A, A] = v2 # No error
b2: TA2[B, B] = v2 # No error
c2: TA2[C, C] = v2 # No error
d2: TA2[D, D] = v2 # Error
e2: TA2[E, E] = v2 # Error

v3: TA3[C, C] = lambda x, y: None

# Contravariant
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: (C(), C())

# Invariant
a4: TA4[A, A] = v4 # Error
b4: TA4[B, B] = v4 # Error
c4: TA4[C, C] = v4 # No error
d4: TA4[D, D] = v4 # Error
e4: TA4[E, E] = v4 # Error

v5: TA5[C, C] = [(C(), C())]

# 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