OCaml
Listbearbetning

List.Map

List.map har signaturen ('a -> 'b) -> 'a list -> 'b list som på engelska är en funktion som tar en funktion (vi kallar detta mappningsfunktionen) från en typ (nämligen 'a ) till en annan typ (nämligen 'b ) och en lista över den första typen. Funktionen returnerar en lista av den andra typen där varje element är resultatet av att anropa mappningsfunktionen på ett element i den första listan.

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

Typerna 'a och 'b behöver inte vara annorlunda. Vi kan till exempel kartlägga siffror till deras rutor lika enkelt.

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

Samla data i en lista

List.fold_left och List.fold_right är högre ordning som implementerar den yttre logiken för listaggregering. Att aggregera en lista, ibland även kallad att reducera en lista, betyder att man beräknar ett värde som härrör från sekventiell inspektion av alla objekt i listan.

Dokumentationen för listmodulen anger att

• List.fold_left fa [b1; ...; bn] är f (... (f (fa b1) b2) ...) bn .
• List.fold_right f [a1; ...; an] b är f a1 (f a2 (... (f an b) ...)) . (Den senare funktionen är inte svårrekursiv.)

På vanlig engelska databehandling List.fold_left fa [b1; ...; bn] uppgår till att köra igenom listan [b1; ...; bn] hålla reda på en ackumulator som initialt sattes till a : varje gång vi ser ett objekt i listan använder vi f att uppdatera ackumulatorns värde, och när vi är klara är ackumulatorn det slutliga värdet för vår beräkning. Funktionen List.fold_right är liknande.

Här är några praktiska exempel:

Beräkna den totala summan av en lista med siffror

List.fold_left ( + ) 0 lst

Beräkna medelvärdet för en lista med flottörer

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)

Återimplementera grundläggande listbehandling

Funktionerna List.fold_left och List.fold_right är så generella att de kan användas för att implementera nästan alla andra funktioner från listmodulen:

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

Det är till och med möjligt att List.iter funktionen List.iter , kom ihåg att () är det globala tillståndet i programmet för att tolka den här koden som ett ytterligare exempel på listaggregation :

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

Dessa exempel är avsedda att vara läromedel, dessa implementationer har ingen dygd över motsvarande funktioner från standardbiblioteket.