OCaml

ML（Meta Language）の開発

1970年代から1980年代にかけて、イギリスの計算機科学者でありチューリング賞受賞者のロビン・ミルナーは、エディンバラ大学の計算機科学基礎研究所（英語版）で研究を行っていた^[8][9]。ミルナーらは定理証明器の開発に取り組んでおり、これらは歴史的にLispなどの言語で開発されていた。ミルナーは、定理証明器が証明ではないものを組み合わせることで証明が有効であると主張しようとする問題に繰り返し直面した^[9]。その結果、彼は自身の計算可能関数ロジック（英語版）（LCF）のためのメタ言語（meta language）を開発することになった。これは多相型システムによって、プログラマが有効な証明のみを構築できるようにする言語であった^[10]。MLは、異なるマシンでのLCFの使用を簡素化するためにコンパイラへと変えられ、1980年代までにはそれ自体が完全なシステムとなった^[10]。MLは最終的にOCamlの基盤として機能することになる。

1980年代初頭、フランス国立情報学自動制御研究所（Inria）のFormelチームがMLに関心を持つきっかけとなるいくつかの進展があった。オックスフォード大学の研究教授であったルカ・カルデリ（英語版）は、自身の「関数型抽象機械（functional abstract machine）」を使用してMLのより高速な実装を開発し、ロビン・ミルナーは様々な実装間の相違を避けるためにMLの新しい定義を提案した。同時に、パリ・ディドロ大学（現・パリ・シテ大学）の上級研究員であったピエール＝ルイ・キュリアン（Pierre-Louis Curien）は圏論的コンビネータ（categorical combinators）の計算を開発し、それをラムダ計算に結びつけた。これにより「圏論的抽象機械（英語版）（CAM）」の定義が導かれた。パリ・ディドロ大学の研究者ガイ・クジノー（Guy Cousineau）は、これがMLのコンパイル手法として適用できることを認識した^[11]。

初期の実装

Caml（英語版）は、ジェラール・ユエ（英語版）率いるInriaのFormelチームによって最初に設計および開発された。Camlの最初の実装は1987年に作成され、1992年までさらに開発が続けられた。開発はAscánder Suárezによって主導されていたが、1988年に彼が去った後はピエール・ワイスとミシェル・モーニー（Michel Mauny）が開発を引き継いだ^[11]。

Caml Light

1990年から1991年にかけて、グザヴィエ・ルロワはC言語で書かれたバイトコードインタプリタに基づくCaml（英語版）の新しい実装を設計した。これに加えて、ダミアン・ドリジェ（英語版）はこの実装のために、シーケンシャルなガベージコレクションとして知られるメモリ管理システムを記述した^[10]。Caml Light（英語版）として知られるこの新しい実装は、古いCamlの実装を置き換え、小型のデスクトップマシンで動作した^[11]。その後数年で、ミシェル・モーニーの構文操作ツールなどのライブラリが登場し、教育や研究チームでのCamlの使用を促進するのに役立った^[10]。

Caml Special Light

1995年、グザヴィエ・ルロワはCaml（英語版）の改良版であるCaml Special Lightをリリースした^[11]。バイトコードコンパイラに最適化されたネイティブコードコンパイラが追加され、これによりパフォーマンスがC++などの主要言語と同等レベルにまで大幅に向上した^[10][11]。また、ルロワはStandard MLのモジュールシステムに触発された高水準モジュールシステムを設計した。これにより、抽象化とパラメータ化のための強力な機能が提供され、より大規模なプログラムの構築が容易になった^[10]。

Objective Caml

ディディエ・レミとジェローム・ヴイヨンは、オブジェクトとクラスのための表現力豊かな型システムを設計し、それがCaml Special Lightに統合された。これにより、1996年に初めてリリースされたObjective Caml言語が誕生し、後に2011年にOCamlへと改名された。このオブジェクトシステムは、C++やJavaなどの言語では型の不健全性（unsoundness）を引き起こしたり、実行時のチェックを必要としたりするような、普及している多くのオブジェクト指向のイディオムを、静的かつ型安全な方法でサポートしていた。2000年にジャック・ガリグ（Jacques Garrigue）は、多相メソッド、バリアント、ラベル付きおよびオプションの引数など、複数の新機能でObjective Camlを拡張した^[10][11]。

継続的な開発

増大するOCamlの商業的および学術的なコードベースをサポートするため、過去20年間にわたり言語の改善が段階的に追加されてきた^[10]。2012年のOCaml 4.0のリリースでは、言語の柔軟性を高めるために、一般化代数的データ型（GADT）とファーストクラス・モジュールが追加された^[10]。2022年のOCaml 5.0.0リリース^[12]は言語ランタイムの完全な書き直しであり、グローバル・インタプリタ・ロック（英語版）（グローバルGCロック）が削除され、限定継続（delimited continuations）を介したエフェクトシステム（英語版）（effect handlers）が追加された。これらの変更により、それぞれ共有メモリ並列処理と、カラーブラインド並行性（color-blind concurrency）のサポートが可能になる。

OCamlの開発は2005年までInriaのCristalチーム内で行われていたが、その後Galliumチームに引き継がれた^[13]。続いて、2019年にGalliumはCambiumチームに引き継がれた^[14][15]。2023年現在、コンパイラ配布のコア開発者は様々な組織からの23名で構成されており^[16]、幅広いOCamlツーリングおよびパッケージング・エコシステムには41名の開発者がいる^[17]。2023年、OCamlコンパイラはSIGPLAN（英語版）（ACM SIGPLAN Programming Languages Software Award）を受賞した。

Caml Light

前述の通り、OCamlの前身である実装。正確には名前だけでなく、新しい手法で再実装されたものであり、OCamlよりCaml Lightのほうが古くからある。現在もCaml Lightとして配布され続けている。

MinCaml

MinCamlは、ペンシルベニア大学（当時）の住井英二郎がOCamlで実装した、Caml似のMLの小型版である。同作者により、コンパイラがOCaml自身で書かれている。MinCamlは、2004年度の未踏ソフトウェア創造事業に採択された。

MinCamlコンパイラは教育目的での利用を主眼としている。わずか2000行前後のコードで書かれており、実装されている機能はMLのサブセットである。バックエンドはSPARCとx86に対応しており、ある程度の学習をすれば比較的容易に改造を行うことができる（有志によってPowerPC用に出力できるバージョンも提供されている。バックエンドをLLVMに置き換えた例も報告されている^[20]）。実際に東京大学理学部情報科学科などで教育目的に利用され、国内におけるOCamlおよび関数型言語の普及と理解に一定の役割を果たしている^[要出典]。

• 速攻MinCamlコンパイラ概説 - MinCamlの配布・解説（SourceForge.net）

Moscow ML

CamlやOCamlのような方言ではなく、SML（Standard ML）の処理系の実装にCaml Lightを利用している。完全なSMLを実装する。

その他

OchaCamlなど、研究用の改造のベースとして、規模の大きくなったOCamlではなくCaml（Caml Light）を利用する例がみられる。

MetaOCaml

MetaOCaml^[21] は、実行中に新しい機械語コードのインクリメンタルなコンパイルを可能にする、OCamlの多段階プログラミング（英語版）拡張である。いくつかの状況下では、多段階プログラミングを使用することで大幅な高速化が可能になる。これは、通常のコンパイル時よりも実行時の方が処理するデータに関する詳細な情報が得られるため、インクリメンタルコンパイラが条件チェックなどの多くのケースを最適化して排除できるためである。

例として、コンパイル時に何らかの冪乗関数x -> x^nが頻繁に必要になることがわかっているが、nの値はランタイム時にしかわからない場合、MetaOCamlでは2段階の冪乗関数を使用できる。

let rec power n x =
  if n = 0
  then .<1>.
  else
    if even n
    then sqr (power (n/2) x)
    else .<.~x *. .~(power (n - 1) x)>.

実行時にnが判明するとすぐに、特化された非常に高速な冪乗関数を作成できる。

.<fun x -> .~(power 5 .<x>.)>.

その結果、以下のようになる。

fun x_1 -> (x_1 *
    let y_3 = 
        let y_2 = (x_1 * 1)
        in (y_2 * y_2)
    in (y_3 * y_3))

新しい関数は自動的にコンパイルされる。

その他の派生言語

• F# - OCamlをベースにした.NETフレームワーク言語。
• JoCaml（英語版） - 並行および分散プログラムを開発するための構造を統合した言語。
• Reason（英語版） - Facebookで作成された、ネイティブコードとJavaScriptの両方にコンパイルできる代替のOCaml構文およびツールチェーン。

Hello World

Hello world の例を示す。以下のプログラムhello.mlは、

print_endline "Hello world!";;

直接実行することができる。

$ ocaml hello.ml

バイトコード実行可能ファイルにコンパイルする場合：

$ ocamlc hello.ml -o hello

最適化されたネイティブコード実行可能ファイルにコンパイルする場合：

$ ocamlopt hello.ml -o hello

実行結果：

$ ./hello
Hello world!
$

ocamlcへの最初の引数である "hello.ml" はコンパイルするソースファイルを指定し、"-o hello" フラグは出力ファイルを指定する^[23]。

Option型

OCamlにおけるoption型コンストラクタは、HaskellのMaybe型に似ており、与えられたデータ型を拡張して、そのデータ型の何らかの値（Some）を返すか、何も返さない（None）ようにする^[24]。これは値が存在するかしないかを表現するために使用される。

# Some 42;;
- : int option = Some 42
# None;;
- : 'a option = None

以下の関数は、オプションの内部に整数があればそれを抽出し文字列に変換し、なければ空の文字列を返す例である。

let extract o =
  match o with
  | Some i -> string_of_int i
  | None -> "";;

# extract (Some 42);;
- : string = "42"
# extract None;;
- : string = ""

リストの合計

リストはOCamlの基本的なデータ型の1つである。以下のコード例では、整数のリストを引数に取る再帰関数 sum を定義している。関数が再帰的であることを示すキーワードrecに注目してほしい。この関数は与えられた整数のリストを再帰的に反復処理し、要素の合計を提供する。matchステートメントはC言語のswitch文と似ている部分があるが、はるかに汎用性が高い。

let rec sum integers =                   (* キーワード rec は「再帰的」を意味する *)
  match integers with
  | [] -> 0                              (* integers が空のリスト [] の場合は 0 を返す *)
  | first :: rest -> first + sum rest;;  (* integers が空でないリストの場合は再帰呼び出し。
                                            first はリストの最初の要素、
                                            rest は残りの要素のリスト（[] の場合もある） *)

  # sum [1;2;3;4;5];;
  - : int = 15

別の方法として、リストに対して機能する標準的なfold関数（英語版）を使用することもできる。

let sum integers =
  List.fold_left (fun accumulator x -> accumulator + x) 0 integers;;

  # sum [1;2;3;4;5];;
  - : int = 15

無名関数は単なる+演算子の適用であるため、以下のように短縮できる。

let sum integers =
  List.fold_left (+) 0 integers

さらに、部分適用（英語版）を利用することでリストの引数を省略することもできる。

let sum =
  List.fold_left (+) 0

クイックソート

OCamlは再帰的なアルゴリズムを簡潔に表現するのに適している。以下のコード例は、リストを昇順にソートするクイックソートに似たアルゴリズムを実装している。Haskellなどにも見られるパターンマッチの機能がここでも使われている。

 let rec qsort = function
   | [] -> []
   | pivot :: rest ->
     let is_less x = x < pivot in
     let left, right = List.partition is_less rest in
     qsort left @ [pivot] @ qsort right

または、>=演算子の部分適用を使用する。

 let rec qsort = function
   | [] -> []
   | pivot :: rest ->
     let is_less = (>=) pivot in
     let left, right = List.partition is_less rest in
     qsort left @ [pivot] @ qsort right

誕生日のパラドックス

以下のプログラムは、部屋にいる人全員の誕生日が完全に異なる確率が50%未満になる最小の人数を計算する（誕生日のパラドックス。1人の場合は確率が365/365（100%）、2人の場合は364/365、3人の場合は364/365 × 363/365…となる）（答え = 23）。

let year_size = 365.

let rec birthday_paradox prob people =
  let prob = (year_size -. float people) /. year_size *. prob  in
  if prob < 0.5 then
    Printf.printf "answer = %d\n" (people+1)
  else
    birthday_paradox prob (people+1)
;;

birthday_paradox 1.0 1

チャーチ数

以下は、ラムダ計算の教科書などに見られる、自然数のチャーチ符号化（英語版）のコード例である。後者（succ）および加算（add）が定義されている。チャーチ数nは、関数fと値xを受け取り、xに正確にn回fを適用する高階関数である。チャーチ数を関数値から文字列に変換するために、入力に文字列"S"を先頭に追加する関数と、定数文字列"0"を渡す。以下の例では、5のチャーチ数として"SSSSS0"を出力する。

let zero f x = x
let succ n f x = f (n f x)
let one = succ zero
let two = succ (succ zero)
let add n1 n2 f x = n1 f (n2 f x)
let to_string n = n (fun k -> "S" ^ k) "0"
let church_5 = to_string (add (succ two) two)
;;
print_endline church_5;

任意精度階乗関数（ライブラリ）

様々なライブラリにOCamlから直接アクセスできる。たとえば、OCamlには任意精度演算のための組み込みライブラリがある。階乗関数は非常に急速に増加するため、すぐにマシン精度の数値（通常は32ビットまたは64ビット）をオーバーフローする。したがって、階乗は任意精度演算の適切な候補となる。

OCamlでは、Numモジュール（現在はZArithモジュールに置き換えられている）が任意精度演算を提供しており、次のように入力することで実行中のトップレベルに読み込むことができる。

# #use "topfind";;
# #require "num";;
# open Num;;

すると、任意精度数値演算子=/, */, -/を使用して階乗関数を記述できる。

# let rec fact n =
    if n =/ Int 0 then Int 1 else n */ fact(n -/ Int 1);;
val fact : Num.num -> Num.num = <fun>

この関数は、120!のようなはるかに大きな階乗を計算できる。

# string_of_num (fact (Int 120));;
- : string =
"6689502913449127057588118054090372586752746333138029810295671352301633
55724496298936687416527198498130815763789321409055253440858940812185989
8481114389650005964960521256960000000000000000000000000000"

三角形（グラフィックス）

以下のプログラムは、OpenGLを使用して2Dで回転する三角形を描画する。

let () =
  ignore (Glut.init Sys.argv);
  Glut.initDisplayMode ~double_buffer:true ();
  ignore (Glut.createWindow ~title:"OpenGL Demo");
  let angle t = 10. *. t *. t in
  let render () =
    GlClear.clear [ `color ];
    GlMat.load_identity ();
    GlMat.rotate ~angle: (angle (Sys.time ())) ~z:1. ();
    GlDraw.begins `triangles;
    List.iter GlDraw.vertex2 [-1., -1.; 0., 1.; 1., -1.];
    GlDraw.ends ();
    Glut.swapBuffers () in
  GlMat.mode `modelview;
  Glut.displayFunc ~cb:render;
  Glut.idleFunc ~cb:(Some Glut.postRedisplay);
  Glut.mainLoop ()

OpenGLへのLablGLバインディングが必要である。その後、プログラムは以下のようにバイトコードにコンパイルできる。

$ ocamlc -I +lablGL lablglut.cma lablgl.cma simple.ml -o simple

ネイティブコードへのコンパイル：

$ ocamlopt -I +lablGL lablglut.cmxa lablgl.cmxa simple.ml -o simple

より簡単に、ocamlfindビルドコマンドを使用する場合：

$ ocamlfind opt simple.ml -package lablgl.glut -linkpkg -o simple

実行：

$ ./simple

OCamlでは、はるかに洗練された高性能な2Dおよび3Dグラフィカル・プログラムを開発できる。OpenGLとOCamlのおかげで、結果として得られるプログラムはクロスプラットフォームになり、変更を加えることなく多くの主要プラットフォームでコンパイルできる。

フィボナッチ数列

以下のコードは、入力された数値nのフィボナッチ数列を計算する。これには末尾再帰とパターンマッチングが使用されている。

let fib n =
  let rec fib_aux m a b =
    match m with
    | 0 -> a
    | _ -> fib_aux (m - 1) b (a + b)
  in fib_aux n 0 1

高階関数

関数は関数を入力として受け取り、結果として関数を返すことができる。たとえば、twiceを関数fに適用すると、引数にfを2回適用する関数が生成される。

let twice (f : 'a -> 'a) = fun (x : 'a) -> f (f x);;
let inc (x : int) : int = x + 1;;
let add2 = twice inc;;
let inc_str (x : string) : string = x ^ " " ^ x;;
let add_str = twice(inc_str);;

  # add2 98;;
  - : int = 100
  # add_str "Test";;
  - : string = "Test Test Test Test"

関数twiceは型変数'aを使用して、int->int関数だけでなく、型'aからそれ自身へのマッピングを行う任意の関数fに適用できることを示している。特に、twiceはそれ自身にさえ適用することができる。

  # let fourtimes f = (twice twice) f;;
  val fourtimes : ('a -> 'a) -> 'a -> 'a = <fun>
  # let add4 = fourtimes inc;;
  val add4 : int -> int = <fun>
  # add4 98;;
  - : int = 102