Kas yra never tipas ir kaip jis suteikia išsamumo patikras?

Question

Accepted Answer

`never` yra tipas reikšmių, kurios **niekada neatsiranda** — funkcija, kuri negrįžta (išmeta išimtį arba begaliniai ciklai), arba šaka, kurią kompileris įrodė, kad neįmanoma. Tai yra *tuščias* tipas: jokia reikšmė nėra priskirta `never` (išskyrus patį `never`).

```ts
function fail(msg: string): never { throw new Error(msg); } // never returns
function loop(): never { while (true) {} }
```

## Kodėl never yra naudingas: išsamumo patikra

Kai susiaurinei union iki nieko, TypeScript likusią reikšmę nustato kaip `never`. Tu panaudoji tai, norėdamas priversti tvarkyti kiekvieną atvejį:

```ts
type Shape =
  | { kind: "circle"; r: number }
  | { kind: "square"; side: number };

function area(s: Shape): number {
  switch (s.kind) {
    case "circle": return Math.PI * s.r ** 2;
    case "square": return s.side ** 2;
    default:
      // if all cases are handled, s is `never` here — assignment OK
      const _exhaustive: never = s;
      return _exhaustive;
  }
}
```

Dabar, jei kas nors prideda `{ kind: "triangle"; ... }` į `Shape`, bet pamiršta atvejį, `s` numatytajame yra trikampio tipas (ne `never`), todėl `const _exhaustive: never = s` **nepavyksta kompiliuoti** — nurodydamas tiksliai, kurį switch reikia atnaujinti.

## never vs void

```ts
function a(): void {}   // returns normally, just no value
function b(): never { throw "x"; } // never returns at all
```

## Kodėl tai svarbu

`never` paverčia "ar tvarkaiau kiekvieną atvejį?" iš runtime viltės į kompiliavimo laiko garantiją.

Tai yra raktas į saugią, ateičiai parengtą diskriminuotų unijų tvarkymą — pridėk variantą ir kompileris išvardija kiekvieną vietą, kurią turi atnaujinti.