Type alias in Python (2)

#python #typealias #generics #type

*Memo:

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

Bound & Constraints:

''' Type statement '''
type TA1[T=float] = None
type TA2[T:float=float] = None                 # Bound 
type TA3[T:(float, str)=float] = None          # Constraints
# type TA4[T:(float, str)=(float, str)] = None # Constraints # Error
''' Type statement '''

''' TypeAliasType '''
# from typing import TypeVar, TypeAliasType

# T1 = TypeVar('T1', default=float)
# T2 = TypeVar('T2', bound=float, default=float)         # Bound
# T3 = TypeVar('T3', (float, str), default=float)        # Constraints
# T4 = TypeVar('T4', (float, str), default=(float, str)) # Constraints # Error

# # Error for mypy
# TA1 = TypeAliasType('TA1', value=T1 | None, type_params=(T1,))
# TA2 = TypeAliasType('TA2', value=T2 | None, type_params=(T2,))
# TA3 = TypeAliasType('TA3', value=T3 | None, type_params=(T3,))
''' TypeAliasType '''

x1: TA1[object] = None  # No error
x2: TA1[complex] = None # No error
x3: TA1[float] = None   # No error
# x3: TA1 = None        # No error
x4: TA1[int] = None     # No error
x5: TA1[bool] = None    # No error
x6: TA1[str] = None     # No error

y1: TA2[object] = None  # Error
y2: TA2[complex] = None # Error
y3: TA2[float] = None   # No error
# y3: TA2 = None        # No error
y4: TA2[int] = None     # No error
y5: TA2[bool] = None    # No error
y6: TA2[str] = None     # Error

z1: TA3[object] = None  # Error
z2: TA3[complex] = None # Error
z3: TA3[float] = None   # No error
# z3: TA3 = None        # No error
z4: TA3[int] = None     # Error
z5: TA3[bool] = None    # Error
z6: TA3[str] = None     # No error

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

''' Type statement '''
type TA1[T=C] = None
type TA2[T:C=C] = None                 # Bound
type TA3[T:(C, str)=C] = None          # Constraints
# type TA4[T:(C, str)=(C, str)] = None # Constraints # Error
''' Type statement '''

''' TypeAliasType '''
# from typing import TypeVar, TypeAliasType

# T1 = TypeVar('T1', default=C)
# T2 = TypeVar('T2', bound=C, default=C)       # Bound
# T3 = TypeVar('T3', C, str, default=C)        # Constraints
# T4 = TypeVar('T4', C, str, default=(C, str)) # Constraints # Error

# # Error for mypy
# TA1 = TypeAliasType('TA1', value=T1 | None, type_params=(T1,))
# TA2 = TypeAliasType('TA2', value=T2 | None, type_params=(T2,))
# TA3 = TypeAliasType('TA3', value=T3 | None, type_params=(T3,))
''' TypeAliasType '''

x1: TA1[A] = None   # No error
x2: TA1[B] = None   # No error
x3: TA1[C] = None   # No error
# x3: TA1 = None    # No error
x4: TA1[D] = None   # No error
x5: TA1[E] = None   # No error
x6: TA1[str] = None # No error

y1: TA2[A] = None   # Error
y2: TA2[B] = None   # Error
y3: TA2[C] = None   # No error
# y3: TA2 = None    # No error
y4: TA2[D] = None   # No error
y5: TA2[E] = None   # No error
y6: TA2[str] = None # Error

z1: TA3[A] = None   # Error
z2: TA3[B] = None   # Error
z3: TA3[C] = None   # No error
# z3: TA3 = None    # No error
z4: TA3[D] = None   # Error
z5: TA3[E] = None   # Error
z6: TA3[str] = None # No error

Variance:

from collections.abc import Callable

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

''' TypeAliasType (TypeVar without `infer_variance`) '''
# from typing import TypeVar, TypeAliasType as TAT

# T = TypeVar('T')

# Error for mypy
# TA1 = TAT('TA1', value=Callable[[], T], type_params=(T,))     # Covariant
# TA2 = TAT('TA2', value=tuple[T, ...], type_params=(T,))       # Covariant
# TA3 = TAT('TA3', value=Callable[[T], None], type_params=(T,)) # Contravariant
# TA4 = TAT('TA4', value=Callable[[T], T], type_params=(T,))    # Invariant
# TA5 = TAT('TA5', value=list[T], type_params=(T,))             # Invariant
''' TypeAliasType (TypeVar without `infer_variance`) '''

''' TypeAliasType (TypeVar with `infer_variance`) '''
# from typing import TypeVar, TypeAliasType as TAT

# T = TypeVar('T', infer_variance=True) # Error for mypy

# # Error for mypy
# TA1 = TAT('TA1', value=Callable[[], T], type_params=(T,))     # Covariant
# TA2 = TAT('TA2', value=tuple[T, ...], type_params=(T,))       # Covariant
# TA3 = TAT('TA3', value=Callable[[T], None], type_params=(T,)) # Contravariant
# TA4 = TAT('TA4', value=Callable[[T], T], type_params=(T,))    # Invariant
# TA5 = TAT('TA5', value=list[T], type_params=(T,))             # Invariant
''' TypeAliasType (TypeVar with `infer_variance`) '''

v1: TA1[float] = lambda: 0.0

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

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

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

v3: TA3[float] = lambda x: None

# Contravariant
a3: TA3[object] = v3  # Error
b3: TA3[complex] = v3 # Error
c3: TA3[float] = v3   # No error
d3: TA3[int] = v3     # No error
e3: TA3[bool] = v3    # No error

v4: TA4[float] = lambda x: 0.0

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

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

# Invariant
a5: TA5[object] = v5  # Error
b5: TA5[complex] = v5 # Error
c5: TA5[float] = v5   # No error
d5: TA5[int] = v5     # Error
e5: TA5[bool] = v5    # Error

from collections.abc import Callable

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

''' TypeAliasType (TypeVar without `infer_variance`) '''
# from typing import TypeVar, TypeAliasType as TAT

# T = TypeVar('T')

# # Error for mypy
# TA1 = TAT('TA1', value=Callable[[], T], type_params=(T,))     # Covariant
# TA2 = TAT('TA2', value=tuple[T, ...], type_params=(T,))       # Covariant
# TA3 = TAT('TA3', value=Callable[[T], None], type_params=(T,)) # Contravariant
# TA4 = TAT('TA4', value=Callable[[T], T], type_params=(T,))    # Invariant
# TA5 = TAT('TA5', value=list[T], type_params=(T,))             # Invariant
''' TypeAliasType (TypeVar without `infer_variance`) '''

''' TypeAliasType (TypeVar with `infer_variance`) '''
# from typing import TypeVar, TypeAliasType as TAT

# T = TypeVar('T', infer_variance=True) # Error for mypy

# # Error for mypy
# TA1 = TAT('TA1', value=Callable[[], T], type_params=(T,))     # Covariant
# TA2 = TAT('TA2', value=tuple[T, ...], type_params=(T,))       # Covariant
# TA3 = TAT('TA3', value=Callable[[T], None], type_params=(T,)) # Contravariant
# TA4 = TAT('TA4', value=Callable[[T], T], type_params=(T,))    # Invariant
# TA5 = TAT('TA5', value=list[T], type_params=(T,))             # Invariant
''' TypeAliasType (TypeVar with `infer_variance`) '''

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

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

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

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

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

v3: TA3[C] = lambda x: None

# Contravariant
a3: TA3[A] = v3 # Error
b3: TA3[B] = v3 # Error
c3: TA3[C] = v3 # No error
d3: TA3[D] = v3 # No error
e3: TA3[E] = v3 # No error

v4: TA4[C] = lambda x: C()

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

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

# Invariant
a5: TA5[A] = v5 # Error
b5: TA5[B] = v5 # Error
c5: TA5[C] = v5 # No error
d5: TA5[D] = v5 # Error
e5: TA5[E] = v5 # Error

DEV Community

Type alias in Python (2)

Bound & Constraints:

Variance:

Top comments (0)