Tipe never di TypeScript: Exhaustive Check dan never vs void

never adalah tipe tanpa nilai. Fungsi dengan tipe kembalian never tidak pernah selesai secara normal: ia melempar error atau berjalan selamanya. Variabel bertipe never menandai kode yang tidak mungkin berjalan, dan itulah yang membuat exhaustive check bisa dilakukan.

function fail(message: string): never {
  throw new Error(message);
}

function parsePort(text: string): number {
  const n = Number(text);
  if (Number.isInteger(n) && n > 0 && n < 65536) return n;
  return fail(`invalid port: ${text}`); // never is assignable to number
}

console.log(parsePort("8080")); // 8080

try {
  parsePort("http");
} catch (e) {
  console.log((e as Error).message); // invalid port: http
}

return fail(...) lolos kompilasi di fungsi yang mengembalikan number karena never bisa di-assign ke setiap tipe: nilai bertipe never tidak akan pernah benar-benar sampai.

Fungsi yang Tidak Pernah Selesai

Ada dua jenis fungsi yang tidak pernah mencapai akhirnya: yang selalu melempar error, dan yang punya perulangan tanpa akhir. Compiler memeriksa klaim ini. Fungsi yang dianotasi never tetapi akhirnya bisa dijangkau adalah error TS2534, A function returning 'never' cannot have a reachable end point.

function fail(message: string): never {
  throw new Error(message);
}

function runForever(): never {
  while (true) {
    // poll, serve requests...
  }
}

Inferensinya berbeda tergantung sintaks. Deklarasi fungsi yang hanya melempar error disimpulkan mengembalikan void, sedangkan arrow function atau function expression yang hanya melempar error disimpulkan sebagai never:

function f1() { throw new Error("x"); }       // () => void
const f2 = () => { throw new Error("x"); };   // () => never

Narrowing hanya memperlakukan sebuah pemanggilan sebagai jalan buntu kalau nama yang dipanggil punya tipe eksplisit yang mengembalikan never: deklarasi fungsi yang dianotasi : never, seperti fail di atas, atau variabel dengan anotasi tipe, const fail: (m: string) => never = (m) => { throw new Error(m); }. never hasil inferensi tidak dihitung, begitu juga const fail = (m: string): never => ..., yang hanya arrow function-nya yang dianotasi, bukan variabelnya.

never vs void

Perbedaan praktisnya terlihat saat narrowing. Setelah if (!user) fail("no user"), compiler tahu user sudah terdefinisi di baris berikutnya hanya kalau fail mengembalikan never. Dengan tipe kembalian void, compiler menganggap eksekusi bisa berlanjut.

Exhaustive Check dengan never

Setiap case dari switch atas sebuah union mempersempit tipe nilainya. Setelah setiap member ditangani, yang tersisa di default adalah never. Meng-assign-nya ke variabel never mengubah "aku sudah menangani semua kasus" menjadi sesuatu yang diverifikasi compiler:

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "square":
      return shape.side ** 2;
    default: {
      const unhandled: never = shape; // shape is never here
      throw new Error(`unknown shape: ${JSON.stringify(unhandled)}`);
    }
  }
}

console.log(area({ kind: "square", side: 3 })); // 9
console.log(area({ kind: "circle", radius: 1 }).toFixed(4)); // 3.1416

Sekarang tambahkan member ketiga ke union tanpa menambahkan case-nya:

// This does not compile: "triangle" is not handled
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number }
  | { kind: "triangle"; base: number; height: number };

function assertNever(value: never): never {
  throw new Error(`Unhandled value: ${JSON.stringify(value)}`);
}

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "square":
      return shape.side ** 2;
    default:
      return assertNever(shape);
  }
}

console.log(area({ kind: "square", side: 3 }));

index.ts(18,26): error TS2345: Argument of type '{ kind: "triangle"; base: number; height: number; }' is not assignable to parameter of type 'never'.

Error-nya menyebut member yang kamu lupakan. Tambahkan case "triangle": return (shape.base * shape.height) / 2; dan kodenya lolos kompilasi lagi. Helper assertNever adalah bentuk pemeriksaan yang sama yang bisa dipakai ulang, dan throw-nya tetap penting saat runtime: data dari JSON atau client versi lama bisa saja berisi kind yang menurut tipenya mustahil. Pola ini adalah tulang punggung discriminated union.

Narrowing sampai never

Hal yang sama terjadi pada narrowing apa pun, bukan hanya switch. Begitu semua kemungkinan sudah disingkirkan, variabelnya bertipe never:

function describe(x: string | number | boolean): string {
  if (typeof x === "string") return `string "${x}"`;
  if (typeof x === "number") return `number ${x}`;
  if (typeof x === "boolean") return `boolean ${x}`;
  const nothing: never = x; // every option handled
  return nothing;
}

console.log(describe("a")); // string "a"
console.log(describe(2));   // number 2
console.log(describe(true)); // boolean true

Kalau nanti kamu melebarkan parameternya menjadi string | number | boolean | bigint, baris const nothing: never = x menjadi error, yang menunjuk ke fungsi yang perlu diperbarui.

never Menghilang di Union

never adalah himpunan nilai yang kosong, jadi menambahkannya ke union tidak mengubah apa pun: string | never sama saja dengan string. Begitulah conditional type menyaring union. Cabang yang mengembalikan never membuang member tersebut:

type OnlyStrings<T> = T extends string ? T : never;

type Mixed = "a" | "b" | 1 | 2 | true;
type Letters = OnlyStrings<Mixed>; // "a" | "b"

const ok: Letters = "a";
// @ts-expect-error: Type '1' is not assignable to type 'Letters'.
const bad: Letters = 1;

console.log(ok);

Exclude<T, U> dan Extract<T, U> bawaan bekerja persis dengan cara ini. Di intersection, kebalikannya yang berlaku: string & never adalah never.

Tipe yang Mustahil Menjadi never

Intersection yang tidak bisa dipenuhi nilai apa pun akan menyusut menjadi never:

type A = string & number;                   // never
type B = { kind: "a" } & { kind: "b" };     // never

Membaca properti dari nilai bertipe B akan melaporkan alasannya: Property 'kind' does not exist on type 'never'. The intersection 'B' was reduced to 'never' because property 'kind' has conflicting types in some constituents. Kalau tipe yang kamu bangun ternyata menjadi never, cari dua bagian yang saling bertentangan.

never, unknown, dan any

unknown adalah puncak hierarki tipe, dan never adalah dasarnya. any sama sekali bukan bagian dari hierarki itu: ia mematikan pemeriksaan.