OCaml

$ ocaml        OCaml version 4.13.1#

# 1 + 2 * 3;;- : int = 7

print_endline "Hello World!"

$ ocamlc hello.ml -o hello

或者被编译成优化的本地代码可执行文件：

$ ocamlopt hello.ml -o hello

接着执行它：

$ ./helloHello World!

给ocamlc的第一个实际参数hello.ml，指定要编译的源文件而-o hello标志指定了输出文件。

很多数学函数，比如阶乘，可以很自然的表示为纯粹的函数形式：

let rec fact n =  if n=0 then 1 else n * fact(n - 1);;

这个函数可以使用模式匹配等价的写为：

let rec fact = function  | 0 -> 1  | n -> n * fact(n - 1);;

后者形式是阶乘作为递推关系的数学定义。

编译器将这个函数的类型推论为int -> int，意味着这个函数将int映射到int。例如，12!：

# fact 12;;- : int = 479001600

斐波那契序列

下列代码计算输入数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;;

生日问题

下列程序计算在一个屋子里面有完全唯一的生日概率小于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 = %dn" (people+1)  else    birthday_paradox prob (people+1);;

# birthday_paradox 1.0 1;;answer = 23- : unit = ()

合计整数列表

列表是OCaml中的基础数据类型之一。下面的代码例子定义递归函数sum，它接受一个实际参数integers，而它被假定为整数的列表。注意关键字rec指示了这个函数是递归的。这个函数递归的在给定整数列表之上进行迭代，并提供这些元素的一个总和。match语句类似于C的switch（英语：Switch statement）语句，但要更加一般性。

let rec sum integers =                   (* 关键字rec含义为递归。 *)  match integers with  |  -> 0                              (* 产生0，如果integers为空列表 。 *)  | first :: rest -> first + sum rest;;  (* 递归调用，如果integers是非空列表；                                            first是这个列表的第一个元素，                                            而rest是余下元素的列表，可能是。 *)

# sum ;;- : int = 15

另一种方式是对列表使用标准的fold高阶函数:

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

# sum ;;- : int = 15

因为匿名函数是简单的+算符应用，它可以简写为：

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

进一步的，还可以通过采用部分应用（英语：Partial application）省略列表实际参数：

let sum =  List.fold_left (+) 0

快速排序

OCaml自身可提供对递归算法的简介表达。下列代码例子实现了类似于以升序排序一个列表的quicksort的一个算法：

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

高阶函数

函数可以接受函数作为参数并且返回函数作为结果。例如，应用twice到函数f产生应用f到它的实际参数两次的一个函数：

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，来指示它可以应用于映射一个类型'a到自身的任何f，而非只应用于int->int函数。特别是，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

邱奇数

下列代码定义自然数的邱奇编码，具有后继（succ）和加法（add）。邱奇数n是接受一个函数f和一个值x的一个高阶函数，它应用f到x精确的n次：

let zero f x = xlet succ n f x = f (n f x)let one = succ zerolet 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";;

为了将一个邱奇数从函数值转换成一个字符串，这里把它传递给向其输入和常量字符串"0"前置上字符串"S"的函数to_string：

# let _ = to_string (add (succ two) two);;- : string = "SSSSS0"

对象例子

在OCaml中对象，通过它们的方法的名字和类型，按结构来确定类型。对象可以直接创建（立即对象），而不用通过有名称的类。例如：

# let x =    object      val mutable x = 5      method get_x = x      method set_x y = x <- y    end;;val x : < get_x : int; set_x : int -> unit > = <obj>

这里OCaml交互式运行时间系统打印出这个对象的推论类型。它的类型< get_x : int; set_x : int -> unit >，只由它的方法来定义。换句话说，x的类型由方法类型get_x : int和set_x : int -> unit而非任何名字来定义。类只充当创建对象的函数，例如上例中的对象可以用类来定义，并接着用new算符来创建：

# class simple_cls =    object (self)      val mutable x = 5      method get_x = x      method set_x y = x <- y    end;;  let x = new simple_cls;;

要定义有相同的方法和方法类型的另一个对象：

# let y =    object      method get_x = 2      method set_x y = Printf.printf "%dn" y    end;;val y : < get_x : int; set_x : int -> unit > = <obj>

OCaml将它们视为有相同的类型。例如，等式算符被确定类型为只接受有相同类型的两个值：

# x = y;;- : bool = false

所有尽管它们有不同的值，却必定是相同类型的，否则连类型检查都不会做完。这展示了类型等价是结构性的。可以定义调用一个方法的函数：

# let set_to_10 a = a#set_x 10;;val set_to_10 : < set_x : int -> 'a; .. > -> 'a = <fun>

第一个实际参数的推论类型< set_x : int -> 'a; .. >是值得关注的。..意味着第一个实际参数，可以是有接受一个int作为实际参数的set_x方法的任何对象。所以它可以用在对象x之上：

# set_to_10 x;;- : unit = ()

另一个对象可以碰巧有这个方法和方法类型；其他方法是无关紧要的：

# let z =    object      method blahblah = 2.5      method set_x y = Printf.printf "%dn" y    end;;val z : < blahblah : float; set_x : int -> unit > = <obj>

set_to_10函数对它也有效：

# set_to_10 z;;10- : unit = ()

这展示了对于事物比如方法调用的兼容性是由结构来确定的。下面为只有一个get_x方法而没有其他方法的对象定义一个类型同义词（synonym）：

# type simpler_obj = < get_x : int >;;type simpler_obj = < get_x : int >

对象x不是这个类型的；但在结构上x是这个类型的一个子类型，因为x包含它的方法的一个超集。所以x可以强制（coerce）成这个类型：

# (x :> simpler_obj);;- : simpler_obj = <obj># (x :> simpler_obj)#get_x;;- : int = 10

但是对象z不行，因为它不是一个结构子类型：

# (z :> simpler_obj);;Error: Type < blahblah : float; set_x : int -> unit > is not a subtype of         simpler_obj = < get_x : int >        The first object type has no method get_x

这展示了拓宽强制的兼容性是结构性的。

可以从OCaml访问各种各样的库。比如，OCaml有内建的任意精度算术。由于阶乘函数增长得非常迅速，会很快溢出机器精度的整数。因此阶乘很适合选用任意精度算术。

在OCaml中，Num模块（现在被ZArith所取代）提供了任意精度算术，比如在Ubuntu中安装它：sudo apt install libnum-ocaml-dev，它可以如下这样装载到运行中的顶层中：

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

阶乘函数可以使用任意精度算符=/、*/和-/写为：

let rec fact n =  if n =/ Int 0 then Int 1 else n */ fact(n -/ Int 1);;

这个函数可以计算非常大的阶乘比如120!：

# string_of_num (fact (Int 120));;- : string ="6689502913449127057588118054090372586752746333138029810295671352301633557244962989366874165271984981308157637893214090552534408589408121859898481114389650005964960521256960000000000000000000000000000"

绘制图形例子

下列程序simple.ml使用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 ;    GlMat.load_identity ();    GlMat.rotate ~angle: (angle (Sys.time ())) ~z:1. ();    GlDraw.begins `triangles;    List.iter GlDraw.vertex2 ;    GlDraw.ends ();    Glut.swapBuffers () in  GlMat.mode `modelview;  Glut.displayFunc ~cb:render;  Glut.idleFunc ~cb:(Some Glut.postRedisplay);  Glut.mainLoop ()

需要事先安装负责绑定到OpenGL的LablGL，比如在Ubuntu中安装它：sudo apt install liblablgl-ocaml-dev，这个程序可以如下这样编译成字节码：

$ 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，结果的程序可以跨平台编译而在主要平台上无需改动。