功能
使用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"
使用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和箭头。这是因为带有两个参数的函数实际上是一个函数，它只接受一个参数，但返回另一个接受下一个参数的函数。你可以这样读它：
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
匿名函数
由于函数是普通值，因此可以使用方便的语法创建没有名称的函数：
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
请注意，第二个函数没有req关键字。