never ਕਿਸ਼ਮ ਕੀ ਹੈ ਅਤੇ ਇਹ exhaustiveness ਜਾਂਚ ਨੂੰ ਕਿਵੇਂ ਸਮਰੱਥ ਕਰਦਾ ਹੈ?

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 ਜਾਂਚ

ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ 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;
  }
}
```

ਹੁਣ ਜੇ ਕੋਈ `Shape` ਵਿੱਚ `{ kind: "triangle"; ... }` ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ ਪਰ ਇੱਕ ਕੇਸ ਭੁੱਲ ਜਾਂਦਾ ਹੈ, ਤਾਂ default ਵਿੱਚ `s` triangle ਕਿਸ਼ਮ ਹੈ (ਨਾ ਕਿ `never`), ਤਾਂ `const _exhaustive: never = s` **ਕੰਪਾਈਲ ਕਰਨਾ ਫੇਲ** ਕਰਦਾ ਹੈ — ਤੁਹਾਨੂੰ ਬਿਲਕੁਲ ਉਸ switch ਵੱਲ ਦਿਖਾਉਂਦਾ ਹੈ ਜੋ ਅਪਡੇਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

## never ਬਨਾਮ 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 ਦੀ ਸੁਰੱਖਿਆ, ਭਵਿੱਖ-ਪ੍ਰਮਾਣ ਹੈਂਡਲਿੰਗ ਦੀ ਕੁੰਜੀ ਹੈ — ਇੱਕ variant ਜੋੜੋ ਅਤੇ ਕੰਪਾਈਲਰ ਹਰ ਥਾਂ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ ਜਿਥੇ ਤੁਹਾਨੂੰ ਅਪਡੇਟ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।