Funciones de orden superior: el vocabulario que sustituye al bucle

La primera vez que alguien acostumbrado a los lenguajes imperativos busca cómo escribir un bucle en Elm, descubre con incredulidad que la respuesta es que no se escribe. No hay for, no hay while, no hay break, no hay continue y no hay ninguna manera de incrementar un índice, porque no hay reasignación que lo permita. La reacción natural es pensar que se ha perdido algo básico, y merece la pena examinar despacio qué es exactamente lo que se ha perdido, porque no es lo que parece. Un bucle imperativo hace siempre dos cosas a la vez y las mezcla en el mismo bloque de texto: describe cómo recorrer una estructura y describe qué hacer con cada elemento. La primera parte es idéntica en el noventa y nueve por ciento de los bucles que se escriben en la vida, es la parte donde se cometen los errores de índice y de condición de parada, y no aporta información sobre el problema que se está resolviendo. La segunda parte es la única que importa. Lo que hace Elm no es prohibir el bucle sino separar esas dos cosas: la forma del recorrido se da por nombrada de antemano en un puñado de funciones, y lo único que escribes es la parte específica de tu problema. Aprender ese puñado de nombres no es aprender una biblioteca de utilidades; es aprender el vocabulario con el que se habla de recorridos cuando ya no hace falta describirlos.

map y filter: lo que cada una promete conservar

Las dos funciones más usadas de la biblioteca se distinguen mejor por lo que garantizan que por lo que hacen. map promete que la lista resultante tendrá exactamente la misma longitud y el mismo orden que la de partida, y que cada elemento habrá sido sustituido por el resultado de aplicarle la función. filter promete lo contrario: los elementos que sobrevivan serán idénticos a los originales, y lo único que puede cambiar es cuántos hay.

-- map : (a -> b) -> List a -> List b
-- Conserva la longitud, cambia los elementos
List.map (\n -> n * 2) [ 1, 2, 3 ]        -- [ 2, 4, 6 ]
List.map .nombre usuarios                 -- List String

-- filter : (a -> Bool) -> List a -> List a
-- Conserva los elementos, cambia la longitud
List.filter (\n -> n > 2) [ 1, 2, 3, 4 ]  -- [ 3, 4 ]

-- El bucle imperativo tipico hacia ambas cosas mezcladas;
-- aqui se leen como dos intenciones separadas
usuarios
    |> List.filter .activo
    |> List.map .correo

Esa promesa no es una descripción informal: está escrita en el tipo. Que filter devuelva List a y no List b es una garantía verificada por el compilador de que ninguna función de filtrado podrá modificar los elementos por descuido, algo que en un bucle que hace las dos cosas a la vez depende exclusivamente de la disciplina de quien lo escribe. Leer map en una línea de código es saber sin mirar más que la cantidad de resultados no cambia; leer filter es saber que los datos no se han tocado. Un bucle no dice ninguna de las dos cosas hasta que se lee entero.

Conviene además notar que estos nombres no pertenecen a las listas. La misma pareja de operaciones existe con la misma forma para Maybe, para Result, para Dict, para Set, para Array y para los decodificadores, porque lo que nombran no es un recorrido sobre una secuencia sino una manera de relacionarse con un contenedor cualquiera. Quien aprendió List.map en la primera semana ya sabe leer Maybe.map sin que nadie se lo explique, y esa transferencia gratuita entre módulos es uno de los motivos por los que la biblioteca estándar de Elm se aprende mucho más rápido de lo que su tamaño sugiere.

foldl y foldr: el pliegue del que salen los demás

El pliegue es la operación fundamental sobre una lista, y todas las anteriores son casos particulares suyos. Recibe una función que combina un elemento con un acumulador, un valor inicial para ese acumulador y la lista, y va aplicando la combinación elemento a elemento hasta agotarla.

-- foldl : (a -> b -> b) -> b -> List a -> b
List.foldl (+) 0 [ 1, 2, 3, 4 ]          -- 10
List.foldl (::) [] [ 1, 2, 3 ]           -- [ 3, 2, 1 ], invierte
List.foldr (::) [] [ 1, 2, 3 ]           -- [ 1, 2, 3 ], reconstruye

-- map y filter son pliegues disfrazados
mapConFold : (a -> b) -> List a -> List b
mapConFold f lista =
    List.foldr (\x acc -> f x :: acc) [] lista

filterConFold : (a -> Bool) -> List a -> List a
filterConFold p lista =
    List.foldr
        (\x acc ->
            if p x then
                x :: acc

            else
                acc
        )
        []
        lista

La diferencia entre las dos direcciones se explica mal con metáforas y muy bien con un caso concreto: el que aparece arriba. foldl recorre desde el principio y va colocando cada elemento delante de lo acumulado, de modo que el primero acaba al fondo y la lista sale invertida. foldr recorre desde el final y reconstruye la lista tal cual. La regla práctica que se deriva es sencilla: cuando el acumulador es un número, un Bool o un Dict, la dirección casi nunca importa y conviene usar foldl, que en Elm es recursiva de cola y no crece en la pila; cuando el acumulador es una lista que quieres en el mismo orden, usa foldr. Conviene también desmontar aquí un mito heredado de los lenguajes perezosos: en Elm la evaluación es estricta, así que foldr no puede detenerse antes de tiempo ni operar sobre estructuras infinitas, y su única ventaja real es el orden de construcción.

El repertorio completo y el bucle que ya no se escribe

Con media docena de nombres más queda cubierto prácticamente todo lo que un bucle imperativo hace en el código real, incluidas las combinaciones que en el mundo imperativo obligan a acumular banderas o a salir a mitad del recorrido.

-- Filtrar y transformar de una vez, descartando lo que no convierte
List.filterMap String.toInt [ "1", "dos", "3" ]    -- [ 1, 3 ]

-- Aplanar una lista de listas producida por la transformacion
List.concatMap etiquetasDe articulos

-- Los que sustituyen a un bucle con salida anticipada
List.any esUrgente tareas        -- Bool
List.all estaValidado campos     -- Bool
List.member "elm" lenguajes      -- Bool

-- Ordenar por un criterio derivado, sin comparador manual
List.sortBy .apellido usuarios
List.sortWith compararPrioridad tareas

-- Y el equivalente de un indice, cuando de verdad hace falta
List.indexedMap (\i x -> String.fromInt i ++ ": " ++ x) filas

Merece la pena notar que any y all conservan la eficiencia del bucle con salida anticipada, porque su implementación deja de recorrer en cuanto el resultado está decidido. La diferencia con el bucle imperativo equivalente es que aquí la salida anticipada no es algo que tú escribes y puedes equivocarte al escribir, sino una propiedad de la función que usas. Lo mismo ocurre con List.indexedMap, que es la respuesta correcta cuando de verdad necesitas la posición: el índice te llega como argumento y no puedes desalinearlo, que es exactamente el error más común del bucle con contador.

Hay además una consecuencia menos evidente de este vocabulario y que solo se aprecia al mantener un programa durante meses. Como cada función de orden superior tiene un tipo que declara la forma del recorrido, cambiar de opinión sobre esa forma es un cambio que el compilador acompaña. Convertir un map en un filterMap porque ahora algunos elementos pueden no producir resultado no es una edición delicada dentro de un bucle con banderas, sino una sustitución de nombre que provoca un error de tipo en cada punto que dependía del resultado anterior, y ese error es la lista exacta de sitios que hay que revisar. En un bucle imperativo el mismo cambio se hace añadiendo una condición en medio, no rompe nada visiblemente y deja al resto del programa recibiendo silenciosamente menos elementos de los que esperaba. La diferencia entre las dos experiencias no es de elegancia: es la diferencia entre un cambio guiado y un cambio a ciegas.

flowchart TD
L[Lista de entrada] --> M[map transforma cada uno]
L --> F[filter selecciona algunos]
L --> D[foldl acumula en un valor]
M --> S[Lista de igual longitud]
F --> T[Lista mas corta o igual]
D --> U[Un unico resultado]
style M fill:#89b4fa,color:#11111b
style F fill:#f9e2af,color:#11111b
style D fill:#a6e3a1,color:#11111b