Suche…
Definieren einer Funktion mit einer Let-Bindung
Werte können mit let :
# let a = 1;;
val a : int = 1
Sie können eine ähnliche Syntax verwenden, um eine Funktion zu definieren. Geben Sie einfach zusätzliche Parameter für die Argumente an.
# let add arg1 arg2 = arg1 + arg2;;
val add : int -> int -> int = <fun>
Wir können es so nennen:
# add 1 2;;
- : int = 3
Wir können Werte direkt so übergeben oder an Namen gebundene Werte übergeben:
# add a 2;;
- : int = 3
Die Zeile, die der Interpreter uns gibt, nachdem wir etwas definiert haben, ist der Wert des Objekts mit seiner Typunterschrift. Wenn wir es einen einfachen Wert gab gebunden a , kam es zurück mit:
val a : int = 1
Was bedeutet a ist ein int , und sein Wert ist 1 .
Die Typensignatur unserer Funktion ist etwas komplizierter:
val add : int -> int -> int = <fun>
Die Typensignatur von add sieht aus wie eine Menge Ints und Pfeile. Dies liegt daran, dass eine Funktion, die zwei Argumente verwendet, tatsächlich eine Funktion ist, die nur ein Argument akzeptiert, aber eine andere Funktion zurückgibt, die das nächste Argument übernimmt. Sie könnten es stattdessen so lesen:
val add : int -> (int -> int) = <fun>
Dies ist nützlich, wenn Sie verschiedene Funktionen im laufenden Betrieb erstellen möchten. Zum Beispiel eine Funktion, die 5 zu allem hinzufügt:
# let add_five = add 5;;
val add_five : int -> int = <fun>
# add_five 5;;
- : int = 10
# add_five 10;;
- : int = 15
Verwenden Sie das Funktionsschlüsselwort
Das Schlüsselwort der function verfügt automatisch über eine Musterübereinstimmung, wenn Sie den Körper Ihrer Funktion definieren. Beachten Sie es unten:
# 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"
Anonyme Funktionen
Da es sich bei Funktionen um gewöhnliche Werte handelt, gibt es eine praktische Syntax zum Erstellen von Funktionen ohne Namen:
List.map (fun x -> x * x) [1; 2; 3; 4]
(* - : int list = [1; 4; 9; 16] *)
Das ist praktisch, da wir sonst die Funktion zuerst benennen müssen (siehe let ), um sie verwenden zu können:
let square x = x * x
(* val square : int -> int = <fun> *)
List.map square [1; 2; 3; 4]
(* - : int list = [1; 4; 9; 16] *)
Rekursive und gegenseitig rekursive Funktionen
Sie können eine Funktion mit dem Schlüsselwort rec als rekursiv definieren, damit sie sich selbst aufrufen kann.
# 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
Sie können auch gegenseitig rekursive Funktionen mit dem Schlüsselwort and , damit sie sich gegenseitig aufrufen können.
# 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
Beachten Sie, dass die zweite Funktion nicht das Schlüsselwort req .