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` **సంకలనం విఫలమవుతుంది** — మీరు ఏ స్విచ్‌ను తప్పనిసరిగా నవీకరించాలో సూచిస్తుంది.

## 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 నిర్వహణకు కీ — వైవిధ్యం జోడించండి మరియు కంపైలర్ మీరు నవీకరించాల్సిన ప్రతిটి స్థానాన్ని సంఖ్య చేస్తుంది.