OCaml
functies

Een functie definiëren met een let Binding

Waarden kunnen namen krijgen met let :

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

U kunt een vergelijkbare syntaxis gebruiken om een functie te definiëren. Geef gewoon aanvullende parameters op voor de argumenten.

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

We kunnen het zo noemen:

# add 1 2;;
- : int = 3 

We kunnen waarden direct zo doorgeven, of we kunnen waarden doorgeven die aan namen zijn gebonden:

# add a 2;;
- : int = 3 

De lijn die de tolk ons geeft nadat we iets definiëren, is de waarde van het object met zijn typeaanduiding. Toen we het een eenvoudige waarde gaven die gebonden was aan a , kwam het terug met:

val a : int = 1

Wat betekent dat a een int is en dat de waarde 1 .

De typeaanduiding van onze functie is iets gecompliceerder:

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

De typeaanduiding van add ziet eruit als een stel ints en pijlen. Dit komt omdat een functie die twee argumenten aanneemt, eigenlijk een functie is die slechts één argument aanneemt, maar een andere functie retourneert die het volgende argument aanneemt. Je zou het in plaats daarvan zo kunnen lezen:

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

Dit is handig als we snel verschillende soorten functies willen maken. Bijvoorbeeld een functie die 5 aan alles toevoegt:

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

Het functietrefwoord gebruiken

Het function automatisch overeen met het patroon wanneer u het hoofdgedeelte van uw functie definieert. Bekijk het hieronder:

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

Anonieme functies

Aangezien functies gewone waarden zijn, is er een handige syntaxis voor het maken van functies zonder namen:

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

Dit is handig, omdat we anders de functie eerst een naam zouden moeten geven (zie laten ) om deze te kunnen gebruiken:

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

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

Recursieve en wederzijds recursieve functies

U kunt een functie definiëren om recursief te zijn met het sleutelwoord rec , zodat deze zichzelf kan aanroepen.

# 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

U kunt ook onderling recursieve functies definiëren met de and trefwoord, zodat ze elkaar kunnen bellen.

# 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

Merk op dat de tweede functie niet het req sleutelwoord heeft.