❯ TypeScript Type System

Roughly 20% of a typical loop — and 20% of the mock exam here.

Structural typing and erasure

TypeScript compares types by structure, not by name: a value is assignable when it has the required members, whatever it was called or where it was declared. That is why a plain object literal satisfies an interface with no implements clause, and why nominal behavior has to be faked with a brand — type UserId = string & { readonly __brand: unique symbol } — plus a checked factory that produces it.

Everything type-level is erased. No interface, annotation or readonly modifier exists at runtime, so validating external data needs a real check: a hand-written guard or a schema library. An as assertion does nothing at runtime at all; it only silences the checker, which is how bad data reaches production. When the compiler refuses a direct assertion, as unknown as T is the escape hatch and the smell.

any switches checking off for that value. unknown is its safe twin: assignable from everything, assignable to nothing until narrowed. It is the right type for parsed JSON, and it is what catch (e) gives you under current defaults, because JavaScript can throw any value.

Narrowing is the daily work

The checker follows control flow. typeof x === 'number', Array.isArray(x), 'kind' in x, x instanceof Error and a truthiness check all narrow, and so does comparing a literal-typed discriminant:

type Shape = { kind: 'circle'; r: number } | { kind: 'square'; side: number };
function area(s: Shape) {
  switch (s.kind) {
    case 'circle': return Math.PI * s.r ** 2;
    case 'square': return s.side ** 2;
    default: { const _exhaustive: never = s; return _exhaustive; }
  }
}

The discriminant must be a literal type — kind: string narrows nothing. The never assignment in default is the exhaustiveness check: add a variant and every switch that forgot it fails to compile.

A user-defined type predicate — function isUser(x: unknown): x is User — extends narrowing to your own checks, but the compiler trusts it without verifying the body, so a sloppy implementation is a silent hole. Since 5.5 many predicates are inferred from a straightforward function body.

Narrowing has a known blind spot: it does not reach through an unresolved generic parameter. If props: T where T extends Shape, testing props.kind narrows nothing useful — accept the union directly, or destructure into a concrete local.

Generics, constraints and inference

Constrain a parameter to what the body actually uses: function first<T extends { length: number }>(x: T). Annotating the parameter as the constraint instead would throw away the caller’s more specific type, which defeats the point of the generic.

keyof T gives the union of keys and T[K] reads a member type; together they type a generic accessor whose return type stays exact per call site. In a type position, typeof value reuses an inferred type, which pairs with as const to derive unions from data — type Mode = (typeof MODES)[number].

as const freezes inference to literal types. satisfies verifies a value against a type while each property keeps its own inferred type instead of the declared one — so with satisfies Record<Colors, string | RGB>, palette.green.toUpperCase() compiles where the annotated version gives you string | RGB. It does not preserve literals on its own; as const satisfies T is the combination that does both. Since 5.0, a const type parameter moves the as const burden from every call site into the library signature.

The utility types worth naming

Partial and Required add or remove ?; both are shallow. Pick and Omit keep or drop listed keys — and Omit does not constrain its keys to keyof T, so a typo silently removes nothing, which is how types go stale after a rename. Record<K, V> builds a lookup, and with a literal union key every member is required. ReturnType, Parameters and Awaited read a function’s shape; Awaited<ReturnType<typeof fetchUser>> is the async payload idiom.

Underneath, these are mapped and conditional types. Mapped types can add or strip modifiers — { -readonly [K in keyof T]-?: T[K] } makes everything writable and required — and infer captures a type from a matched position. A conditional type distributes over unions unless both sides are wrapped in tuples: [T] extends [U] tests the union as one unit.

Two more that show up in senior screens: strictFunctionTypes checks function-property parameters contravariantly but leaves method-syntax parameters bivariant for compatibility, and import type guarantees erasure so a single-file transpiler never emits a module import purely for a type.