Typescript Type Level Programming Recursive Conditional Tuple Permutation

Definisi

Type-level programming = menulis logika di dalam sistem tipe (bukan runtime) pakai conditional types, infer, dan recursion lewat union/tuple. Contoh: Permutation<T>, DeepReadonly<T>, Join<T, D>.

Kapan dipakai

Pakai saat ingin constraint compile-time kuat tanpa runtime cost: route param types, schema-derived types, DSL tipe. Hindari kalau cuma butuh runtime sederhana — type-level berat sulit dibaca.

Cara kerja

DeepReadonly

ts

type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K];
};

Join tuple

ts

type Join<T extends unknown[], D extends string> =
  T extends [infer F, ...infer R]
    ? R['length'] extends 0
      ? `${F & string}`
      : `${F & string}${D}${Join<R, D>}`
    : '';
 
type P = Join<['a','b','c'], '/'>; // 'a/b/c'

Permutation (simplified)

ts

type Permutation<T, K = T> =
  [K] extends [never] ? [] :
  K extends K ? [K, ...Permutation<Exclude<T, K>>] : never;

Struktur alur

Catatan implementasi

• Recursion di tipe dibatasi compiler (~50 kedalaman); jangan terlalu dalam.
• Tuple ([infer F, ...infer R]) cara utama iterasi di level tipe.
• Exclude<T, K> untuk hapus elemen sudah dipakai (buat permutation).
• Uji dengan type Test = Expect<Equal<...>> (vitest/type-challenges) bila rumit.

Kesalahan umum

• Recursion terlalu dalam: error "Type instantiation is excessively deep".
• Distributive conditional tak disengaja: bungkus [K] extends [never] untuk non-distributive.
• infer salah posisi: hasil tak sesuai; cek urutan generic.
• Over-engineering: tipe sulit dimengerti tim; dokumentasikan.

Referensi terkait

• TypeScript infer Deep Dive, Conditional Types Pivot
• TypeScript Generics Constraints, Default, Conditional Return
• Advanced Types: Unions, Mapped, Conditional, infer