api: YAML JSON TOON Database
version: 1.0.0
format: json
dataset:
  id: 21
  slug: typescript-type-system
  title: TypeScript Type System
  description: "TypeScript's static type system: types, interfaces, generics, utility types, and advanced type manipulation."
  summary: The TypeScript type system's main concepts, from primitive types, interfaces and generics to union and intersection types, type guards, utility types, discriminated unions, mapped and conditional types and template literal types, each with a description and example.
  use_when:
    - You need the TypeScript construct for a typing problem and an example.
    - You are reading advanced type definitions in a library.
  caveats:
    - TypeScript's types are erased at runtime; they do not validate data coming from outside.
    - Complex conditional and mapped types can slow the compiler and are hard to read; use them with care.
  related:
    - javascript-es6-features
    - csharp-dotnet-features
    - language-comparison-2026
    - solid-principles
  category: Programming Languages
  category_slug: programming-languages
  tags: typescript,types,static-typing,generics,interfaces
  view_count: 0
  created_at: 1777673262
  updated_at: 1777673262
  entry_count: 12
  fields:
    - section: concepts
      field: name
      type: string
      example: Primitive Types
    - section: concepts
      field: types
      type: array
      example: "[7 items]"
    - section: concepts
      field: description
      type: string
      example: Basic built-in types. TypeScript adds `any`, `u…
    - section: concepts
      field: example
      type: string
      example: "let name: string = \"Alice\"; let age: number = 3…"
    - section: concepts
      field: keyword
      type: string
      example: interface
    - section: concepts
      field: patterns
      type: array
      example: "[4 items]"
    - section: concepts
      field: common
      type: array
      example: "[6 items]"
    - section: concepts
      field: pattern
      type: string
      example: tagged union
data:
  concepts:
    - name: Primitive Types
      types:
        - string
        - number
        - boolean
        - "null"
        - undefined
        - symbol
        - bigint
      description: Basic built-in types. TypeScript adds `any`, `unknown`, `never`, `void`.
      example: "let name: string = \"Alice\"; let age: number = 30; let isActive: boolean = true;"
    - name: Interfaces
      keyword: interface
      description: Define object shape; can be extended and implemented. Structural typing.
      example: "interface User { id: number; name: string; email?: string; }\nconst u: User = { id: 1, name: \"Bob\" };"
    - name: Type Aliases
      keyword: type
      description: Create new named type; can represent primitives, unions, tuples, objects.
      example: "type ID = number | string; type Point = [number, number]; type User = { name: string };"
    - name: Generics
      keyword: <T>
      description: Type variables enable reusable components that work with multiple types.
      example: "function identity<T>(arg: T): T { return arg; }\nlet output = identity<string>(\"hello\");"
    - name: Union Types
      keyword: "|"
      description: Value can be one of several types; use type guards to narrow.
      example: "function format(x: string | number) { if (typeof x === 'string') { ... } else { ... } }"
    - name: Intersection Types
      keyword: "&"
      description: Combine multiple types into one; object must satisfy all constraints.
      example: "type Admin = User & { permissions: string[] };"
    - name: Type Guards
      patterns:
        - typeof
        - instanceof
        - in operator
        - custom type predicate
      description: Narrow types within conditional blocks.
      example: "function isString(x: unknown): x is string { return typeof x === 'string'; }\nif (isString(val)) { val.toUpperCase(); }"
    - name: Utility Types
      common:
        - Partial<T>
        - Required<T>
        - Pick<T,K>
        - Omit<T,K>
        - Record<K,T>
        - ReturnType<T>
      description: Built-in type transformations; avoid manual re-declaration.
      example: "interface Post { title: string; content: string; published: boolean; }\ntype EditPost = Pick<Post, 'title' | 'content'>;"
    - name: Discriminated Unions
      pattern: tagged union
      description: Union of types with common literal field; enables exhaustive type checking in switch.
      example: "type Shape = { kind: 'circle'; radius: number } | { kind: 'square'; side: number };\nfunction area(s: Shape) { switch(s.kind) { case 'circle': return Math.PI * s.radius ** 2; ... } }"
    - name: Mapped Types
      keyword: keyof, in
      description: Create types by mapping over properties of another type.
      example: "type Readonly<T> = { readonly [P in keyof T]: T[P]; }\ntype Optional<T> = { [P in keyof T]?: T[P] };"
    - name: Conditional Types
      keyword: "T extends U ? X : Y"
      description: Types that choose between two types based on a condition.
      example: "type IsString<T> = T extends string ? true : false;\ntype NonNullable<T> = T extends null | undefined ? never : T;"
    - name: Template Literal Types
      keyword: "`${}`"
      description: Build strings from other types; useful for CSS property names, API endpoints.
      example: type EventName = `on${Capitalize<string>}`; // onLoad, onMouseEnter, etc.