OCaml
Procesamiento de listas

List.Map

List.map tiene la firma ('a -> 'b) -> 'a list -> 'b list que en inglés es una función que toma una función (llamaremos a esto la función de mapeo) de un tipo (a saber, 'a ) a otro tipo (a saber, 'b ) y una lista del primer tipo. La función devuelve una lista del segundo tipo donde cada elemento es el resultado de llamar a la función de mapeo en un elemento de la primera lista.

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

Los tipos 'a y 'b no tienen que ser diferentes. Por ejemplo, podemos asignar números a sus cuadrados con la misma facilidad.

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

Datos agregados en una lista

Las funciones List.fold_left y List.fold_right son funciones de orden superior que implementan la lógica externa de la agregación de listas. La agregación de una lista, a veces también denominada reducción de una lista, significa calcular un valor derivado de la inspección secuencial de todos los elementos de esa lista.

La documentación del módulo de lista indica que

• List.fold_left fa [b1; ...; bn] es f (... (f (fa b1) b2) ...) bn .
• List.fold_right f [a1; ...; an] b es f a1 (f a2 (... (f an b) ...)) . (Esta última función no es recursiva de cola.)

En lenguaje sencillo en inglés, List.fold_left fa [b1; ...; bn] equivale a correr a través de la lista [b1; ...; bn] hacer el seguimiento de un acumulador establecido inicialmente en a : cada vez que vemos un elemento de la lista, usamos f para actualizar el valor del acumulador, y cuando hayamos terminado, el acumulador es el valor final de nuestro cálculo. La función List.fold_right es similar.

Aquí hay algunos ejemplos prácticos:

Calcular la suma total de una lista de números

List.fold_left ( + ) 0 lst

Calcular el promedio de una lista de flotadores.

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)

Reimplementar el procesamiento básico de listas

Las funciones List.fold_left y List.fold_right son tan generales que se pueden usar para implementar casi todas las demás funciones del módulo de lista:

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

Incluso es posible List.iter función List.iter , recuerde que () es el estado global del programa para interpretar este código como un ejemplo adicional de agregación de lista :

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

Estos ejemplos pretenden ser material de aprendizaje, estas implementaciones no tienen ninguna virtud sobre las funciones correspondientes de la biblioteca estándar.