Cuando trabajamos con Elixir, la recursividad es una herramienta fundamental para procesar listas y colecciones. En particular, la combinación de recursividad con pattern matching nos permite crear funciones que operan sobre listas de forma clara y elegante, aunque no siempre la más eficiente. Sin embargo, entender cómo construir estas funciones a mano nos ayuda a comprender mejor el funcionamiento interno de funciones comunes como map, filter o reduce.
Para empezar, pensemos en una función que tome una lista de números y devuelva una lista con el doble de cada uno de esos números. En Elixir, la recursividad suele implementarse directamente en los parámetros de la función mediante pattern matching. Por ejemplo, podemos definir una función llamada dobles que tenga dos cláusulas: una para el caso base, cuando la lista está vacía, y otra para cuando la lista tiene al menos un elemento.
En el caso base, si la lista está vacía, simplemente devolvemos una lista vacía, porque el doble de nada es nada. En la segunda cláusula, descomponemos la lista en cabeza y cola. La cabeza es el primer elemento, y la cola es el resto de la lista. Entonces, construimos una nueva lista donde el primer elemento es el doble de la cabeza original, y el resto es el resultado de llamar recursivamente a dobles con la cola.
Este proceso se repite hasta que la cola se vacía, momento en el que la función devuelve la lista vacía y la recursión termina. Así, cada llamada procesa un elemento y lo transforma, y luego delega el resto del trabajo a la llamada recursiva siguiente.
defmodule RecursionListas do
def dobles([]), do: []
def dobles([cabeza | cola]) do
[cabeza * 2 | dobles(cola)]
end
end
Si probamos esta función con una lista como [1, 2, 3, 4, 5], obtendremos [2, 4, 6, 8, 10], replicando el comportamiento de un map que dobla cada elemento.
Siguiendo esta misma idea, podemos construir una función pares que filtre los números pares de una lista. Aquí, además del pattern matching, usamos guardas para decidir si la cabeza cumple la condición de ser par. Si la cabeza es par, la incluimos en la lista resultado y seguimos procesando la cola. Si no, simplemente descartamos la cabeza y seguimos con la cola.
defmodule RecursionListas do
def pares([]), do: []
def pares([cabeza | cola]) when rem(cabeza, 2) == 0 do
[cabeza | pares(cola)]
end
def pares([_cabeza | cola]) do
pares(cola)
end
end
Es importante destacar que en las guardas solo podemos usar ciertas expresiones y funciones, ya que no todo es válido en ese contexto. Por ejemplo, no podemos llamar a funciones arbitrarias dentro de un when, salvo que sean macros o funciones permitidas.
Para hacer estas funciones más flexibles, podemos pasar una función como parámetro que defina el criterio o la transformación a aplicar. Esto nos permite generalizar el comportamiento de filter o map y reutilizar el código para diferentes casos.
Finalmente, para implementar un reduce artesanal, podemos definir una función que reciba una lista y un acumulador inicial. Si la lista está vacía, devolvemos el acumulador. Si no, descomponemos la lista en cabeza y cola, y llamamos recursivamente a reduce con la cola y el acumulador actualizado con la operación que queramos realizar, por ejemplo, sumar la cabeza al acumulador.
defmodule RecursionListas do
def suma(lista), do: suma(lista, 0)
defp suma([], acumulador), do: acumulador
defp suma([cabeza | cola], acumulador) do
suma(cola, acumulador + cabeza)
end
end
Aquí, suma/1 es una función fachada que inicia la suma con un acumulador en cero, mientras que suma/2 es la función recursiva privada que realiza el trabajo real.
Este enfoque nos permite entender cómo funcionan internamente muchas de las funciones que usamos a diario en Elixir, y practicar la recursividad con listas de forma clara y didáctica. Además, nos prepara para enfrentar problemas más complejos donde la recursividad y el pattern matching son esenciales.