TypeScript 「never」を使った網羅チェック

UNIONを使った全網羅条件分岐処理の場合、条件が追加になっても対応漏れにならないように対策をしましょう。っていう話。

ユーザーランク「A, B, C」がありました。
```javascript
// ユーザーランク
type UserRankOptions = 'A' | 'B' | 'C';
```
ユーザーランクに以下の仕様変更が発生が発生しました。
> ランクDを追加
> ランクDのボーナスポイントは30とする

```javascript
type UserRankOptions = 'A' | 'B' | 'C' | 'D'; // ランクD追加
```

## :-1::-1:　なにも対策していない
**addBonusPoint**メソッドは対策をしていなので、改修が漏れた場合ランクDのボーナスポイント30が付加されず不具合の要因になる。
```javascript
// ユーザーランク
type UserRankOptions = 'A' | 'B' | 'C' | 'D';

// ユーザークラス
class User {
  private _point: number;
  private _rank: UserRankOptions;
  public constructor(rank: UserRankOptions) {
    this._point = 0;
    this._rank = rank;
  }
  public get point() { return this._point }
  public set point(point: number) { this._point = point}
  public get rank() { return this._rank }
  
}

// ボーナスポイントを付加
function addBonusPoint(user: User): void {
  switch (user.rank) {
    case 'A': 
      user.point += 100;
      break;
    case 'B': 
      user.point +=  70;
      break;
    case 'C': 
      user.point +=  50;
      break;
    // ランクDの処理が漏れている！！！
  }
}

const user = new User('D');
addBonusPoint(user); // ボーナスポイント30が付加されない。。。
consolo.log(user.point); // 0
```

## :-1:　例外エラーによる対策
予期しない値を受け取ると例外エラーを発生させ、改修漏れを防ぐ対策となります。
「D」を受け取ると例外エラーが発生するので、改修漏れでも**運良ければ**検証中（実行中）に発見出来きます。
改修が漏れているということはUTテストケース改修も漏れるのでUTで気付くのは難しいかも。。。。
```javascript
function addBonusPoint(user: User): void {
  switch (user.rank) {
    case 'A': 
      user.point += 100;
      break;
    case 'B': 
      user.point +=  70;
      break;
    case 'C': 
      user.point +=  50;
      break;
    // 例外エラーにして、改修漏れ対策をする  
    default:
      throw new Error(`${user.rank}未対応ランク値`);  }
}
```

## :+1:　neverを使った例外エラーによる対策
これも予期しない値を受け取ると例外エラーを発生させ、改修漏れを防ぐ対策となります。
**neverを使っていな場合との違いは、neverを使うと「実装エラー」となることです。**　
実装エラーになるので、改修実装時に改修箇所を特定できます。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3477554/1295e395-3891-2426-c73e-0832f7dd5eee.png)

```javascript
// 全網羅例外エラークラス
class ExhaustiveError extends Error {
  constructor(value: never, message = `未対応値: ${value}`) {
    super(message);
  }
}

function addBonusPoint(user: User): void {
  switch (user.rank) {
    case 'A': 
      user.point += 100;
      break;
    case 'B': 
      user.point +=  70;
      break;
    case 'C': 
      user.point +=  50;
      break;
    default:
       // Dの分岐がないとエラーになる
      // Argument of type 'string' is not assignable to parameter of type 'never'.ts(2345)  
      throw new ExhaustiveError(user.rank);  }
}
```

# おまけ

## 戻り値がある場合、到達不能（デッド）分岐は実装しないほうがよい？
### :-1::-1:　到達不能分岐を実装する
「とりえずdefaultの場合は0でも返しておくかー」的な発想で、到達不能（デッド）分岐を実装してしまう。
```javascript
type UserRankOptions = 'A' | 'B' | 'C';

function getBonusPoint(userRank: UserRankOptions): number {
  switch (userRank) {
    case 'A': 
      return 100;
    case 'B': 
      return 70;
    case 'C': 
      return 50;
    default: // 到達不能（デッド）分岐
      return 0; //0って意味のない値 
  }
}
```
「D」の分岐が無いため**default**分岐が「到達不能」から「到達可能」になります。
改修しないとランクDの場合「０」が戻ってくるので不具合の要因となります。

「UserRankOptions」を使用している全プログラムを調査すればよいが、大規模システムだとこの作業が結構大変だったりします。

### :+1:　到達不能分岐を実装しない
実装エラーになるので、改修実装時に改修箇所を特定できます。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3477554/1b3c31fa-359b-a8c5-1413-36d88ea3cbf7.png)

:warning:　これはTypeScriptの設定「strictNullChecks: true」になっていないとエラーにならないので注意です。
```javascript
type UserRankOptions = 'A' | 'B' | 'C' | 'D';

// エラー：Function lacks ending return statement and return type does not include 'undefined'.ts(2366)
function getBonusPoint(userRank: UserRankOptions): number {
  switch (userRank) {
    case 'A': 
      return 100;
    case 'B': 
      return 70;
    case 'C': 
      return 50;
  }
}
```