Initial commit
[blog.git] / posts / 139.sxml
1 ;;; -*- scheme -*-
2
3 (use-modules (haunt utils))
4
5 `((title . "La recursividad \"infinita\" de Lisp")
6   (date . ,(string->date* "2011-02-11 16:04"))
7   (content
8    ((p (img (@ (src "/wp-content/uploads/2011/03/lisp.jpg") (align "left") (style "margin: 10px;"))))
9     (p "La posibilidad de aprovechar toda la potencia de la recursividad es uno de los puntos fuertes (hay tantos) de los lenguajes funcionales y aunque voy a hablar de Lisp, ya que es el lenguaje funcional que mejor conozco, lo que voy a decir es aplicable a Scheme, Haskell, etc.")
10
11     (p "Para la explicación usaré el típico ejemplo de calcular el factorial de un número. El código en Lisp para realizar el cálculo (que nadie se asuste con los paréntesis) sería:")
12
13     (p (pre "(defun factorial (n)
14    (cond ((= n 1) 1)
15          (t (* n (factorial (- n 1))))))"))
16
17     (p "La misma función escrita en C sería la siguiente:")
18
19     (p (pre "int factorial (int n) {
20     if (n == 1)
21         return 1;
22     else
23         return n * factorial (n - 1);
24 }"))
25
26     (p "Sin embargo, esta forma de calcular el factorial de un número suele encontrarse únicamente en libros de programación para explicar el mecanismo de la recursividad. Cualquier programador sabe que cada vez que llamamos a una función el sistema operativo almacena en la pila el estado actual del programa para recuperarlo después cuando vuelva de la llamada a la función, con lo que si queremos calcular el factorial de un número muy grande corremos el riesgo de sufrir un desbordamiento de pila con efectos un tanto desagradables para nuestro programa.")
27
28     (p "Por esa razón los programadores de C calcularían el factorial de la siguiente forma:")
29
30     (p (pre "int factorial (int n) {
31     int r = 1, n2 = n;
32
33     while (n2 > 1) {
34         r = r * n2;
35         n2--;
36     }
37
38     return r;
39 }"))
40
41     (p "Ahora evitamos el problema del desbordamiento de pila y el programa, al ser iterativo, es mucho más rápido, aunque el código no resulta tan fácil de leer ni tan lógico como la versión recursiva.")
42
43     (p "Pero, en contra de lo que podría esperarse, el código en Lisp funciona igual de rápido que el código en C y además, podemos calcular factoriales de números inmensos sin que la pila se inmute. ¿Cómo es posible? Es posible gracias al trabajo del intérprete de Lisp y a una técnica conocida como " (a (@ (href "http://en.wikipedia.org/wiki/Tail_recursion")) "Tail Recursion") " (recursividad por cola).")
44
45     (p "Lo que hace el intérprete de Lisp es sustituir nuestra función por esta otra:")
46
47     (p (pre "(defun factorial (n &optional (r 1))
48     (cond ((= n 1) r)
49           (t (factorial (- n 1) (* r n)))))"))
50
51     (p "Si nos fijamos bien veremos que la nueva función no necesita volver sobre sus pasos para calcular el factorial, sino que va calculando el resultado antes de la llamada recursiva. Esto permite que no sea necesario usar la pila, ya que no hace falta regresar a través de todas las llamadas, sino que la última es la que devolverá el resultado directamente.")
52
53     (p "Si bien es cierto que muchos compiladores de lenguajes imperativos como C tienen en cuenta este tipo de funciones y las tratan como funciones iterativas, los intérpretes y compiladores de lenguajes funcionales lo hacen de forma implícita, lo que permite un código mucho más claro y legible."))))