never வகை என்றால் என்ன மற்றும் அது exhaustiveness checks ஐ எவ்வாறு செயல்படுத்துகிறது?

Question

Accepted Answer

`never` என்பது **எப்போதும் நிகழாத** மதிப்புகளின் வகை — ஒரு செயல்பாடு எப்போதும் திரும்பாது (வீசுகிறது அல்லது நிரந்தரமாக வளையும்), அல்லது கம்பைலர் சாத்தியமற்றதாக நிரூபித்த ஒரு கிளை. இது *வெற்று* வகை: `never` க்கு (தனியாக `never` தவிர) எந்த மதிப்பும் ஒதுக்கக்கூடியதல்ல.

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

## never ஏன் பயனுள்ளது: exhaustiveness checking

ீனீ ஒரு union ஐ எதுவுமற்றதாக குறைக்கும்போது, TypeScript மீதமுள்ள மதிப்பை `never` என வகைப்படுத்துகிறது. ஒவ்வொரு வழக்கையும் கையாள நী இதை பயன்படுத்துகிறீ:

```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;
  }
}
```

இப்போது யாராவது `{ kind: "triangle"; ... }` ஐ `Shape` க்கு சேர்க்கினாலும் ஒரு வழக்கை மறந்தாலும், default இல் `s` என்பது முக்கோண வகை (எப்போதும் அல்ல), எனவே `const _exhaustive: never = s` **தொகுக்க தோல்வியடையும்** — நீ எந்த switch ஐ புதுப்பிக்க வேண்டும் என்பதை சுட்டிக்காட்டுகிறது.

## never vs void

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

## ஏன் முக்கியமாக உள்ளது

`never` "ஒவ்வொரு வழக்கையும் நான் கையாண்டேனா?" என்பதை runtime தக்கவைப்பு முதல் compile-time உத்திரவாதமாக மாற்றுகிறது.

இது பாதுகாப்பான, எதிர்ப்பறுக்கக் கூடிய discriminated unions கையாளுவதன் திறவுகோல் — ஒரு மாறுபாடு சேர்க்கவும் மற்றும் கம்பைலர் நீ புதுப்பிக்க வேண்டிய ஒவ்வொரு இடத்தையும் கணக்கிடுகிறது.