Los tipos enumerados son estructuras de datos que podemos recorrer desde un principio hasta un final, como las listas o los mapas. Por ejemplo, una lista de átomos como [:a, :b, :c, :d] nos permite acceder a cada elemento secuencialmente, ya sea usando funciones como head y tail o mediante funciones que abstraen ese recorrido, como Enum.at, que nos devuelve el elemento en una posición específica sin preocuparnos por la implementación interna.
Los mapas también son tipos enumerados, aunque con una particularidad importante: no garantizan un orden fijo al recorrerlos. Podemos acceder a sus claves y valores, y existen funciones como Map.keys y Map.values que nos devuelven listas con las claves o valores respectivamente. Además, Enum.to_list convierte un mapa en una lista de tuplas, donde cada tupla contiene una clave y su valor asociado. Esto nos permite tratar mapas como colecciones enumerables y aplicarles funciones de alto orden.
Las funciones de alto orden son aquellas que reciben otras funciones como parámetros. En el contexto de tipos enumerados, estas funciones nos permiten procesar colecciones de manera declarativa y concisa. Una de las más útiles es filter, que toma un enumerable y una función que define un criterio, y devuelve una nueva colección con los elementos que cumplen ese criterio.
La función filter funciona aplicando la función criterio a cada elemento del enumerable. Si la función devuelve un valor considerado verdadero, el elemento se incluye en la colección resultante; si devuelve falso, se excluye. Por ejemplo, si tenemos la lista [1, 2, 3, 4, 5] y queremos quedarnos solo con los números pares, podemos usar:
Enum.filter([1, 2, 3, 4, 5], fn x -> rem(x, 2) == 0 end)
# Resultado: [2, 4]
Aquí, la función anónima fn x -> rem(x, 2) == 0 end evalúa si un número es divisible entre 2. filter recorre la lista, aplica esta función a cada elemento y construye una nueva lista con los que cumplen la condición.
Cuando trabajamos con mapas, la función que pasamos a filter recibe cada elemento como una tupla {clave, valor}. Podemos usar pattern matching para extraer solo el valor y aplicar el filtro sobre él. Por ejemplo, dado el mapa %{a: 1, b: 2, c: 3, d: 4}, si queremos quedarnos con las entradas cuyo valor sea par, haríamos:
Enum.filter(%{a: 1, b: 2, c: 3, d: 4}, fn {_k, v} -> rem(v, 2) == 0 end)
# Resultado: [b: 2, d: 4]
Es importante notar que el resultado no es un mapa, sino una Keyword List con las tuplas que cumplen el criterio.
La ventaja principal de usar filter y otras funciones de alto orden frente a los bucles tradicionales es que delegamos en el lenguaje la gestión del recorrido y la construcción de la colección resultante. En lenguajes imperativos como C o Java, tendríamos que escribir explícitamente un bucle, una condición y una estructura para almacenar los resultados, lo que implica más código y mayor complejidad, especialmente si queremos optimizar el procesamiento o paralelizarlo.
Con filter, simplemente definimos qué queremos filtrar y dejamos que la función se encargue del resto. Esto no solo hace el código más legible y conciso, sino que también abre la puerta a optimizaciones internas que el lenguaje pueda aplicar, como procesamiento paralelo o evaluaciones perezosas, sin que tengamos que preocuparnos por esos detalles.
Entender bien cómo funciona filter es fundamental antes de avanzar a otras funciones de alto orden como map o reduce, que también nos permiten transformar y combinar colecciones de manera elegante y eficiente.