TypeScriptで配列が指定した要素を全部持つか調べる方法

TypeScriptは、JavaScriptに型がついたたいへん素晴らしい言語です。しかし、元がJavaScriptであるということで、やりたいことが一筋縄ではうまくいかないこともままあります。

この記事ではそのような事例を一つ取り上げて、解決策やその考え方を紹介します。

記事に出てくるTypeScriptの型がよく分からない場合は以下の記事を参照するとよいかもしれません。

- [TypeScriptの型入門](https://qiita.com/uhyo/items/e2fdef2d3236b9bfe74a)
- [TypeScriptの型初級](https://qiita.com/uhyo/items/da21e2b3c10c8a03952f)

# 解決したい問題
例えばタブ型のUIを作りたい場合を考えます。各タブの名前を文字列で表現する場合は、タブ名の型はそれらの文字列のunion型となるでしょう。（下のコードは`Tab`型の利用例としてReactのコードが出てきますが、Reactが分からなくても本題の理解には問題ありません。）

```tsx
/** タブ名の型 */
type Tab = 'tab1' | 'tab2' | 'tab3';

/** タブを表示するコンポーネント（React） */
function TabComponent(props: { tab: Tab }) {
  switch (props.tab) {
    case 'tab1':
      return <div>タブ1</div>;
    case 'tab2':
      return <div>タブ2</div>;
    case 'tab3':
      return <div>タブ3</div>;
  }
}
```

このような型を作った場合、タブ名の一覧の配列が欲しくなることがよくあります。

```tsx
/** 全てのタブ名の配列 */
const tabs: Tab[] = ['tab1', 'tab2', 'tab3'];

/** メニューを表示するコンポーネント */
function Menu() {
  return <ul>{
    tabs.map(tab => <li><a>{tabName(tab)}</a></li>)
  }</ul>
}
```

今回問題となるのは、ここで出てきた変数`tabs`です。後からタブ4が追加されて`Tab`型の定義が以下のように変更された場合を考えてください。

```ts
type Tab = 'tab1' | 'tab2' | 'tab3' | 'tab4';
```

こうした場合、タブ名の一覧の配列についても変更する必要があります。理想的には、変更する必要がある箇所は型エラーになってほしいですね。型エラーが発生してくれれば修正するべき箇所を簡単に発見することができます。下の例は`Tab`の変更後は「全て」ではなくなっているのにエラーは発生しません。

```tsx
/** 全てのタブ名の配列（“全て”でないのに型エラーにならない！） */
const tabs: Tab[] = ['tab1', 'tab2', 'tab3'];
```

そこで、`Tab`の変更が型エラーとなるようなコードを書きたいというのが今回の問題です。

より一般的な言い方をすれば、「与えられた配列が、union型で指定した要素を全部含むかどうか型検査で調べたい」ということになります。

# 解決策
では、いきなりですが完成された解決策を見ましょう。

```ts
type ElementOf<A extends any[]> = A extends (infer Elm)[] ? Elm : unknown;
type IsNever<T> = T[] extends never[] ? true : false;

function allElements<V>(): <Arr extends V[]>(arr: Arr) =>
    IsNever<Exclude<V, ElementOf<Arr>>> extends true ? V[] : unknown {
    return arr => arr as any;
}

type Tab = 'tab1' | 'tab2' | 'tab3' | 'tab4';

// tabsはunknown型
const tabs = allElements<Tab>()(['tab1', 'tab2', 'tab3']);
// tabs2はTab[]型
const tabs2 = allElements<Tab>()(['tab1', 'tab2', 'tab3', 'tab4']);
```

上半分が今回作ったもので、下半分が例です。変数`tabs`に直接配列を代入するのではなく、今回作った`allElements`という関数を噛ませるようになりました。この`alElements`関数はunion型で与えられた型変数を1つとり、与えられた配列がunion型の各要素を全部含んでいれば返り値の型はそれの配列型となり、含んでいなければ返り値の型がunknown型になるという関数です。

よく見ると、関数呼び出しの括弧が2つ並んでいますね。これは、複数の型引数のうち一部だけ指定して、一部を引数から推論させたいときに使うテクニックです。

TypeScriptでは現在のところ、型引数を一部省略するということはできません。全部省略して推論してもらうか、全部書くかのどちらかです。ところが、このように関数を返す関数を用いることで一部だけを指定することができます。この例では、気持ちの上では`allElements`は`V`と`Arr`の2つの型引数を持つわけですが、そのうち`V`のみを利用者側に指定してほしいため、このように関数を分割して`V`のみを指定できるようにしています。早いところ、一部のみ型引数を指定できる機能が実装されてほしいですね。

ここで述べたように、`Arr`の型引数を明示しないことでTypeScriptに推論させるというのが最初のポイントです。`Arr`は型指定を見ると分かるように、引数として渡された配列の型です。これを推論させることで、型引数`Arr`に「実際に渡された型」の情報が得られるようになっています。上のコードの一部を再掲します。

```ts
function allElements<V>(): <Arr extends V[]>(arr: Arr) =>
    IsNever<Exclude<V, ElementOf<Arr>>> extends true ? V[] : unknown {
    return arr => arr as any;
}

const tabs = allElements<Tab>()(['tab1', 'tab2', 'tab3']);
```

この呼び出しで型引数`V`と`Arr`がどうなるかを考えましょう。`V`は型引数で指定されている通り、`Tab`です。`Tab`は`'tab1' | 'tab2' | 'tab3' | 'tab4'`のことでしたね。一方で、`Arr`は引数`arr`の型です。今回`arr`に渡されているのは`['tab1', 'tab2', 'tab3']`なので、引数の型を全部unionでつなぐと`'tab1' | 'tab2' | 'tab3'`となります。よって、型`Arr`はそれの配列の型、すなわち`Array<'tab1' | 'tab2' | 'tab3'>`となります。

こうなると、何となく希望が見えてきましたね。「必要な要素全ての型」と「実際に与えられた型」が得られたので、それらに差があるかどうか確かめればいいわけです。

なお、ここで一つ注意しておきたいのですが、`['tab1', 'tab2', 'tab3']`の型が`Array<'tab1' | 'tab2' | 'tab3'>`のように推論されるのは型引数を推論するときだけです。これを通常の変数に入れるとリテラル型の情報は消えます。

```ts
// arrの型はstring[]となる
const arr = ['tab1', 'tab2', 'tab3'];
```

ですので今回の関数は、配列リテラルを直接`allElements`に渡さないと`Arr`が正しく推論できません。

このように、配列（やオブジェクト）の中身をリテラル型として得たい場合は型引数の推論対象に直接入れてあげる必要があります。これはよく使うテクニックなので覚えておくとよいでしょう。

---

では、話を戻します。`V`と`Arr`の意味は分かったので、残るはこれらから返り値を決める部分です。`allElements`の返り値（正確には返り値の返り値）は以下のようになっていますね。

```ts
IsNever<Exclude<V, ElementOf<Arr>>> extends true ? V[] : unknown
```

ここで使われている2つの補助型の定義も再掲します。

```ts
type ElementOf<A extends any[]> = A extends (infer Elm)[] ? Elm : unknown;
type IsNever<T> = T[] extends never[] ? true : false;
```

`ElementOf<A>`は配列型`A`の要素の型を得る型関数です。（書いてから気が付きましたが、`A[number]`でも良かったですね。）`IsNever<T>`は、`T`が`never`型なら`true`型を、そうでなければ`false`型を返す型関数です。

そして、`Exclude<T, U>`は、union型`T`と`U`を受け取って、`T`の要素から`U`の要素を除いた型を返す型関数です。

`ElementOf<Arr>`によって、配列で与えられた要素の一覧をunion型で取得しています。今回の例では、`ElementOf<Arr>`は`'tab1' | 'tab2' | 'tab3'`となりますね。これは実際に配列に含まれている要素の型の一覧でした。

これを、`V`、すなわち含まれていてほしい全ての型の一覧から引き算していることになります。そうなると、残るのはなんでしょうか。そう、「含まれていてほしいけど与えられた配列には含まれていなかった型」が残ります。上の例で考えると、`V`は`'tab1' | 'tab2' | 'tab3' | 'tab4'`だったので、そこから`ElementOf<Arr>`を引いた結果は`'tab4'`となります。これは、与えられた配列には`'tab4'`が含まれていてほしかったのに含まれていないことを意味しています。

次に、`Exclude`の結果が`never`型かどうかを`IsNever`で判定しています。`never`なら結果の型は`V[]`に、そうでないなら`unknown`となることが分かります。実は、`Exclude<T, U>`で`U`に`T`の要素が全部含まれていた場合、結果は空っぽになります。この空っぽを表す型が`never`型です。

以上が返り値の型の解説です。結局、与えられた配列にほしい型が全部含まれているかどうかをチェックしてそれによって返り値の型を変えているということがお分かりになると思います。

本当は、全部含まれていなかった返り値の型が`unknown`というのは理想的ではありません。理想的には、そうなった時点で型エラーが発生して欲しいです。そのような「型エラーを発生させる型」というのはやはり需要があるらしく[議論があります](https://github.com/Microsoft/TypeScript/issues/23689)。

とはいえ、これを型エラーに変換するのは難しくありません。一つの方法は型アノテーションです。

```ts
// unknown型はTab[]型に代入できないのでエラーが発生
const tabs: Tab[] = ellElements<Tab>()(['tab1', 'tab2', 'tab3']);
// こっちは大丈夫
const tabs2: Tab[] = ellElements<Tab>()(['tab1', 'tab2', 'tab3', 'tab4']);
```

これはちゃんと型エラーが発生して偉いですが、`Tab`と2回書かなければいけないのが少し残念です。

もうひとつの方法は、`unknown`型のまま放置するという方法です。正しくやれば結果は配列型となることを意図していますから、`tabs`を使おうとしたときにエラーが発生するという寸法です。これは楽ですが、エラーの発生する位置が`tabs`を使う場所なのでいまいち分かりにくいという欠点があります。

最後の方法は、型が配列であることをチェックする関数にさらにかけるという方法です。

```ts
function assertArray<T>(arr: T[]): T[] {
    return arr;
}

// unknown型の要素をT[]型の引数に渡そうとしたのでエラー
const tabs = assertArray(ellElements<Tab>()(['tab1', 'tab2', 'tab3']));
const tabs2 = assertArray(ellElements<Tab>()(['tab1', 'tab2', 'tab3', 'tab4']));
```

この例のように、引数が配列の型になっていることをチェックする`assertArray`を用意する方法です。これは`Tab`を2回書く必要が無くて偉いですが、記述量が多いという欠点があります。どれも一長一短ですね。

## 余談
ところで、上では簡単のためにunknownを返り値にしましたが、これだとエラーメッセージがちょっと分かりにくいという問題があります。

```ts
// error TS2322: Type 'unknown' is not assignable to type 'Tab[]'.
const tabs: Tab[] = ellElements<Tab>()(['tab1', 'tab2', 'tab3']);
```

エラーメッセージは「`unknown`型を`Tab[]`に代入することはできません」と言っていて、まあそうなのですが、どの要素が足りないのか（今回の場合は`'tab4'`）ということが分からないのでエラーメッセージとしては不親切です。

例えばこんな感じに改良する方法があります、

```ts
function allElements<V>(): <Arr extends V[]>(arr: Arr) =>
    IsNever<Exclude<V, ElementOf<Arr>>> extends true ? V[] : {notFound: Exclude<V, ElementOf<Arr>>} {
    return arr => arr as any;
}
```

返り値の型を`unknown`ではなく`{notFound: Exclude<V, ElementOf<Arr>>}`としています。この`Exclude<V, ElementOf<Arr>>`というのは含まれていない値の型だったので、これを返り値の型に含めてやることでエラーメッセージに表示させようという魂胆です。こうすると先のエラーはこのようになります。

```ts
// error TS2322: Type '{ notFound: "tab4"; }' is not assignable to type 'Tab[]'.
//   Property 'length' is missing in type '{ notFound: "tab4"; }'.
const tabs: Tab[] = ellElements<Tab>()(['tab1', 'tab2', 'tab3']);
```

ごちゃごちゃしていて分かりやすいとは言えませんが、`'tab4'`が足りないという情報がエラーメッセージに入っていて偉いですね。

# まとめ
この記事ではリテラル型とunion型にまつわる身近な問題を取り上げ、その解決策を紹介しました。条件型のような難しい型を実用的に用いるよい例となっていると思います。皆さんもぜひこのような問題を見つけてTypeScriptの型の力で解決しましょう。

技術的な面では、配列リテラルの要素をリテラル型（のunion）として得るために型引数を推論させるというテクニックを紹介しました。このテクニックは結構使いますので覚えておくとそのうち役に立つのではないかと思います。