型クラスのご紹介

オーバーロードの必要性 ⁴

int型の値が 2 つあって、等しいのか調べたいですね。コードを書きます

let rec eq_int a b =
  match a, b with
  | 0, 0 -> true
  | _, 0 -> false
  | 0, _ -> false
  | n, m -> eq_int (n - 1) (m - 1)

なるほど⁵。じゃあ string は⁶？標準ライブラリにいい関数があったので借りてくる。

let eq_string = String.equal

いいね。使ってみる⁷。

# eq_int 1 2 ;;
- : bool = false
# eq_string "abc" "abc" ;;
- : bool = true

正しい感じがする。ところで OCaml には = という演算子があって…同じ型であればこの演算子を使って値の比較ができる:

# (=) ;;
- : 'a -> 'a -> bool = <fun>
# 1 = 2 ;;
- : bool = false
# "abc" = "abc" ;;
- : bool = true

お〜すごい。ところで文字列と数値は内部表現がかなり違いそうな気がしますが…

前の記事でちょっと書いた話と関連するんですが、OCaml はランタイムの値にメタな情報を埋め込んで、それを見ながら = の実装内で実行時に分岐して比較しています。

でもちょっと待って、1 = 1では int の値に適用しているんだから eq_int を、"abc" = "abc"では string の値に適用しているんだから eq_string を呼べばいいってことはコンパイル時に分かるのでは？整数含む全オブジェクトに共通の内部表現を持たせるのはなかなか厳しいものがあるので⁸、コンパイル時に呼び分けることができたらかなり嬉しいですね。

おっとそれだけではない！！'a -> 'a -> boolというハイパワーな型を持っているので、例えば関数同士の比較といった“ない”操作⁹も型チェックを通ってしまう。

# eq_int = eq_int ;;  (* runtime error *)
Exception: Invalid_argument "compare: function value".

おぅ…これはしんどいわね。

別の例を見てみます。OCaml でも + は見た目に違わず、加算の演算子です。使ってみましょう:

# 1 + 2 ;;
- : int = 3
# 1.1 + 1.2 ;;
Error: This expression has type float but an expression was expected of type
         int

なんか言ってますね。型を見てみます

# (+) ;;
- : int -> int -> int = <fun>

なるほど + は int にしか使えないらしい。じゃあ float はどうすれば…+.があります

# (+.) ;;
- : float -> float -> float = <fun>
# 1.1 +. 1.2 ;;
- : float = 2.3

ん〜解決ｗとはならなくて、使う型ごとに演算子を変えなきゃいけないのはしんどいなあという気持ちになります。

この時点でわかったしんどさをまとめてみます。=と + の例に共通していたのは、「同じ記号に型によって違う意味を持たせたい」という点でした。その上で:

• 型ごとに別名を作りたくない
  • +.のようにユーザーに呼び分けを要求したくない
• 取れる型を、意味が存在する型のみに制限したい
  • (=) :: ('a -> 'a) -> ('a -> 'a) -> bool は許容したくない
  • (+) :: bool -> bool -> bool も許容したくない

まず前者の問題を解決するために登場するのが¹⁰、オーバーロード (overloading)と呼ばれる機能です。直感的な説明としては同じ名前に対して複数の意味を与えられる言語機能になります。下に C++での例を示します¹¹。

int add(int a, int b) {
    return add_int(a, b);
}

float add(float a, float b) {
    return add_float(a, b);
}

ここで、addには 2 つの実装があり、引数が int か float かによって呼び分けることができます。=についても同様で、実際に C++の標準ライブラリでは operator== が比較関数として様々な型にオーバーロードされています。

なお、今後の記事中で二項演算子(+とか)は二引数関数として扱います。すなわち a + b は (+) a bとしてパースされるイメージです。

多相性について

さて話は変わりますが、多相性 (polymorphism) についてお話しします。複数の型を同時に表す型で、とある世界線でのジェネリクスのようなものです。 多相性には大きく分けて二種類あって、

• パラメトリック多相 (parametric polymorphism) 1 つの名前に複数の型を持つ。付く型によらず同一のオブジェクトを示す。
• アドホック多相 (ad-hoc polymorphism) 1 つの名前が複数の型を持つ。付く型によって異なるオブジェクトを示す。

があります。パラメトリック多相のわかりやすい例としてはリストの長さを返す関数 len :: 'a list -> int があります。これは任意の 'a について 'a list 型のリストの長さを求める 1 つの関数です。一方、先ほど紹介したオーバーロードは型によって違う実装が使われるのでアドホック多相ですね。

型クラスあらわる

では後者の問題、すなわち取れる型の制限について考えてみましょう。先ほどの例で、=は 'a -> 'a -> bool では弱すぎることがわかりました。+ではその問題がよりはっきりしていて、'a -> 'a -> 'a'ではたまったもんじゃない。じゃあ、名前に対して取れる型の集合を与えてあげてはどうでしょうか？int, float, bool、そして関数型しかないと仮定すると、こう:

(=) :: { int -> int -> bool, float -> float -> bool, bool -> bool -> bool }

(+) :: { int -> int -> int, float -> float -> float }

オ〜良さそうだ。しかしこの方法では拡張性がないですね。 すなわちこの方法では (=) の定義箇所で (=) が使える型を全て把握している必要がありますが、実際には (=) の定義の後に (=) が使える型を増やしたいことは往々にしてあります。 言語プリミティブの型は = が使えるがユーザーが定義した型は結局呼び分ける必要があるというのは（先程の状況からは改善されたとはいえ）悲しい気持ちになってしまいます。

そこで型クラスです。型クラスを使うとオーバーロードされた名前が取りうる型を制限された型スキームの形で表現することができます。

(=) :: ∀'a. Eq 'a => 'a -> 'a -> bool

(+) :: ∀'a. Num 'a => 'a -> 'a -> 'a

これは先程の方法と比べると取りうる型の制限の仕方が Eq 'a などとすこし抽象的になっています。 型の分類¹²を型から分離したことで拡張性を手に入れた、といった感じでしょうか。 そのため、ユーザーが定義した型でもその型が Eq であると後で宣言してやることで、その型に対して (=) を使うことができます！ なお、型が型クラスに含まれていることを宣言するものをインスタンス宣言と呼んでいます。

型コンストラクタの型クラス

話は変わりますが¹³map関数を知っていますか？僕は知っています:

List.map :: ('a -> 'b) -> 'a list -> 'b list

さて、'a optionにも map は定義されている。

Option.map :: ('a -> 'b) -> 'a option -> 'b option

なら、mapもオーバーロードできまいか。

map :: ∀'a 'b 'f. Mappable 'f => ('a -> 'b) -> 'a 'f -> 'b 'f

ム、Mappable¹⁴になっている 'f は型ではない。これは 'a 'f で型になっているところからわかるとおり型を受けとって型を返す型コンストラクタで、これの上の型クラスも許すことができたら嬉しいです。こういう型クラスと型コンストラクタを組み合わせた体系はconstructor classという名前で[2]で提示されました。

型コンストラクタに対する型クラスがあると様々な抽象を表現することができて、例えば先ほどの Mappable（というか Functor）の他にも Monad というのがあります。Monadは手続きを抽象化した構造で、Haskell にような純粋なプログラミング言語で副作用などの文脈をもった計算（手続き）を構造として扱ううえで欠かせないものとなっています。[2]にモナドを紹介している節があるのでそれを見るとふむふむという感じになります。