En Elixir, una práctica fundamental para mantener nuestro código limpio y manejable es dividir las tareas complejas en funciones pequeñas y específicas. Ya sabemos que podemos llamar funciones de otros módulos, como IO.puts, pero también es muy común y útil llamar funciones dentro del mismo módulo. Esto nos permite organizar mejor nuestro código y facilitar su comprensión.
Cuando una función empieza a crecer en líneas o en complejidad, lo ideal es extraer partes de esa lógica en funciones auxiliares. Así, cada función hace una cosa concreta y podemos entenderlas por separado sin perdernos en un bloque de código demasiado extenso. Esto es especialmente importante en Elixir, donde cada función es una expresión y podemos componerlas para construir funcionalidades más complejas.
Para ilustrar esta idea, podemos crear un módulo llamado Impuestos que calcule el impuesto a pagar según el tipo de producto. En España, por ejemplo, existen tres tipos de IVA: normal, reducido y superreducido, que aplican diferentes porcentajes. En lugar de poner estos porcentajes directamente en la función principal, creamos una función de apoyo que, dado un tipo, devuelve el porcentaje correspondiente.
Podemos implementar esta función porcentaje usando un condicional cond que evalúe el tipo y devuelva el valor adecuado:
defmodule Impuestos do
def impuesto(precio, tipo) do
precio * porcentaje(tipo)
end
defp porcentaje(tipo) do
cond do
tipo == :normal -> 0.21
tipo == :reducido -> 0.10
tipo == :superreducido -> 0.04
end
end
end
Aquí, impuesto/2 calcula el impuesto multiplicando el precio por el porcentaje que devuelve porcentaje/1. Notemos que porcentaje está definida como una función privada con defp, lo que significa que solo puede ser llamada desde dentro del módulo Impuestos. Esto es importante para encapsular la lógica interna y evitar que otras partes del programa usen funciones que no deberían ser accesibles directamente.
Además, Elixir nos facilita la llamada a funciones dentro del mismo módulo sin necesidad de anteponer el nombre del módulo. Por ejemplo, dentro de impuesto/2 podemos llamar simplemente a porcentaje(tipo) en lugar de Impuestos.porcentaje(tipo). Esto hace que el código sea más limpio y legible.
Si intentamos llamar a Impuestos.porcentaje(:normal) desde fuera del módulo, obtendremos un error porque porcentaje es privada. En cambio, podemos llamar a Impuestos.impuesto(10, :reducido) y obtener el cálculo correcto del impuesto para un precio de 10 con tipo reducido.
Esta forma de organizar el código nos permite tener funciones pequeñas, claras y bien agrupadas. Las funciones privadas actúan como piezas internas que solo el módulo conoce y utiliza, mientras que las funciones públicas son la interfaz que exponemos para que otros módulos o partes del programa interactúen con nuestro código.
En definitiva, separar la lógica en funciones privadas de apoyo nos ayuda a escribir código más estable, fácil de mantener y entender. Así evitamos tener funciones largas y complejas, y podemos modificar detalles internos sin afectar la interfaz pública del módulo. Esta modularidad es clave para desarrollar aplicaciones Elixir robustas y limpias.