功能

功能

使用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关键字。