OCaml
Listenverarbeitung

List.Map

List.map hat die Signatur ('a -> 'b) -> 'a list -> 'b list die auf Englisch eine Funktion ist, die eine Funktion übernimmt (wir nennen diese Abbildungsfunktion) von einem Typ (nämlich 'a ) auf einen anderen Typ (nämlich 'b ) und eine Liste des ersten Typs. Die Funktion gibt eine Liste des zweiten Typs zurück, bei der jedes Element das Ergebnis des Aufrufs der Zuordnungsfunktion für ein Element der ersten Liste ist.

List.map string_of_int [ 1; 2; 3; 4 ]
#- [ "1"; "2"; "3"; "4" ] : string list

Die Typen 'a und 'b müssen nicht unterschiedlich sein. Zum Beispiel können wir Zahlen genauso einfach ihren Quadraten zuordnen.

let square x = x * x in
List.map square [ 1; 2; 3; 4 ]
#- [ 1; 4; 9; 16 ] : int list

Daten in einer Liste zusammenfassen

Die Funktionen List.fold_left und List.fold_right Funktionen höherer Ordnung , die die äußere Logik der List.fold_right implementieren. Das Aggregieren einer Liste, manchmal auch als Reduzieren einer Liste bezeichnet, bedeutet, einen Wert zu berechnen, der aus der sequentiellen Prüfung aller Elemente in dieser Liste abgeleitet wird.

Die Dokumentation des List-Moduls gibt dies an

• List.fold_left fa [b1; ...; bn] ist f (... (f (fa b1) b2) ...) bn .
• List.fold_right f [a1; ...; an] b ist f a1 (f a2 (... (f an b) ...)) . (Diese letztere Funktion ist nicht rekursiv.)

Im einfachen Englisch List.fold_left fa [b1; ...; bn] läuft durch die Liste [b1; ...; bn] anfänglich auf Spur eines Akkumulators halten a : jedes Mal , wenn wir ein Element in der Liste zu sehen, verwenden wir f den Wert des Speichers zu aktualisieren, und wenn wir fertig sind, der Speicher ist der letzte Wert unserer Berechnung. Die Funktion List.fold_right ist ähnlich.

Hier einige praktische Beispiele:

Berechnen Sie die Gesamtsumme einer Liste von Zahlen

List.fold_left ( + ) 0 lst

Berechnen Sie den Durchschnitt einer Liste von Floats

let average lst =
  let (sum, n) =
    List.fold_left (fun (sum, n) x -> (sum +. x, n + 1)) (0.0, 0) lst
  in
  sum /. (float_of_int n)

Implementieren Sie die grundlegende Listenverarbeitung erneut

Die Funktionen List.fold_left und List.fold_right sind so allgemein, dass sie verwendet werden können, um fast alle anderen Funktionen des List.fold_right zu implementieren:

let list_length lst = (* Alternative implementation to List.length *)
  List.fold_left ( + ) 0 lst

let list_filter predicate lst = (* Alternative implementation to List.filter *)
  List.fold_right (fun a b -> if predicate a then a :: b else b) lst []

Es ist sogar möglich , die neu zu implementieren List.iter Funktion, denken Sie daran , dass () der globale Zustand des Programms ist es, diesen Code als ein weiteres Beispiel der Liste Aggregation zu interpretieren:

let list_iter f lst = (* Alternation implementation to List.iter *)
  List.fold_left (fun () b -> f b) () lst

Diese Beispiele sind als Lernmaterial gedacht, diese Implementierungen haben gegenüber den entsprechenden Funktionen aus der Standardbibliothek keine Vorteile.