never type क्या हो र यसले exhaustiveness checks को लागि कसरी सक्षम गर्छ?

Question

Accepted Answer

`never` त्यो मूल्यको प्रकार हो जो **कहिले पनि आचरण गर्दैन** — एक function जो कहिले पनि रिटर्न नगर्दो (throw गर्छ वा सधैं loop मा रहन्छ), वा एक branch जो compiler ले असम्भव साबित गरेको छ। यो *खाली* प्रकार हो: कुनै पनि मूल्य `never` को लागि assign गर्न सकिदैन (`never` आफैं बाहेक)।

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

## never किन उपयोगी छ: exhaustiveness checking

जब तपाई एक union लाई केहीमा कम गर्नुहुन्छ, TypeScript ले बाँकी मूल्य लाई `never` को रूपमा टाइप गर्छ। तपाई यो प्रत्येक case को हेन्डलिङलाई बाध्य गर्न उपयोग गर्नुहुन्छ:

```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` मा थप्छ तर एक case भुल्छ, default मा `s` triangle type हो (`never` होइन), त्यसैले `const _exhaustive: never = s` **compile गर्न असफल हुन्छ** — तपाईलाई ठीक switch मा देखाउँदै जुन अपडेट गर्न आवश्यक छ।

## never बनाम void

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

## किन यो महत्त्वपूर्ण छ

`never` "मैले प्रत्येक case हेन्डल गरें?" लाई runtime आशा बाट compile-time guarantee मा बदलन्छ।

यो discriminated unions को सुरक्षित, भविष्य-प्रमाण हेन्डलिङको कुञ्जी हो — एक variant थप्नुहोस र compiler ले हरेक स्थान enumerate गर्छ जहाँ तपाई अपडेट गर्नुपर्छ।