TypeScript で “radian” と “degree” を間違えないようにする

今回は、degree と rad, EUR と JPYなど、ついつい間違ってしまいがちな概念を型レベルで区別するためのアプローチを紹介します。

tl; dr

• @fsubalさんの「TypeScript で幽霊型っぽいものをつくる」という記事で紹介されているやり方を使うとよい
• 一方で、PureScriptなどのプログラミング言語には、既存の型１つをラップして新しい型をつくるために newtype というキーワードがある
  • TypeScriptは言語レベルではnewtypeをサポートしていないが、ライブラリとして newtype-tsがある。
    • newtype の本来の目的に加えて、その型で”正の値”, “0でない”などの条件をmonadicに表現することができる
      • そのため内部表現に変換することになり、若干の実行時オーバーヘッドがある。必要でないなら@fsubalさんのやり方を使うと良い

“単位” をどう扱うか

冒頭で挙げたようなdegree と rad, EUR と JPYなどの”単位”を間違えないようにするためには、どうするとよいのでしょうか？すぐ思いつきそうなアプローチは、変数名で区別することです。

declare function degToRad(degree: number): number;
declare function radToDegree(rad: number): number;

const angleInDegree = 90;
const angleInRad = Math.PI / 2;
degreeToRad(angleInDegree);
radToDegree(angleInRad);

これは手軽で、ほとんどのプログラミング言語で利用できる素敵なアプローチです。しかし、うっかり変数定義を間違えてしまったりすると実行時エラーになってしまいそうです。

そこで、型レベルで degree と radian を表現することにしましょう。型を定義すればコンパイル時にエラーに気づいたり、実行時エラーのエラーメッセージをわかりやすくしたりすることができるからです。

type Degree = number;
type Rad = number;

declare function degreeToRad(degree: Degree): Rad;
const angleInDegree: Degree = 90;
const angleInRad = Math.PI / 2;

// ok!
degreeToRad(angleInDegree);
// ok!?
radToDegree(angleInRad);

TypeScriptを普段からお使いの方にとっては当然かもしれませんが、ここで radToDegree(angleInRad) はコンパイルエラーになりません。TypeScriptやその他のプログラミング言語のtype キーワードで定義した型は、単に元の型のエイリアスとなり、別の型にはならないのです。

「ユーザ定義型を使いたい」というissue(proposal)はTypeScript公式に立っているようですが、現状 Degree, Rad, number をそれぞれ別の型として定義する、一番良いアプローチは何なのでしょうか？

アプローチA. 幽霊型っぽいもの定義する

1つは、@fsubalさんの「TypeScript で幽霊型っぽいものをつくる」という記事で紹介されているアプローチです。

// https://qiita.com/fsubal/items/cbbe170edbe07d775bab
type Degree = number & { __DegreeBrand: never };
type Radian = number & { __RadianBrand: never };

const doSomething = (degree: Degree) => alert(degree.toString())

// ok
const tenInDegree = 10 as Degree;
doSomething(tenInDegree)

// not ok
// "Conversion of type 'Degree' to type 'Radian' may be a mistake because neither type sufficiently overlaps with the other."
const tenInRadian = tenInDegree as Radian;

シンプルで強力な、たいへん素晴らしいやり方です。

アプローチB. newtype-ts を使う

ところで、TypeScriptと同じAltJSである、PureScriptにおける答えはnewtype になるでしょう。PureScriptでは次のようにしてDegree, Radを定義できます。

newtype Degree = Degree Number
newtype Rad = Rad Number

これでPureScriptのコンパイラ(pscといいます)はDegreeとRadを区別してくれます。もちろん、コンパイルを通した後には内部表現に使うややこしいオブジェクトの姿は消え失せて、何事もなかったかのようにnumberになっています。すばらしいですね！

しかしながら、TypeScriptにはnewtypeやそれ相当の概念はありませんので、ライブラリを使って実現することになります。newtype-tsという便利そうなライブラリを見つけたので紹介します。

まずは使い方ですが、とてもシンプルです。

import { Newtype, iso } from "newtype-ts";

interface Degree extends Newtype<{ readonly Degree: unique symbol }, number> {}

// isoDegree: Iso<Degree, number>
// 定義: https://github.com/gcanti/monocle-ts#iso
// 利用例: https://github.com/gcanti/monocle-ts/blob/master/examples/Iso.ts
const isoDegree = iso<Degree>();

// number -> Degree
const angleInDegree = isoDegree.wrap(90);
// Degree -> number
const n = isoDegree.unwrap(angleInDegree);

declare function degToRad(degree: Degree): void;

degToRad(90); // compile error
degToRad(angleInDegree); // ok!

まず、ライブラリが提供するNewtype<S, A>をextendsしたDegreeインターフェイスを定義します。ここで、Sに{ readonly Degree: unique symbol }という型を渡しています。

unique symbol はcomputed property nameを型安全に実現するために導入された型のようです（PRに定義やサンプルコードが書いてありました）。例えば、幽霊型のアプローチで使ったこのコードですが、

type Degree = number & { __DegreeBrand: never };

unique symbol 型を使って次のように書くことができます。

type Degree = number & { readonly __DegreeBrand: unique symbol };

次に、このDegreeを使ってIsoクラスのインスタンスをつくります。Isoとは、互いに変換可能な２つの概念を表現するためのクラスで、TypeScriptでHaskellのLensようななことをするためのmonocle-tsというライブラリの内部で使われている型のようです。

monocle-tsのリポジトリにあるIsoのサンプルコードを見てみましょう。

// From: https://github.com/gcanti/monocle-ts/blob/master/examples/Iso.ts
import { Iso } from '../src'

const mToKm = new Iso<number, number>(m => m / 1000, km => km * 1000)

console.log(mToKm.get(100)) // => 0.1
console.log(mToKm.reverseGet(1.2)) // => 1200

const kmToMile = new Iso<number, number>(km => km / 1.60934, miles => miles * 1.60934)

// composition
const mToMile = mToKm.compose(kmToMile)

console.log(mToMile.get(100)) // => 0.06213727366498068

“km”と”m”という互いに変換可能な概念を、型で表現していることがわかります。

newtype-tsの提供するiso関数は、先程のDegree型のようにNewTypeインターフェイスをextendsした型をジェネリクスで指定して呼び出すと、このコードのようにIsoクラスのコンストラクタに2つの概念を変換するための関数を渡してくれます。といっても、newtypeの場合は２つの概念を型レベルで区別するだけなので、取った引数をそのまま返す関数を渡しています。

あとは見ての通り、isoインスタンスのwrap(), unwrap()メソッドを利用してnumber -> Degree, Degree -> number の変換をしています。

“degree” をより安全に処理する

ここまではA.のやり方でも実現できますし、むしろIsoクラスのインスタンスを作ったりする手間を考えるとA.のやり方のほうがベターです。

しかし、newtype-ts では、本来の目的に加えて”正の値”, “0でない”などの制約を型に持たせることができます。先程定義したDegree に、”90で割り切れる数である”という制約を付けてみましょう。

import { Newtype, prism, iso } from "newtype-ts";

interface Degree extends Newtype<{ readonly Degree: unique symbol }, number> {}

const isMultiplesOf90 = (n: number) => n % 90 === 0;

const degreeMultiplesOf90 = prism<Degree>(isMultiplesOf90);

// optional90: Option<Degree>
const optional90 = degreeMultiplesOf90.getOption(90);
const optional5 = degreeMultiplesOf90.getOption(5);
const isoDegree = iso<Degree>();
const zeroInDegree = isoDegree.wrap(0);

console.log(
  // 90
  optional90.getOrElse(zeroInDegree),
  // 0
  optional5.getOrElse(zeroInDegree)
);

prism関数は先程紹介したiso関数のように、monocle-tsのクラスPrismのインスタンスを返してくれます。Prismを使うと、ある値が”制約”を満たしている場合でもそうでない場合でも、実行時エラーにならないような安全な処理をfunctionalに書くことができます。

今回は制約としてprismにconst isMultiplesOf90 = (n: number) => n % 90 === 0;という関数を渡してインスタンスを返してもらいます。このインスタンスのメソッドgetOptionは、”制約を満たす場合はその値（がsomeでラップされたsome(value)）を、そうでなければnoneを返す”という関数です。

getOptionはsome(value)かnoneを返すことがわかっているため、パターンマッチング的に安全な処理を書くことができます。ここではgetOrElseメソッドを使って、「制約を満たさない場合は0を、満たす場合はその値を返す」ように記述することができました。

さいごに

後半で紹介したnewtype-ts、そしてnewtype-tsの依存しているライブラリであるmonocle-tsは、いずれもfp-tsというライブラリの作者である@gcantiさんによるものです。最近のTypeScriptには先程挙がったcomputed property nameやunknown typeなどの強力なシステムが追加されており、@gcanti氏はこれらを巧みに利用してtype safeでfunctionalなコードを書くためのライブラリを多く公開しています。興味があれば調べてみると面白いかもしれません。（最近では代数的データ型を表現するためのボイラープレートを自動生成してくれるfp-ts-codegenが公開されました。）

カブクでは、type safeなコードやfunctionalなコードで堅牢なソフトウェアを開発したいプログラマを募集しています！

スペシャルサンクス: @kimamula(レビュー, アドバイス)