Programación funcional en Haskell

Uno de los puntos fuertes de Haskell es la programación funcional pura. La cual se centra en funciones matemáticas puras, sin efectos secundarios, y en transformar datos de manera predecible.

Donde cada función es como una receta que recibe ingredientes (datos de entrada) y devuelve un resultado (salida).

Donde las funciones no alteran cosas externas (osea, sin efectos secundarios), solo trabajan con lo que reciben.

Donde los datos no cambian, se transforman en nuevos resultados.

Donde no se evalúa una expresión hasta que su resultado sea estrictamente necesario, permitiendo el manejo de estructuras de datos infinitas.

Con Haskell es como si trabajaras con fórmulas matemáticas, cada función es una operación que siempre da el mismo resultado con los mismos datos.

Incluso permitiendo que las funciones tomen a otras funciones como argumentos, o simplemente devolviendo éstas.

Es como hacer un jugo de naranja. Tomas la naranja y la exprimes, y así obtienes su jugo. Repitiendo el mismo proceso. Sin explicar ni detallar absolutamente nada.

Función jugo(naranja) -> "jugo de naranja"

Para programadores que usan Java esto puede parecer confuso. Puesto que nos llevaría una lógica muy distinta:

boolean hayNaranjas = true;

if(hayNaranjas){
   irAlaCocina();
   tomarLaNaranja();
   prepararVaso();
   exprimirNaranja();
   servirVaso();
}

Para entender mejor esto tenemos lo siguiente...

Los puntos fuertes de la programación funcional pura (en Haskell) son:

1. Las funciones puras: una función siempre devuelve el mismo resultado; no depende de variables externas ni modifica estados.

2. Inmutabilidad: no existen as mutaciones de estado, los valores no cambian.

3. Transparencia referencial: una expresión puede ser reemplazada por su valor sin alterar el comportamiento del programa.

4. Evaluación perezosa (lazy evaluation): las expresiones se evalúan solo cuando son necesarias.

5. Tipado fuerte y estático: el compilador verifica tipos en tiempo de compilación

Para entender mejor crearemos un programa que defina una función ``suma`` que sume dos números enteros (Int).

suma.hs

suma :: Int -> Int -> Int
suma x y = x + y

La función ``suma`` es pura y siempre que se invoque con los mismos argumentos, devolverá el mismo resultado. Es decir, si introduces dos números enteros, devolverá un resultado tipo entero. Quien haya asistido a la escuela primaria y llevado la materia de aritmética básica entenderá esto.

Entremos al REPL de Haskell:

$ ghci

Cargamos el programa:

ghci> :l suma.hs
[1 of 2] Compiling Main             ( suma.hs, interpreted )
Ok, one module loaded.

Introducimos dos valores tipo entero (Int) y el resultado será entero:

ghci> suma 45 32
77
ghci> suma 1 5
6

Ahora un ejemplo de evaluación perezosa con el programa ``naturales.hs``, en el cual definimos una lista infinita:

naturales :: [Int]
naturales = [1..]

primerosCinco = take 5 naturales

Cargamos el programa:

ghci> :l naturales.hs
[1 of 2] Compiling Main             ( naturales.hs, interpreted )
Ok, one module loaded.

La lista naturales es infinita, pero gracias a la evaluación perezosa podemos trabajar con ella sin problemas.

Salida:

ghci> primerosCinco
[1,2,3,4,5]

Continuaremos con este tema en próximas entregas.

Enlaces:

http://aprendehaskell.es/
https://wiki.haskell.org/index.php?title=Functional_programming