OCaml
Les fonctions

Définir une fonction avec une let

Les valeurs peuvent être des noms en utilisant let :

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

Vous pouvez utiliser une syntaxe similaire pour définir une fonction. Fournissez simplement des paramètres supplémentaires pour les arguments.

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

Nous pouvons l'appeler comme ceci:

# add 1 2;;
- : int = 3 

On peut passer des valeurs directement comme ça, ou on peut passer des valeurs liées aux noms:

# add a 2;;
- : int = 3 

La ligne que l'interprète nous donne après avoir défini quelque chose est la valeur de l'objet avec sa signature de type. Lorsque nous lui avons donné une valeur simple liée à a , il est revenu avec:

val a : int = 1

Ce qui signifie a est un int et sa valeur est 1 .

La signature de type de notre fonction est un peu plus compliquée:

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

Le type signature de add ressemble à un tas d'ints et de flèches. En effet, une fonction qui prend deux arguments est en fait une fonction qui ne prend qu'un argument, mais retourne une autre fonction qui prend l’argument suivant. Vous pourriez plutôt le lire comme ceci:

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

Ceci est utile lorsque vous voulez créer différentes sortes de fonctions à la volée. Par exemple, une fonction qui ajoute 5 à tout:

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

Utiliser le mot-clé function

La function mot - clé est automatiquement mise en correspondance de modèle lorsque vous définissez le corps de votre fonction. Observez-le ci-dessous:

# 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" 

Fonctions anonymes

Comme les fonctions sont des valeurs ordinaires, il existe une syntaxe pratique pour créer des fonctions sans noms:

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

Ceci est pratique, car il faudrait d'abord nommer la fonction (voir let ) pour pouvoir l'utiliser:

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

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

Fonctions récursives et mutuellement récursives

Vous pouvez définir une fonction pour qu'elle soit récursive avec le mot-clé rec , afin qu'il puisse s'appeler.

# 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

Vous pouvez également définir des fonctions mutuellement récursives avec le mot and clé and , afin qu'elles puissent s'appeler.

# 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

Notez que la deuxième fonction n'a pas le mot clé req .