OCaml
Funciones

Definiendo una función con un enlace let

A los valores se les puede dar nombres usando let :

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

Puedes usar una sintaxis similar para definir una función. Simplemente proporcione parámetros adicionales para los argumentos.

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

Podemos llamarlo así:

# add 1 2;;
- : int = 3 

Podemos pasar valores directamente de esa manera, o podemos pasar valores vinculados a nombres:

# add a 2;;
- : int = 3 

La línea que nos da el intérprete después de definir algo es el valor del objeto con su tipo de firma. Cuando le dimos un valor simple vinculado a a , regresó con:

val a : int = 1

Lo que significa que a es un int , y su valor es 1 .

La firma tipo de nuestra función es un poco más complicada:

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

El tipo de firma de add ve como un manojo de flechas y flechas. Esto se debe a que una función que toma dos argumentos es en realidad una función que solo toma un argumento, pero devuelve otra función que toma el siguiente argumento. En su lugar, podrías leerlo así:

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

Esto es útil cuando queremos crear diferentes tipos de funciones sobre la marcha. Por ejemplo, una función que agrega 5 a todo:

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

Usando la palabra clave de la función

La palabra clave de function tiene una coincidencia de patrón automáticamente cuando define el cuerpo de su función. Obsérvalo a continuación:

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

Funciones anonimas

Dado que las funciones son valores ordinarios, hay una sintaxis conveniente para crear funciones sin nombres:

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

Esto es útil, ya que de otro modo tendríamos que nombrar la función primero (ver let ) para poder usarla:

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

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

Funciones recursivas y recursivas mutuas

Puede definir una función para que sea recursiva con la palabra clave rec , para que pueda llamarse a sí misma.

# 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

También puede definir funciones recursivas entre sí con la palabra clave and , para que puedan llamarse entre sí.

# 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

Observe que la segunda función no tiene la palabra clave req .