What does a type alias like `Vector = list[float]` change at runtime and for a type checker?

### The assignment is just an assignment `Vector = list[float]` runs at import time like any other statement. `list[float]` builds a `types.GenericAlias` object, and the name `Vector` is bound to it. There is no new class, no registration with the interpreter, and no runtime checking of what a function actually receives. You can prove it in a REPL: `Vector == list[float]` is `True`, and `Vector([1, 2])` builds a perfectly ordinary `list` -- the annotation says `float`, but nothing enforces it. That is worth stating plainly because it is the most common junior misconception: annotations and aliases are documentation that a *separate* tool reads. The interpreter stores them and moves on. ### What "transparent" means to a checker A checker expands the alias wherever it appears. Given `Vector = list[float]`, these two signatures are indistinguishable to it: ```python def scale(v: Vector, k: float) -> Vector: ... def scale(v: list[float], k: float) -> list[float]: ... ``` So a caller may pass any `list[float]` and a function may return any `list[float]`. There is no "a Vector is not a list" error to be had, because the alias is not a type -- it is a spelling. This is exactly why aliases are cheap and safe to introduce: adding one can never make previously valid code fail to check. The payoff is readability at the point of use. A signature reading `dict[str, list[tuple[str, int | None]]]` in four places is a maintenance hazard; naming it once and using the name is the same type with a much better label, and changing the underlying shape is then a one-line edit. ### Declaring an alias unambiguously A bare assignment is ambiguous. Does `X = int` mean "X is an alias for int" or "X is a module-level variable whose value happens to be the `int` class"? Checkers use heuristics, and the heuristics occasionally guess wrong -- especially for aliases whose right-hand side is a plain class name, or which are assigned inside a function or conditional branch. Two spellings remove the doubt: * `Vector: TypeAlias = list[float]` -- the `typing.TypeAlias` marker, added in **Python 3.10** (PEP 613). It is a promise to the checker, and the annotation itself does nothing at runtime. * `type Vector = list[float]` -- the `type` statement, added in **Python 3.12** (PEP 695). This is now the preferred spelling for new code; it also makes the right-hand side lazily evaluated, which matters for forward references. Its runtime object and mechanics are a topic of their own. Code that must run on 3.10 or 3.11 uses the `TypeAlias` marker; code pinned to 3.12+ uses the statement. Both still describe a transparent alias. ### Aliases can be nested and parameterised Aliases compose: `Matrix = list[Vector]` is `list[list[float]]`. They can also carry type parameters. In the pre-3.12 spelling that means writing the alias in terms of a `typing.TypeVar` and subscripting the alias at the point of use: ```python from typing import TypeAlias, TypeVar T = TypeVar("T") Pair: TypeAlias = tuple[T, T] def first(p: Pair[int]) -> int: return p[0] ``` `Pair[int]` evaluates to `tuple[int, int]`, again at runtime, again with no checking. ### Where an alias is the wrong tool Three neighbours are routinely confused with it, and being able to say which you want is the real interview signal: * You want a name the checker keeps **distinct** from its base type, so an ordinary `int` cannot be passed where a user id is expected: that is `typing.NewType`, not an alias. * You want to attach **metadata** to a type for some runtime tool to read: that is `typing.Annotated`, which is still the same type to the checker but carries extra objects. * You want to describe a **dictionary with known keys**: a `TypedDict` describes the keys; `dict[str, str]` (aliased or not) describes only "string keys, string values". A final practical note: because the alias is evaluated eagerly, its right-hand side must already be importable at that point in the module. Names that are not yet defined -- including the alias itself, for a recursive shape -- need a string forward reference or the lazily-evaluated 3.12 statement form.