OCaml
Lijstverwerking

List.Map

List.map heeft de handtekening ('a -> 'b) -> 'a list -> 'b list die in het Engels een functie is die een functie (we noemen dit de toewijzingsfunctie) van één type (namelijk 'a ) op een ander type (namelijk 'b ) en een lijst van het eerste type. De functie retourneert een lijst van het tweede type waarbij elk element het resultaat is van het aanroepen van de toewijzingsfunctie op een element van de eerste lijst.

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

De typen 'a en 'b hoeven niet verschillend te zijn. We kunnen bijvoorbeeld nummers net zo gemakkelijk toewijzen aan hun vierkanten.

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

Verzamel gegevens in een lijst

De functies List.fold_left en List.fold_right functies van een hogere orde die de externe logica van List.fold_right implementeren. Een lijst samenvoegen, soms ook wel een lijst verkleinen, betekent een waarde berekenen die is afgeleid van de opeenvolgende inspectie van alle items in die lijst.

In de documentatie van de Lijstmodule staat dat

• List.fold_left fa [b1; ...; bn] is f (... (f (fa b1) b2) ...) bn .
• List.fold_right f [a1; ...; an] b is f a1 (f a2 (... (f an b) ...)) . (Deze laatste functie is niet staartrecursief.)

In gewoon Engels computing List.fold_left fa [b1; ...; bn] neer op het doornemen van de lijst [b1; ...; bn] het bijhouden van een accumulator die aanvankelijk was ingesteld op a : elke keer dat we een item in de lijst zien, gebruiken we f om de waarde van de accumulator bij te werken, en wanneer we klaar zijn, is de accumulator de uiteindelijke waarde van onze berekening. De functie List.fold_right is vergelijkbaar.

Hier zijn een paar praktische voorbeelden:

Bereken de totale som van een lijst met getallen

List.fold_left ( + ) 0 lst

Bereken het gemiddelde van een lijst met drijvers

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)

Voer de basislijstverwerking opnieuw uit

De functies List.fold_left en List.fold_right zijn zo algemeen dat ze kunnen worden gebruikt om bijna alle andere functies uit de List.fold_right te implementeren:

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 []

Het is zelfs mogelijk om de functie List.iter opnieuw te implementeren, onthoud dat () de algemene status van het programma is om deze code te interpreteren als een verder voorbeeld van lijstaggregatie :

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

Deze voorbeelden zijn bedoeld als leermateriaal, deze implementaties hebben geen recht op de overeenkomstige functies uit de standaardbibliotheek.