OCaml
関数

letバインディングを使用した関数の定義

値にletを使って名前を付けることができます：

# let a = 1;;
val a : int = 1 

同様の構文を使用して関数を定義することができます。引数の追加パラメータを提供するだけです。

# let add arg1 arg2 = arg1 + arg2;;
val add : int -> int -> int = <fun> 

これを次のように呼ぶことができます：

# add 1 2;;
- : int = 3 

そのような値を直接渡すことも、名前にバインドされた値を渡すこともできます。

# add a 2;;
- : int = 3 

私たちが何かを定義した後、インタプリタが私たちに与える行は、型シグネチャを持つオブジェクトの値です。我々はそれをにバインドされた単純な値与えたとき、それはして戻ってきました： a

val a : int = 1

これはaがintであり、その値が1あることを意味します。

関数の型シグネチャはもう少し複雑です：

val add : int -> int -> int = <fun> 

addの型シグネチャは、intと矢の束のようadd見えます。これは、2つの引数をとる関数は、実際には1つの引数を取るだけの関数ですが、次の引数を取る別の関数を返すためです。代わりに、次のように読むことができます：

val add : int -> (int -> int) = <fun>

これは、さまざまな種類の関数をオンザフライで作成したいときに便利です。たとえば、すべてに5を追加する関数は次のようになります。

# let add_five = add 5;;
val add_five : int -> int = <fun>
# add_five 5;;
- : int = 10
# add_five 10;;
- : int = 15 

functionキーワードの使用

functionキーワードは、関数の本体を定義すると自動的にパターンマッチングを行います。以下に従ってください。

# let foo = function
0 -> "zero"
| 1 -> "one"
| 2 -> "couple"
| 3 -> "few"
| _ -> "many";;
val foo : int -> bytes = <fun>

# foo 0;;
- : bytes = "zero"

# foo 3;;
- : bytes = "few"                                                                         

# foo 10;;
- : bytes = "many"                                                                        

# let bar = function
"a" | "i" | "e" | "o" | "u" -> "vowel"
| _ -> "consonant";;
val bar : bytes -> bytes = <fun>                                                          

# bar "a";;
- : bytes = "vowel"

# bar "k";;
- : bytes = "consonant" 

匿名関数

関数は通常の値なので、名前を持たない関数を作成するための便利な構文があります：

List.map (fun x -> x * x) [1; 2; 3; 4]
(* - : int list = [1; 4; 9; 16] *)

これは便利なことです。そうでなければ関数を最初に指定しなければなりません（ letを参照）。

let square x = x * x
(* val square : int -> int = <fun> *)

List.map square [1; 2; 3; 4]
(* - : int list = [1; 4; 9; 16] *)

再帰的および相互再帰的関数

recキーワードで関数を再帰的に定義することができるので、自身を呼び出すことができます。

# let rec fact n = match n with
    | 0 -> 1
    | n -> n * fact (n - 1);;

val fact : int -> int = <fun>

# fact 0;;
- : int = 1
# fact 4;;
- : int = 24

また、 andキーワードを使って相互に再帰的な関数を定義することもできます。これにより、互いに呼び出すことができます。

# let rec first x = match x with
    | 1 -> 1
    | x -> second (x mod 10)

  and second x = first (x + 1);;

val first : int -> int = <fun>
val second : int -> int = <fun>

# first 20;;
- : int = 1
# first 12345;;
- : int = 1

2番目の関数にreqキーワードがないことに注目してください。