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와 화살표의 뭉치처럼 보입니다. 이것은 두 개의 인수를 취하는 함수가 실제로 하나의 인수를 취하는 함수이지만 다음 인수를 취하는 다른 함수를 반환하기 때문입니다. 대신 다음과 같이 읽을 수 있습니다.

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 키워드는 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

두 번째 함수에는 req 키워드가 없습니다.