Antes de comenzar debemos saber como entrar y salir de nuestro intérprete. Para iniciar abrimos una terminal, consola o línea de comandos (o símbolo del sistema). Escribimos el nombre de nuestro programa, por ejemplo para clisp:
> clisp
Iniciará el programa del intérprete lisp, con alguna información según el caso.
Para finalizar y devolver el control de la consola al sistema operativo, escribimos:
> (quit)
Llamadas a Funciones
Las funciones son de fundamental importancia aquí. Las llamadas a funciones tienen una estructura determinada:
(nombre argumentos)
Todas las funciones irán entre paréntesis. Las funciones pueden tener uno, varios o ningún argumento. Aquí muestro algunos ejemplos de llamadas a funciones desde el intérprete:
> (+ 2 3)
5
> (write-string "holaaa")
holaaa
"holaaa"
> (* 4 7)
28
> (* 3 4 2)
24
Para asignar valores a variables, usamos la función setf:
> (setf x 45)
45
Colocando el nombre, el interprete evalua y devuelve el valor:
> x
45
Para crear listas de objetos diversos, podemos usar la función list (veremos mas adelante sobre los distintos tipos de datos en lisp):
> (list 34 "cadena de caracteres" 3.14 2/3 (+ 6 7))
(34 "cadena de caracteres" 3.14 2/3 13)
> (setf x 23)
23
> (list 67 5.32 3/8 "octubre" (+ 2 3) x)
(67 5.32 3/8 "octubre" 5 23)
Definir funciones
En Lisp, la forma mas fácil de definir funciones es usando la macro defun. Veamos un ejemplo de creación de una función en el intérprete:
> (defun hola () (write-string "Hola mundo!"))
HOLA
Primero va el nombre de la función, en este caso hola, luego los argumentos, en este caso la función no posee ningún argumento, y por ultimo va el cuerpo de la función.
Otro ejemplo muy conocido para mostrar las definiciones de función en lisp:
> (defun cuadrado (n) (* n n))
CUADRADO
Probamos la función:
> (cuadrado 9)
81
Otro mas:
> (cuadrado 4)
16
Otro ejemplo de definición de funciones:
> (defun cubo (n) (* n n n))
CUBO
Genial! probamos la función:
> (cubo 5)
125
> (cubo 3)
27
Una vez que salimos del intérprete, las definiciones de función creadas se perderán.
¿Cómo guardamos estos datos?
Abrimos un editor de textos cualquiera o emacs con slime y escribimos en él:
(defun hola ()
(write-string "Hola, mundo!"))
(defun cuadrado (n)
(* n n))
(defun cubo (n)
(* n n n))
Guardamos el archivo como "primero.lisp" o lo que sea .lisp.
Si entramos en el intérprete nuevamente, las funciones creadas no estarán cargadas en el sistema. Para cargarlas usamos la función load:
> (load "ruta.../primero.lisp")
Y las funciones creadas estarán disponibles en el intérprete. También podemos compilar el archivo .lisp antes de cargarlo, con lo cual se creará un archivo .fas o .fasl según el tipo de interprete que estemos usando. Esto se hace así:
> (compile-file "ruta.../primero.lisp")
De esta manera crea el archivo "primero.fas" en un lenguaje mas cercano a la máquina. El código se ejecutará mas rápido, esto no se notará en programas pequeños pero si en programas mas extensos. Para cargarlo usamos la función load:
> (load (ruta.../primero.fas")
PD: aquí dejo una guía rápida que encontré en algún momento navegando, hace rato ya:
