5. Funciones

Teoría

El asterisco, o *, indica el prompt del REPL de Common Lisp. En este caso, estamos invocando una función propia llamada my-last que toma una lista como argumento y devuelve el último elemento de esa lista.

Como puedes ver la sintaxis de Common Lisp se estructura en paréntesis, o S-expressions. La primera posición dentro del paréntesis indica la función a invocar, y las posiciones siguientes son los argumentos que se le pasan a dicha función. Nuestra futura función my-last tomará una lista como argumento y devolverá el último elemento de esa lista.

Las funciones se definen con la palabra clave defun, seguida del nombre de la función, una lista de parámetros entre paréntesis y el cuerpo de la función.

Por ejemplo:

(defun total (num1 num2)
  (+ num1 num2))

Para invocarla:

* (total 3 5)
8

En otros lenguajes tenemos una palabra reservada como return para devolver un valor desde una función. En Common Lisp, el valor de la última expresión es el valor que se devuelve. En el ejemplo anterior, la expresión (+ num1 num2) es la última expresión, también la única, por lo que su resultado es el valor devuelto por la función.

Otra forma de llamarla es mediante una función anónima:

* (funcall #'total 10 15)
25

O usando apply para pasar una lista de argumentos:

* (apply #'total '(20 30))
50

Usar '(20 30) es una forma de crear una lista literal en Common Lisp. El apóstrofe (') antes del paréntesis indica que lo que sigue es una lista literal y no debe ser evaluado. También podrías usar la función list para crear la misma lista: (list 20 30).

Para capturar los valores de forma individual, puedes usar nth-value, first o last (son funciones que operan sobre múltiples valores devueltos o listas):

* (nth 2 '(a b c d))
(C)

* (first '(a b c d))
(A)

* (last '(a b c d))
(D)

* (last '(a b c d) 2)
(C D)

* (subseq '(a b c d) 1 3)
(B C)

También tienes a tu disposición funciones como car y cdr.

* (car '(a b c d))
A

* (cdr '(a b c d))
(B C D)

La diferencia entre first y car es que first es una función genérica que puede operar sobre diferentes tipos de secuencias, mientras que car está específicamente diseñada para listas enlazadas. En la práctica, para listas, ambos funcionan igual.

Common Lisp heredó de sus predecesores una serie de combinaciones de car y cdr que permiten acceder a elementos anidados en listas. Por ejemplo, cadr es equivalente a (car (cdr lista)), es decir, el segundo elemento.

* (cadr '(a b c d))
B

* (caddr '(a b c d))
C

* (cadddr '(a b c d))
D

* (cddr '(a b c d))
(C D)

* (cdddr '(a b c d))
(D)

Estas funciones pueden combinarse hasta cuatro niveles de profundidad (c[ad]{2,4}r), aunque en la práctica rara vez se usan más allá de tres niveles.

Sin embargo, el estándar moderno de Common Lisp proporciona alternativas más legibles para acceder a elementos de una lista:

* (first '(a b c d))
A

* (rest '(a b c d))
(B C D)

* (second '(a b c d))
B

* (third '(a b c d))
C

* (fourth '(a b c d))
D

Existen funciones equivalentes hasta tenth (décimo elemento). La función rest es equivalente a cdr y devuelve todos los elementos excepto el primero.

* (fifth '(a b c d e f))
E

* (tenth '(1 2 3 4 5 6 7 8 9 10))
10

Como regla general, se recomienda usar las versiones modernas (first, second, rest, etc.) en código nuevo, ya que son más descriptivas y fáciles de leer. Las funciones car y cdr se mantienen por razones históricas y de compatibilidad.

Y otras funciones útiles para manipular listas como reverse, append, cons, list, entre otras.

* (reverse '(a b c d))
(D C B A)

* (append '(a b) '(c d))
(A B C D)

* (cons 'a '(b c d))
(A B C D)

* (list 'a 'b 'c 'd)
(A B C D)

Las desarrollaremos más adelante, pero por ahora ya tienes las herramientas necesarias para resolver algunos problemas.