LISP es un lenguaje de programación declarativo desarrollado en 1958 que es popular en inteligencia artificial. Se basa en listas como tipo de datos fundamental. Incluye operadores lógicos y numéricos, y permite definir funciones y realizar entrada/salida. LISP ofrece un entorno flexible para manipular listas y realizar cálculos simbólicos.

1. Introducción a LISP
Sergio Jiménez Celorrio
Departamento Ingeniería Informática – UC3M

2. Introducción
 List Processing
 Desarrollado en 1958, en el MIT por John McCarthy
 Lenguaje mas popular en IA
– Declarativo
– Alto Nivel
 Diferentes Intérpretes
– CLISP, Allegro, CMUCL, …
 Aplicaciones
– Emacs, Autocad…

3. Tipos de datos
 Listas, Elemento Fundamental del Lenguaje
– (funcion x y z)
– (print “Hola Mundo”)
 Átomos
– Símbolos: var1, contador, …
– Valores Lógicos: t, nil
– Números: 3, 3.001
– Strings: “Hola mundo”
 Otros:
– arrays, vectores, tablas hash,…
– Estructuras y Clases definidas por el usuario

4. Operadores Básicos
 Numéricos:
– Suma
 (+ 1 2)
 (+ 1 2 3 4)
– Resta
 (- 4 2)
 (- 10 2 2 2)
– Producto
 (* 3 2)
 (* 2 2 2 2)
 Lógicos:
– And
 (and t nil)
 (and 1 2 3)
– Or
 (or t nil)
 (or 1 2 3)
– Not
 (not nil)
 (not 1),
 (not “hola”)

5. Evaluación de una expresión LISP (I)
 Directamente en el prompt del intérprete
 Desde un fichero
 (load “prueba.lisp”)

6. Evaluación de una expresión LISP (II)
 ‘ y quote impide la evaluación de una expresión:
 (+ 3 5)
 ‘(+ 3 5)
 (quote (+ 3 5))
 eval evalúa una expresión dos veces
 (eval (quote (+ 3 5)))
 (eval ‘(+ 3 5))

7. Variables
 Inicializaciones
 (defvar *contador* 1)
 Cambiando el valor a una variable
 (setf *contador* 2)
 Variables locales
 (let ((contador 1))
(print contador))
 (let ((contador 1))
(setf contador 2)
(print contador))

8. Condiciones
 (if (= *a* *b*) (print “hola”) (print “adios”))
 (when (= *a* *b*) (print “hola”))
– Equivalente a (if (= *a* *b*) (print “hola”))
 (unless (= *a* *b*) (print “hola”))
– Equivalente a (if (not (= *a* *b*)) (print “hola”))
 (Cond ((= *a* *b*) (print “uno”))
((> *a* *b*) (print “dos”))
(t (print “tres”)))

9. Relaciones de Igualdad
 EQ (el más específico), compara si dos variables apuntan al mismo objeto.
 (eq ‘(a b c) ‘(a b c))
NIL
 (setf x 1) (setf y x) (eq x y)
T
 EQL como EQ pero también compara números si son del mismo tipo o para caracteres
 (eql x y)
T
 (eql 3 3)
T
 (eql 3.0 3)
NIL
 EQUAL (El más general)
 (equal ‘(a b c) ‘(a b c ))
T
 (equal 3.0 3)
T
 (equal “hola” “HOLA”)
NIL
 EQUALP Como EQUAL pero compara cadenas en mayúsculas y minúsculas
 (equalp “hola” “HOLA”)
T
 Relaciones numéricas: = <, >, <=, >=

10. Bucles
 (dotimes (i 3) (print i))
 (dolist (i ‘(0 1 2)) (print i))
 (setf *i* 0)
(loop (when (= *i* 3) (return))
(print *i*)
(setf *i* (+ *i* 1)))

11. Creación de Listas
 (setf *lista* ‘(1 2 3 4 5))
 (setf *lista* (list 1 2 3 4 5))

12. Funciones Básicas de Manejo de
Listas
 (car *lista*) = (first *lista*) = (nth 0 *lista*)
 (rest *lista*) = (cdr *lista*)
 (last *lista*) = (list (nth (- (length lista) 1) *lista*))
 (push 8 *lista*)
 (pop *lista*)
 (cons 1 ‘(2 3 4 5))
 (append ‘(1 2) ‘(3 4 5))
 (member 1 ‘(3 4 1 5 6))
 (sort ‘(3 2 1) ‘<)
 (remove 1 ‘(3 4 1 5 6))
 (length ‘(3 2 5))

13. Declaración de Funciones de Usuario
 (defun nombre (args) “descripcion” (expresión))
– (defun mi-funcion (lista)
“obtiene el primer elemento del
argumento lista”
(car lista))
 Devuelven el valor de la última expresión

14. Apply y Funcall
 Permiten aplicar una función a un conjunto
de datos
– Apply (apply #’+ ‘(2 3))
– Funcall: (funcall #’+ 2 3)

15. Mapcar
 Permite aplicar una función a cada uno de
los elementos de una lista.
(mapcar #’list ‘(1 2 3 4))
(mapcar #’+ ‘(1 2 3 4)’(10 20 30 40))

16. Funciones Lambda
 Permite definir funciones en tiempo de ejecución
– Muy útil para las funciones tipo map o para definir
funciones de Test
 (mapcar #’(lambda (x) (format t “El doble de ~a es ~a~&“ x (* 2 x)))
‘(1 2 3))
 (member 2 ‘((1 2) (3 4) (5 6))
:test #’(lambda (x y) (equal x (second y))))

17. Entrada / Salida
 Lectura sobre entrada estándar
 (setf *respuesta* (read))
 Escritura sobre salida estándar
 (print “Hola mundo”)
 Salida con formato (format t literal argumentos)
– El literal puede indicar:
~% nueva línea
~d número
~a carácter
 (format t “el cuadrado de ~d es ~d ~&” 3 (* 3 3))
 Abrir un fichero.
 (setq fichero (open “nombre-fichero” :direction :input))
 Escribir en un fichero.
 (format fichero “el cuadrado de ~d es ~d ~&” 3 (* 3 3))
 Cerrar fichero
 (close fichero)

18. Buenos hábitos de programación
 Introducir comentarios
– ; para comentar una línea
– #| para comentar
Varias líneas |#
 Nombres de variables y funciones descriptivos
 Funciones con pocas líneas y cortas
 Utilice editor que resalte emparejado de paréntesis y con sangría automática
– (i.e. emacs o xemacs)
 Use cond en lugar de ifs anidados
 Variables globales comiencen y acaben con *
– *variable1*
 Utilice lógica positiva al dar nombre a las funciones y predicados: que
devuelvan t si es cierto.
– (numberp 5)

19. Libros
 LISP : el lenguaje de la inteligencia artificial /
A.A. Berk
 AutoLISP versión 12 / José Antonio Tajadura
Zapirain, Javier López Fernández
 LISP / Patrick Henry Winston, Berthold Klaus
Paul Horn
 Common LISP : the language. Steele, Guy L.

20. Web
 Referencia Funciones Lisp
– http://www.lispworks.com/documentation/HyperSpec/Front/index.htm