TypeScript Advanced Patterns: Type-Level Programming

Beyond Basic Types

Most TypeScript usage stays at the surface: annotating function parameters, defining interfaces, maybe an occasional generic. But TypeScript's type system is far more powerful - it is essentially a functional programming language that runs at compile time.

Mastering advanced patterns lets you encode invariants in the type system, catch entire categories of bugs at compile time, and create APIs that guide users toward correct usage.

Generics: The Foundation

Generics let you write code that works with any type while preserving type information. The key insight: generics capture and propagate types through your code.

Basic generics accept any type. Constrained generics restrict to types with certain properties. The extends keyword defines these constraints - you can require that a type has specific keys, extends a base type, or satisfies other conditions.

Multiple type parameters let you relate types to each other. A function that takes an object and a key can return the type of that specific property, not just "any property type."

Conditional Types: Type-Level Logic

Conditional types enable branching logic in the type system. The syntax mirrors JavaScript's ternary operator: T extends U ? X : Y.

Combined with infer, conditional types can extract types from other types. Want the return type of a function? The element type of an array? The resolved type of a promise? Conditional types with infer make this possible.

Distributive conditional types automatically map over union types. This enables powerful transformations: filtering unions, transforming each member, or extracting specific variants.

Template Literal Types

Template literal types bring string manipulation to the type system. Combine literal types with template syntax to create derived string types.

This shines for API design: event handler names derived from event types, route parameters extracted from path patterns, CSS property types generated from a design system. The compiler enforces string patterns that would otherwise require runtime validation.

Mapped Types: Transforming Shapes

Mapped types iterate over keys to create new types. The built-in utility types (Partial, Required, Readonly, Pick, Omit) are all mapped types.

Custom mapped types can add or remove modifiers, transform key names, and compute value types. Combined with template literals, you can systematically rename properties or derive new shapes from existing ones.

Type Guards and Narrowing

TypeScript narrows types based on control flow. Type guards tell the compiler how to narrow.

Built-in narrowing works with typeof, instanceof, and truthiness checks. Custom type predicates (functions returning "x is Type") handle complex narrowing logic. Assertion functions narrow types as a side effect.

The goal: write code where impossible states are unrepresentable. If a value can only be certain types in certain contexts, encode that in the type system.

Practical Patterns

Branded types: Add phantom types to primitives to prevent mixing incompatible values (UserId vs OrderId, both strings).

Builder pattern with types: Chain methods that progressively narrow the type, ensuring required fields are set before build() is callable.

Exhaustiveness checking: Use never to ensure switch statements handle all union variants.

Discriminated unions: Tag unions with literal types for type-safe pattern matching.

Best Practices

Infer over annotate: Let TypeScript figure out types when possible

Narrow progressively: Use type guards to refine types through code paths

Encode constraints: Make invalid states unrepresentable

Use utility types: Build on Partial, Pick, Omit, and friends

Template literals for strings: Type-safe string patterns

Keep it readable: Complex types need documentation