TypeScript Type System Mastery

Key Principles

• Enable all strict mode flags:

  strict

  ,

  noUncheckedIndexedAccess

  ,

  exactOptionalPropertyTypes

  in tsconfig.json
• Prefer type inference where it produces readable types; add explicit annotations at module boundaries and public APIs
• Use discriminated unions over type assertions; the compiler should narrow types through control flow, not developer promises
• Design generic functions with the fewest constraints that still ensure type safety
• Treat

  any

  as a code smell; use

  unknown

  for truly unknown values and narrow with type guards

Techniques

• Build generic constraints with

  extends

  :

  function merge<T extends object, U extends object>(a: T, b: U): T & U

• Create mapped types for transformations:

  type Readonly<T> = { readonly [K in keyof T]: T[K] }

• Apply conditional types for branching:

  type IsArray<T> = T extends any[] ? true : false

• Use utility types effectively:

  Partial<T>

  for optional fields,

  Required<T>

  for mandatory,

  Pick<T, K>

  and

  Omit<T, K>

  for subsetting,

  Record<K, V>

  for dictionaries
• Define discriminated unions with a literal

  type

  field:

  type Event = { type: "click"; x: number } | { type: "keydown"; key: string }

• Write type guard functions:

  function isString(val: unknown): val is string { return typeof val === "string"; }

Common Patterns

• Branded Types: Create nominal types with

  type UserId = string & { readonly __brand: unique symbol }

  and a constructor function to prevent mixing semantically different strings
• Builder with Generics: Track which fields have been set at the type level so that

  build()

  is only callable when all required fields are present
• Exhaustive Switch: Use

  default: assertNever(x)

  with

  function assertNever(x: never): never

  to get compile errors when a union variant is not handled
• Template Literal Types: Define route patterns like

  type Route = '/users/${string}/posts/${number}'

  for type-safe URL construction and parsing

Pitfalls to Avoid

• Do not use

  as

  type assertions to silence errors; if the types do not match, fix the data flow rather than casting
• Do not over-engineer generic types that require PhD-level type theory to understand; readability matters more than cleverness
• Do not use

  enum

  for string constants; prefer

  as const

  objects or union literal types which have better tree-shaking and type inference
• Do not rely on

  Object.keys()

  returning

  (keyof T)[]

  ; TypeScript intentionally types it as

  string[]

  because objects can have extra properties at runtime