OCaml
Funktionen höherer Ordnung

Syntax

• val (|>) : 'a -> ('a -> 'b) -> 'b
• val (@@) : ('a -> 'b) -> 'a -> 'b

Generische Algorithmen

Funktionen höherer Ordnung können verwendet werden, um generische Algorithmen zu implementieren, wodurch die Verantwortung für die Bereitstellung endgültiger Details an den Benutzer aufgegeben wird. Beispielsweise erwartet List.sort eine Vergleichsfunktion, mit der verschiedene Sortierweisen implementiert werden können. Hier setzen wir die Groß- und Kleinschreibung von Strings ein:

let string_case_insensitive_sort lst =
  let case_insensitive_compare a b =
    String.compare (String.lowercase a) (String.lowercase b)
  in
  List.sort case_insensitive_compare lst

In der Standardbibliothek gibt es eine umfangreiche Liste von Funktionen höherer Ordnung, insbesondere im Modul List , z. B. List.fold_left und List.sort . Weitergehende Beispiele finden Sie in Bibliotheken von Drittanbietern. Ein gutes Beispiel ist das simulierte Tempern in ocaml-gsl . Das simulierte Tempern ist eine generische Optimierungsprozedur, die durch eine Funktion zur Untersuchung der Zustandsgruppe des Problems und eine Fehlerfunktion (hier als Energiefunktion bezeichnet) parametrisiert wird.

Benutzer, die mit C ++ vertraut sind, können dies mit dem Strategiemuster vergleichen.

Entsorgen Sie Systemressourcen auch dann, wenn eine Ausnahme ausgelöst wird

Funktionen höherer Ordnung können verwendet werden, um sicherzustellen, dass Systemressourcen auch dann zur Verfügung stehen, wenn eine Behandlung eine Ausnahme auslöst. Das von with_output_file verwendete with_output_file ermöglicht eine saubere Trennung der Bedenken: Die übergeordnete Funktion with_output_file sorgt für die Verwaltung der an Dateimanipulation gebundenen Systemressourcen, während die Behandlung f nur den Ausgabekanal belegt.

let with_output_file path f =
  let c = open_out path in
  try
    let answer = f c in
    (close_out c; answer)
  with exn -> (close_out c; raise exn)

Verwenden Sie diese Funktion höherer Ordnung, um eine Funktion zu implementieren, die eine Zeichenfolge in eine Datei schreibt:

let save_string path s =
  (with_output_file path) (fun c -> output_string c s)

Mit erweiterten Funktionen als fun c -> output_string cs können komplexere Werte fun c -> output_string cs werden. Siehe beispielsweise das Marshal- Modul in der Standardbibliothek oder die Yojson- Bibliothek von Martin Jambon.

Kompositionsoperatoren

Zwei nützliche Funktionen höherer Ordnung sind die Binary - Anwendung ( @@ ) und Reverse-Anwendung oder "pipe" ( |> ) Operatoren. Obwohl sie seit 4.01 als Primitive verfügbar sind, kann es dennoch sinnvoll sein, sie hier zu definieren:

let (|>) x f = f x
let (@@) f x = f x

Betrachten Sie das Problem des Inkrementierens des Quadrats von 3. Eine Möglichkeit, diese Berechnung auszudrücken, ist folgende:

(* 1 -- Using parentheses *)
succ (square 3)
(* - : int = 10 *)

(* where `square` is defined as: *)
let square x = x * x

Beachten Sie, dass wir succ square 3 nicht einfach succ square 3 da dies aufgrund der succ square 3 -Assoziativität auf das bedeutungslose (succ square) 3 reduziert würde. Mit der Anwendung ( @@ ) können wir das ohne die Klammern ausdrücken:

(* 2 -- Using the application operator *)
succ @@ square 3
(* - : int = 10 *)

Beachten Sie, wie die letzte succ Operation (nämlich succ ) zuerst im Ausdruck auftritt? Der Umkehranwendungsoperator ( |> ) ermöglicht es uns, dies umzukehren:

(* 3 -- Using the reverse-application operator *)
3 |> square |> succ
(* - : int = 10 *)

Die Zahl 3 wird nun durch das square und dann über den succ , im Gegensatz zu dem square , um ein Ergebnis zu erhalten, auf das der succ angewendet wird.