TypeScriptの型構文をパターンマッチングに活用する ArkType 2.1 の新機能

https://qiita.com/yonaka15/items/39dbe97206d6fe6e6f7b

# TypeScriptの型構文をパターンマッチングに活用する ArkType 2.1 の新機能

前回の記事では、TypeScriptの実行時型検証をシンプルに実現する ArkType 2.0 について紹介しました。今回は、さらに機能が拡張された ArkType 2.1 の目玉機能である「パターンマッチング」に焦点を当てて解説します。

## パターンマッチングとは

パターンマッチングは、データの構造や型に基づいて処理を分岐させる強力なプログラミング技法です。関数型プログラミング言語では一般的な機能ですが、JavaScript/TypeScriptには標準でこの機能が備わっていません（TC39で提案はされていますが、まだ実装段階ではありません）。

従来は `switch` 文や条件分岐を使って実装するか、専用のライブラリを使用する必要がありました。ArkType 2.1 では、TypeScriptの型構文を活用した新しいパターンマッチングAPIを提供します。

## ArkType 2.1 の `match` 機能

ArkType 2.1 の最大の特徴は、`match` 関数の導入です。この関数を使うと、TypeScriptの型構文を使って分岐条件を定義できます。内部的には集合論を活用して最適化されたマッチャーを構築し、一致しない分岐を自動的にスキップします。

これはJavaScriptにおける初めての「構文的なマッチャー」とされており、実行時の型情報を単なる検証以上に活用できる可能性を示す重要な一歩です。

### 基本的な使い方

まずは簡単な例を見てみましょう：

```typescript
import { match } from 'arktype'

const toJson = match({
  "string | number | boolean | null": v => v,
  bigint: b => `${b}n`,
  object: o => {
    for (const k in o) {
      o[k] = toJson(o[k])
    }
    return o
  },
  default: "assert"
})

// 文字列の変換
// 返り値の型: string | number | boolean | null
const a = toJson("foo")

// BigIntの変換
// 返り値の型: string
const b = toJson(5n)

// ネストされたオブジェクトの変換
// 返り値の型: object
const c = toJson({ nestedValue: 5n })
```

この例では、`toJson` というマッチャーを定義しています。入力値の型に応じて異なる処理を行い、最終的にJSONに変換できる値を返します。特筆すべき点は以下の通りです：

1. **型構文をそのまま使用** - TypeScriptの型表現（`string | number | boolean | null` や `bigint` など）をキーとして使用できます
2. **圧倒的なパフォーマンス** - ArkTypeの開発者によると、これらの処理はナノ秒単位で実行可能であり、従来のts-patternと比較して数十倍高速だとされています。この高速性は、型構文を事前に解析して最適化するアプローチによるものです。
3. **型情報の保持** - 返り値の型が正確に推論されます

### `default` オプションの活用

`match` 関数では、どのケースにも一致しない場合の処理を `default` で指定できます。以下の4つのオプションがあります：

1. `"assert"` - 未知の入力を受け付けるが、どのケースにも一致しない場合はエラーを投げる
2. `"never"` - 推論された型のみを受け付け、一致しない場合はエラーを投げる
3. `"reject"` - 未知の入力を受け付けるが、一致しない場合は `ArkErrors` を返す
4. `(data: In) => unknown` - 一致しない場合のカスタム処理関数

どのオプションを選ぶかは、アプリケーションの要件によって異なります。型安全性を最大限に確保したい場合は `"assert"` または `"never"` が適しています。

### フルーエントAPI

オブジェクトリテラルによる定義に加えて、メソッドチェーンを使った定義も可能です：

```typescript
import { match } from 'arktype'

const sizeOf = match()
  .case("string", s => s.length)
  .case("number | bigint", n => Number(n))
  .case("unknown[]", arr => arr.length)
  .default("assert")

sizeOf("hello") // 5
sizeOf(42) // 42
sizeOf([1, 2, 3]) // 3
sizeOf({}) // エラー: Object failed to match any case
```

この方法は、より複雑なパターンマッチングや、文字列に埋め込めない定義を扱う場合に便利です。

### 高度なマッチング機能

ArkType 2.1 では、さらに高度なマッチング機能も提供されています：

#### `in` による入力の絞り込み

```typescript
import { match } from 'arktype'

type Shape = 
  | { kind: "circle"; radius: number }
  | { kind: "rectangle"; width: number; height: number }

const area = match<Shape>()
  .in({ kind: "circle" }, ({ radius }) => Math.PI * radius * radius)
  .in({ kind: "rectangle" }, ({ width, height }) => width * height)
  .default("never")

const circle = { kind: "circle", radius: 5 }
area(circle) // 78.53981633974483
```

#### `at` によるプロパティマッチング

```typescript
import { match } from 'arktype'

const getMessage = match()
  .at("status", 200, () => "成功しました")
  .at("status", 404, () => "リソースが見つかりません")
  .at("status", 500, () => "サーバーエラーが発生しました")
  .default(data => `不明なステータス: ${data.status}`)

getMessage({ status: 200 }) // "成功しました"
```

## ts-pattern との比較

ArkType の開発者は、既存のパターンマッチングライブラリである ts-pattern の作者 Gabriel Vergnaud に敬意を表しつつ、ArkType の独自のアプローチを説明しています。

主な違いは以下の通りです：

1. **最適化のアプローチ** - ArkType は事前に型構文を解析して最適化し、後の実行を高速化します。この「先に解析して後で実行する」アプローチにより、実行時のパフォーマンスが大幅に向上します。
2. **エラーメッセージ** - 詳細な事前計算されたエラーメッセージを提供します。
3. **パフォーマンスのトレードオフ** - ArkType は初期化時（マッチャーを作成する時点）に計算コストがかかりますが、その後の実行は非常に高速です。これは一度定義して何度も使用するパターンに特に効果的です。

この特性から、サーバーコードのように起動時のオーバーヘッドよりも実行時のパフォーマンスが重要で、同じパターンマッチングを何度も実行するケースでは、ArkType が特に有効です。例えば、APIエンドポイントで頻繁に受信するデータ構造の検証などが好例です。

## ArkType 2.1 のその他の機能強化

パターンマッチング以外にも、ArkType 2.1 では以下のような機能強化が行われています：

### 組み込みキーワードのグローバル設定

エラーメッセージなどをカスタマイズするために、組み込みキーワードをグローバルに設定できるようになりました：

```typescript
// config.ts
import { arktype } from 'arktype'

arktype.config({
  string: {
    message: "文字列である必要があります"
  },
  number: {
    message: "数値である必要があります"
  }
})

// app.ts
import './config'
import { type } from 'arktype'

const user = type({
  name: 'string',
  age: 'number'
})

user({ name: 123, age: "30" }) 
// エラーメッセージ: "文字列である必要があります", "数値である必要があります"
```

### `to` 演算子の拡張

値の変換や検証を連鎖させるための `to` 演算子が拡張され、タプルや引数式で使用できるようになりました：

```typescript
import { type } from 'arktype'

const posInt = type('number |> $>=0 |> $==Math.floor($)')
posInt(3.14) // エラー: 3.14 !== Math.floor(3.14)
```

## 実践的な使用シナリオ

ArkType 2.1 のパターンマッチング機能は、以下のようなシナリオで特に有効です：

### APIレスポンスの処理

```typescript
const handleResponse = match({
  "{ status: 'success', data: unknown }": ({ data }) => processData(data),
  "{ status: 'error', message: string }": ({ message }) => handleError(message),
  "{ status: 'loading' }": () => showLoadingSpinner(),
  default: "assert"
})
```

### イベント処理

```typescript
const handleEvent = match()
  .in({ type: "click", target: string }, handleClick)
  .in({ type: "keydown", key: string }, handleKeyDown)
  .in({ type: "submit", form: object }, handleSubmit)
  .default("assert")
```

### データ変換

```typescript
const normalize = match({
  "string": s => s.trim().toLowerCase(),
  "number": n => n.toFixed(2),
  "boolean": b => b ? "yes" : "no",
  "unknown[]": arr => arr.map(normalize),
  "object": obj => {
    const result = {}
    for (const key in obj) {
      result[key] = normalize(obj[key])
    }
    return result
  },
  default: "assert"
})
```

## 開発者にとってのメリット

ArkType 2.1 のパターンマッチング機能を使用することで、以下のようなメリットが得られます：

1. **コードの簡素化** - 複雑な条件分岐が読みやすく、メンテナンスしやすくなります
2. **型安全性の向上** - 実行時にも厳密な型チェックが行われ、予期しないエラーを防ぎます
3. **パフォーマンスの改善** - 高度に最適化されたマッチングにより、処理時間が短縮されます
4. **開発体験の向上** - TypeScriptの型構文をそのまま使用できるため、学習コストが低減します

## まとめ：パフォーマンスと使いやすさを兼ね備えた新しいアプローチ

ArkType 2.1 のパターンマッチング機能は、TypeScriptの型構文を実行時に活用する可能性を大きく広げました。単なる型検証を超えて、型情報を基にした分岐処理を効率的に行えるようになったことで、より表現力豊かで堅牢なコードを書くことができます。

このライブラリの最大の特徴は、「事前最適化アプローチ」にあります。マッチャーを定義する時点で型の解析と最適化を行い、実行時には最小限の処理で高速に動作します。これは、特にサーバーサイドアプリケーションや高頻度で同じパターンマッチングを実行するユースケースで真価を発揮します。

また、パターンマッチングのためだけに新しい構文や概念を学ぶ必要がなく、既存のTypeScriptの知識をそのまま活用できる点も大きな利点です。TypeScriptの型システムに親しんだ開発者であれば、すぐに使いこなせるでしょう。

ArkTypeの開発チームは、「初期化時に少し時間がかかっても、その後の実行を極限まで高速化する」という明確な設計方針のもと、独自の最適化技術を実現したそうです。この新しいアプローチは、特にサーバーサイド開発者や大規模なデータ処理を行うアプリケーション開発者にとって魅力的な選択肢となりそうで。

## 参考リンク

- [ArkType 2.1 公式アナウンス](https://arktype.io/docs/blog/2.1)
- [GitHub リポジトリ](https://github.com/arktypeio/arktype)
- [NPM パッケージ](https://www.npmjs.com/package/arktype)