---
id: wiki-2026-0508-typescript-advanced-type-system
title: TypeScript Advanced Type System
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [TS Advanced Types, TS Type Magic]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [typescript, type-system, generics, conditional-types, mapped-types]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: typescript
  framework: tsc
---

# TypeScript Advanced Type System

## 매 한 줄
> **"매 type 의 first-class 의 program 의 turn"**. TS 의 advanced type system 의 conditional / mapped / template literal / inference 의 combine 의 type-level computation 의 enable, 매 runtime cost zero 의 compile-time guarantee. 매 2026 perspective: TS 5.x 의 const generics, decorator, `using`, satisfies 의 stable — library author 의 toolkit 의 mature.

## 매 핵심

### 매 building block
- **Generic**: `<T>` 의 parametric polymorphism.
- **Conditional**: `T extends U ? X : Y`.
- **Mapped**: `{ [K in keyof T]: ... }`.
- **Template literal**: `` `${string}/${number}` ``.
- **Infer**: conditional 안 의 `infer R` 의 sub-type 의 capture.
- **Variadic tuple**: `[...T, ...U]`.
- **Const generic** (TS 5.0+): `<const T>` 의 literal preserve.

### 매 distributive 동작
- 매 conditional `T extends U` 의 `T` 의 union 의 case 의 each member 의 distribute.
- 매 `[T] extends [U]` 의 wrap 의 distribute prevent.

### 매 응용
1. Library API 의 input 의 output type 의 derive (e.g. zod, drizzle, tRPC).
2. Form schema 의 inference (react-hook-form + zod).
3. Route param 의 string 의 typed object 의 parse.
4. SQL query builder 의 column 의 type-safe.

## 💻 패턴

### Mapped + conditional
```typescript
type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K];
};

type X = DeepReadonly<{ a: { b: number } }>;
// { readonly a: { readonly b: number } }
```

### Template literal route parsing
```typescript
type ExtractParams<T extends string> =
  T extends `${string}:${infer Param}/${infer Rest}`
    ? { [K in Param | keyof ExtractParams<`/${Rest}`>]: string }
    : T extends `${string}:${infer Param}`
      ? { [K in Param]: string }
      : {};

type P = ExtractParams<'/user/:id/post/:postId'>;
// { id: string; postId: string }
```

### Infer return + parameter
```typescript
type ReturnOf<F> = F extends (...args: any) => infer R ? R : never;
type ParamsOf<F> = F extends (...args: infer P) => any ? P : never;

type R = ReturnOf<() => Promise<number>>; // Promise<number>
```

### Variadic tuple zip
```typescript
type Zip<A extends any[], B extends any[]> =
  A extends [infer AH, ...infer AT]
    ? B extends [infer BH, ...infer BT]
      ? [[AH, BH], ...Zip<AT, BT>]
      : []
    : [];

type Z = Zip<[1, 2, 3], ['a', 'b', 'c']>;
// [[1, 'a'], [2, 'b'], [3, 'c']]
```

### Const generic
```typescript
function tuple<const T extends readonly unknown[]>(...items: T): T {
  return items;
}

const t = tuple('a', 1, true); // ['a', 1, true] 의 narrow
```

### Branded type
```typescript
declare const brand: unique symbol;
type Brand<T, B> = T & { [brand]: B };

type UserId = Brand<string, 'UserId'>;
type PostId = Brand<string, 'PostId'>;

const u: UserId = 'abc' as UserId;
const p: PostId = u; // ❌ 매 mix 의 prevent
```

### Discriminated union exhaustive
```typescript
type Shape =
  | { kind: 'circle'; r: number }
  | { kind: 'square'; s: number };

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

### Recursive JSON type
```typescript
type Json = string | number | boolean | null | Json[] | { [k: string]: Json };
```

### Type-safe deep get
```typescript
type Path<T> = T extends object
  ? { [K in keyof T]: K extends string ? K | `${K}.${Path<T[K]> & string}` : never }[keyof T]
  : never;

type PathValue<T, P extends string> =
  P extends `${infer K}.${infer Rest}`
    ? K extends keyof T ? PathValue<T[K], Rest> : never
    : P extends keyof T ? T[P] : never;

declare function get<T, P extends Path<T>>(obj: T, path: P): PathValue<T, P>;
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Public API 의 ergonomic | `satisfies` + generic |
| Internal helper 의 simple | concrete type |
| Library 의 input/output derive | conditional + infer |
| Branded ID | branded type via unique symbol |
| Schema runtime+type | zod / valibot / arktype |
| Type-level math (counter) | recursive tuple length |

**기본값**: 매 first 의 simplest type 의 try, 매 inference 의 break 의 case 의 escalate.

## 🔗 Graph
- 부모: [[TypeScript]] · [[TypeScript 타입 시스템 (TypeScript Type System)|Type System]]
- 변형: [[TypeScript 4.9]]
- 응용: [[TypeScript API Development]] · [[Schema Validation]]
- Adjacent: [[Zod]]

## 🤖 LLM 활용
**언제**: 매 library API 의 author, 매 type-level invariant 의 enforce.
**언제 X**: 매 application code 의 simple business logic — 매 over-engineer.

## ❌ 안티패턴
- **Conditional type 의 5+ deep nest**: 매 IDE 의 hover 의 unreadable — 매 alias 의 break.
- **`any` escape hatch 의 type magic 의 give up**: 매 type safety 의 negate.
- **Distributive 의 unintended**: 매 union 의 mass 의 case 의 `[T] extends [U]` 의 wrap 의 forget.
- **Recursion limit ignore**: 매 50+ depth 의 TS error — 매 tail-recursion 또는 iterative.
- **Branded type 의 runtime check 의 omit**: 매 cast 의 lie — 매 validator 의 pair.

## 🧪 검증 / 중복
- Verified (TS Handbook Advanced Types, TS 5.x release notes).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — conditional, mapped, infer, variadic, const generic |
