Curso de Java

1
El lenguaje LISP
2
Introducción

• Origen 1959
• Uso habitual en Inteligencia Artificial
• LISt Processing
• Lenguaje Interpretado
• También posible compilado
• Todas las variables son punteros
• Liberación automática de memoria (automatic
  garbage collection)
• Eficiencia menor que otros lenguajes (causas es
  interpretado, liberación automática de memoria,
  ...).
• Adecuado para prototipados y cálculo simbólico.
• Datos Programas

3
Datos

• Expresiones LISP
• Átomos
• Símbolos
• simbolo, simbolo3,ejemplo-de-simbolo
• Especiales nil, t
• Keywords
• ejemplo, keyword
• Strings (distinción minúsculas-mayúsculas)
• abc, ABC, string
• Números
• enteros 33, 4, -5
• racionales -3/5, 4/8
• reales 3.23, -4.78, 3.33E45
• Listas
• Colecciones de expresiones
• (a b (c (d)) e), (), (3 abc)

4
Evaluación

• Evaluación de una expresión LISP
• Ejemplos de evaluaciones
• Átomos
• Símbolos
• Su evaluación es su valor como variable
• T y NIL se evalúan a sí mismos
• Números, Strings y Keywords
• Se evalúan a sí mismos
• Listas
• () se evalúa a NIL
• Una lista no vacía evaluable debe tener como
  primer elemento un símbolo
• ( 3 ( 2 5))
• (quote (a b c))
• (setf variable ( 3 4))
• Forma LISP expresión evaluable

5
Operadores QUOTE y SETF

• Operadores
• Funciones evalúan todos sus argumentos
• Macros no evalúan todos los argumentos
• QUOTE
• Macro no evalúa su argumento
• (quote (a b c)) gtgtgt (A B C)
• (a b c) equivale a (quote (a b c))
• SETF
• Macro sólo evalúa el segundo argumento
• (setf x (a b c)) gtgtgt (A B C)
• Representación en memoria
• T, NIL son símbolos reservados

6
Operadores de manipulación de listas, I

• Características comunes
• Al evaluarlos, se obtiene error cuando se aplican
  sobre datos que no siguen su patrón sintáctico.
• La mayoría son funciones (no macros).
• FIRST (CAR)
• (first ltlistagt)
• (first (a b c)) gtgt A
• SECOND, THIRD, ..., NTH
• (second ltlistagt)
• (second (a b c)) gtgtgt B
• (nth ltexpresiongt ltlistagt)
• (nth 1 (a b c)) gtgtgt B

7
Operadores de manipulación de listas, II

• REST (CDR)
• (rest ltlistagt)
• (rest (a b c)) gtgt (B C)
• NTHCDR
• (nthcdr ltexpresiongt ltlistagt)
• (nthcdr ( 1 1) (a b c)) gtgt (C)
• (car (cdr (car ((a b c) d)))) gtgt B
• Es equivalente (cadar ((a b c) d))
• CONS
• (cons ltexpresiongt ltlistagt)
• (cons (a b) (c d e)) gtgtgt ((A B) C D E)
• LIST
• (list ltexpresiongt)
• (list (a b) (c d)) gtgtgt ((A B) (C D))

8
Operadores de manipulación de listas, III

• APPEND
• (append ltlistagt)
• (append (a b) (c d)) gtgtgt (A B C D)
• No destructivo. Crea copia (a primer nivel) de
  todos los argumentos menos el último
• Operadores destructivos
• Suelen ser macros
• (setf a (a b)) (setf b (c d)) (setf c (e f))
• NCONC (append). Función.
• (nconc a b) gtgtgt (A B C D)
• a gtgt (A B C D) b gtgtgt (C D)
• PUSH (cons). Macro
• (push r b) gtgtgt (R C D)
• b gtgtgt (R C D)
• POP. Macro
• (pop c) gtgtgt E
• c gtgtgt (F)

9
Operadores de manipulación de listas, IV

• El macro SETF admite como primer argumento
• Un símbolo
• (setf dias (lunes martes miercoles))
• Una posición de memoria
• (setf (second dias) jueves))
• dias gtgtgt (LUNES JUEVES MIERCOLES)
• (setf (rest dias) (viernes domingo))
• dias gtgtgt (LUNES VIERNES DOMINGO)
• (setf (rest dias) dias) gtgtgt (LUNES LUNES ....)
• Cuidado!, listas circulares

10
Operadores de manipulación de listas, V

• Otras funciones
• LAST
• (last ltlistagt)
• (last (a b c)) gtgtgt (C)
• REVERSE
• (reverse ltlistagt)
• (reverse (a b c)) gtgtgt (C B A)
• LENGTH
• (lenght ltlistagt)
• (lenght (a b c)) gtgtgt 3

11
Otras funciones LISP, I

• PROGN, PROG1
• Permiten escribir instrucciones compuestas (como
  y en el lenguaje C)
• Evalúan todas las instrucciones que contienen y
  devuelven la última o primera instrucción.
• (progn ( 3 4) ( 4 5)) gtgtgt 9
• (prog1 ( 3 4) ( 4 5)) gtgtgt 7
• PRINT
• (PRINT ltformagt)
• Si el valor de ltformagt lo llamamos A, el
  valor es A. Adicionalmente al ejecutarse, también
  se imprime A
• gt (progn (setf x (print A)) ( 3 4))
• A
• gtgtgt 7
• gt x
• gtgtgt A

12
Otras funciones LISP, II

• EVAL
• Evalúa dos veces una expresión
• (eval ( 3 4)) gtgt 7
• Operadores matemáticos
• , -, , /, ABS
• EXPT
• (expt 2 4) gtgtgt 16
• MAX, MIN
• (max 2 3 4 5) gtgtgt 5
• FLOAT
• (float 1/2) gtgtgt 0.5
• ROUND
• (round 3.2) gtgt 3

13
Condicionales, I

• El valor lógico de una forma LISP se considera
  falso si su valor LISP es NIL. En caso
  contrario, el valor lógico es verdadero.
• IF (macro)
• Sintaxis
• (if ltexpresiongt ltforma1gt forma2)
• Si el valor lógico de ltexpresióngt es verdadero,
  devuelve el valor de ltforma1gt. Si es falso,
  devuelve el valor de ltforma2gt.
• (if (gt 5 ( 2 2))
• ( 3 3)
• ( 3 4))
• gtgtgt 6

14
Condicionales, II

• WHEN (macro)
• Sintaxis
• (when ltexpresiongt
• ltforma-1gt ltforma-2gt ...ltforma-ngt)
• Si el valor lógico de ltexpresióngt es verdadero,
  ejecuta las formas ltforma-1gt, ltforma-2gt, ...
  ltforma-ngt y devuelve como valor final el valor de
  ltforma-ngt. Si es falso, devuelve NIL.
• (when (gt 5 ( 2 2))
• ( 3 3)
• ( 3 4))
• gtgtgt 7

15
Condicionales, III

• UNLESS (macro)
• Sintaxis
• (unless ltexpresiongt
• ltforma-1gt ltforma-2gt ...ltforma-ngt)
• Si el valor lógico de ltexpresióngt es falso,
  ejecuta las formas ltforma-1gt, ltforma-2gt, ...
  ltforma-ngt y devuelve como valor final el valor de
  ltforma-ngt. Si es verdadero, devuelve NIL.
• (unless (gt 5 ( 2 2))
• ( 3 3)
• ( 3 4))
• gtgtgt NIL

16
Condicionales, IV

• COND (macro)
• Sintaxis
• (cond (ltcondición-1gt
• ltforma-11gt ltforma-12gt
  ...ltforma-1-a1gt)
• (ltcondición-2gt
• ltforma-21gt ltforma-22gt
  ...ltforma-2-a2gt)
• ...
• (ltcondición-ngt
• ltforma-n1gt
• ltforma-n2gt ...ltforma-n-angt))
• Cuando encuentra una ltcondicion-igt cuyo valor
  lógico de es verdadero, ejecuta las formas
  ltforma-i1gt, ltforma-i2gt, ... ltforma-i-aigt y
  devuelve como valor final el valor de
  ltforma-i-aigt.
• (cond ((gt 5 7) ( 3 4) ( 4 5))
• ((gt 5 3) ( 5 6) ( 6 7))
• (t ( 7 8) ( 8 9))
• gtgtgt 13

17
Predicados

• Usual calcular el valor lógico de expresiones
  LISP construidos con ellos.
• Tipos de datos
• (ltpredicadogt ltexpresiongt)
• ATOM, STRINGP, NUMBERP, SYMBOLP, LISTP
• (atom a) gtgtgt T (atom NIL) gtgtgt T
• (listp a) gtgtgt NIL (listp NIL) gtgtgt T
• Numéricos
• Los operandos deben ser números
• gt, lt, lt, gt, ZEROP, PLUSP, MINUSP, EVENP, ODDP
• Identificador listas vacías
• NULL
• Es la lista vacía? .Es su valor lógico falso?
  
• (null (rest (a))) gtgtgt T

18
Predicados de igualdad, I

• EQ, EQL, EQUAL,
• ( ltnumerogt ltnumerogt)
• ( 3 ( 2 1)) gtgtgt T ( 3 3.0) gtgtgt T
• Ejemplos
• (setf x (a b 2)) (setf y (a b 2)) (setf z x)
• EQ
• Comprueba igualdad a nivel de punteros
• (eq x y) gtgtgt NIL (eq (first x) (first y)) gtgtgt T
• (eq z x) gtgtgt T
• EQL
• (eql ltexp1gt ltexp2gt) gtgtgt T
• Cuando ltexp1gt y ltexp2gt son átomos y además (eq
  ltexp1gt ltexp2gt) se evalúa a T

19
Predicados de igualdad, II

• EQUAL
• Comprueba a nivel simbólico si dos expresiones
  son iguales (al imprimirlas)
• (equal x y) gtgtgt T
• (equal 3 3.0) gtgtgt NIL
• El predicado EQUAL es más caro que el predicado
  EQ

20
Operadores lógicos, I

• AND (macro)
• (and ltexp1gt ltexp2gt ... ltexpngt)
• Si el valor lógico de todas las ltexpigt es
  verdadero, devuelve el valor de la última
  (ltexpngt). En caso contrario, devuelve NIL.
• Cuando encuentra alguna ltexpigt con valor lógico
  falso, ya no sigue evaluando el resto de las
  ltexpgt.
• (and (evenp 2) (plusp -3) (print 3)) gtgtgt NIL
• OR (macro)
• (or ltexp1gt ltexp2gt ... ltexpngt)
• Si el valor lógico de alguna de las ltexpigt es
  verdadero, devuelve su valor. En caso
  contrario, devuelve NIL.
• Cuando encuentra alguna ltexpigt con valor lógico
  verdadero, ya no sigue evaluando el resto de
  las ltexpgt.
• (or (evenp 2) (plusp -3) (print 3)) gtgtgt T
• NOT
• (not ltexp1gt)
• Si el valor lógico de ltexp1gt es verdadero,
  devuelve NIL. En caso contrario devuelve T.

21
Operadores lógicos, II

• NOT
• (not ltexpgt)
• Si el valor lógico de ltexp1gt es verdadero,
  devuelve NIL. En caso contrario devuelve T.
• (not (oddp 2)) gtgtgt T
• (not (list 2 3)) gtgtgt NIL
• (not (oddp 3) gtgtgt NIL

22
Variables locales y globales, I

• (setf dias (lunes martes miercoles))
• Es una variable global (puede ser llamada por el
  resto de instrucciones)
• Las variables globales en LISP se suelen
  denominar con
• dias-de-la-semana

23
Variables locales y globales, II

• Variables locales
• LET (macro)
• Ejemplo
• gt(prog1
• (let ((x a) (y b) z)
• (setf z (list x y))
• (list z z))
• (list 'final 'evaluacion))
• gtgtgt ((A B) (A B))
• Sintaxis
• (let ((ltvar-1gt ltvalor-inicial-1gt)
• (ltvar-2gt ltvalor-inicial-2gt)
• ...
• (ltvar-ngt ltvalor-inicial-ngt))
• ltforma-1gt
• ltforma-2gt
• ....
• ltforma-mgt)

24
Definición de funciones

• Ejemplo
• gt(defun factorial (numero)
• (cond (( numero 0) 1)
• (t ( numero (factorial (- numero
  1))))))
• gtgtgt FACTORIAL
• gt (factorial 3) gtgtgt 6
• Sintaxis
• (defun ltnombre-funciongt ltlista-argumentosgt
• ltforma-1gt
• ltforma-2gt
• ...
• ltforma-ngt)
• Comentarios
• El valor de la función es el de la última forma
  (ltforma-ngt). No se puede utilizar return para
  devolver el valor de retorno (como en el lenguaje
  C).
• Los argumentos son también variables locales.
• Valor de un símbolo como variable y como función.

25
Iteraciones

• DOTIMES
• (dotimes (i 3 (list 'final)) (list i i)) gtgtgt
  (FINAL)
• Sintaxis
• (dotimes (ltvargt ltnum-itergt ltvalor-retorno)
• ltforma-1gt ... ltforma-ngt)
• DOLIST
• (dolist (i (list a b) (list 'final)) (list i
  i)) gtgt (FINAL)
• Sintaxis
• (dolist (ltvargt ltlistagt ltvalor-retorno)
• ltforma-1gt ... ltforma-ngt)
• WHILE
• Sintaxis
• (while ltcondiciongt ltforma-1gt ... ltforma-ngt)
• LOOP
• Sintaxis (la más sencilla)
• (loop ltforma-1gt ... ltforma-ngt)
• En todos estos operadores, al utilizar (return
  ltexpresiongt), se sale de una iteración
  devolviendo el valor de ltexpresiongt.

26
Ejemplos, I

• Cálculo de la potencia de un número con
  optimización
• (defun potencia (x n)
• "Optimizacion calculo potencia"
• (cond (( n 0) 1)
• ((evenp n) (expt (potencia x (/ n 2))
  2))
• (t ( x (potencia x (- n 1))))))
• (potencia 2 3) gtgtgt 8
• Contar los átomos de cualquier expresión LISP
• gt (cuenta-atomos '(a (b c) ((d e) f)))
• gtgtgt 6
• gt(defun cuenta-atomos (expresion)
• (cond ((null expresion) 0)
• ((atom expresion) 1)
• (t ( (cuenta-atomos (first
  expresion))
• (cuenta-atomos (rest
  expresion))))))
• gtgtgt CUENTA-ATOMOS

27
Ejemplos II

• Aplanar una lista
• (aplana (a (b c) ((d e) f))) gtgtgt
• (A B C D E F)
• gt (defun aplana (lista)
• (cond
• ((null lista) NIL)
• ((atom (first lista))
• (cons
• (first lista)
• (aplana (rest lista))))
• (t (append
• (aplana (first lista))
• (aplana (rest lista))))))

28
Ejemplos III

• Número de sublistas de una lista (número de veces
  que se abre paréntesis, menos 1)
• (sublistas (a (b c) ((d e) f))) gtgtgt
• 3
• gt (defun sublistas (expresion)
• (cond ((or (null expresion) (atom
  expresion))
• 0)
• (t ( (if (atom
  (first expresion)) 0 1)
• 
  (sublistas (first expresion))
• 
  (sublistas (rest expresion))))))

29
Ejemplos IV

• Producto escalar
• (producto '(2 3) '(4 5)) gtgtgt 23
• Versión recursiva
• gt (defun producto (vector1 vector2)
• (if (or (null vector1) (null vector2))
• 0
• ( ( (first vector1) (first vector2))
• (producto (rest vector1) (rest
  vector2)))))
• Versión iterativa
• gt (defun producto (vector1 vector2)
• (let ((suma 0))
• (dotimes (i (length vector1))
• (setf suma
• ( suma ( (nth i vector1)
• (nth i
  vector2)))))
• suma))

30
Otros operadores, I

• Un mismo símbolo se puede utilizar para definir
  una variable y una función.
• (setf f a)
• (defun f (x y) (list x y))
• FUNCALL
• (funcall ltfunciongt ltarg1gt ... ltargngt)
• Son equivalentes
• (f a b) gtgtgt (A B)
• (funcall f a b)
• (progn (setf funcíon-f f) (funcall funcíon-f a
  b))
• (funcall (lambda (x y) (list x y)) a b)
• FUNCIÓN ANÓNIMA
• APPLY
• (apply ltfunciongt (ltarg1gt ... ltargngt))
• Son equivalentes
• (f a b) gtgtgt (A B)
• (apply f (a b))

31
Otros operadores, II

• MAPCAR
• (mapcar ltfunciongt ltlista1gt ... ltlistangt)
• gt (mapcar (lambda (x y) (list x x y y))
• (a b c)
• (d e f))
• gtgtgt ((A A D D) (B B E E) (C C F F))
• REMOVE
• (remove ltelementogt ltlistagt
• test ltfuncion-igualdadgt)
• (remove b (a b c)) gtgtgt (A C)
• Equivale a (remove b (a b c) test eql)
• (remove (a b) (a (a b) c)) gtgtgt (A (A B) C)
• (remove (a b) (a (a b) c) test equal) gtgtgt (A
  C)

32
Otros operadores, III

• DELETE
• Versión destructiva de REMOVE
• (setf lista (a b c))
• (remove b lista) gtgtgt (A C)
• lista gtgtgt (A B C)
• (delete b lista) gtgtgt (A C)
• lista gtgtgt (A C)
• MEMBER
• Sintaxis
• (member ltelementogt ltlistagt
• test ltfuncion-gualdadgt)
• (member b (a b c)) gtgtgt (B C)
• Equivale a (member b (a b c) test eql)
• (member (a b) (a (a b) c)) gtgtgt NIL
• gt(member (a b) (a (a b) c) test equal)
• gtgtgt ((A B) C)

33
Otros operadores, IV

• Otros operadores cuyos argumentos son funciones
• COUNT-IF, FIND-IF, REMOVE-IF, REMOVE-IF-NOT,
  DELETE-IF, DELETE-IF-NOT
• Observación
• Al utilizar ltfgt, si ltfgt es un macro se tienen
  resultados inesperados. No usarlos, por tanto.

34
Argumentos de funciones

• Número fijo de argumentos
• (defun f (x y) (list x y))
• (f a b c) gtgtgt error
• Número variable de argumentos (rest)
• Función LIST
• (defun f (x y rest z) (list x y z))
• (f a b c d) gtgtgt (A B (C D))
• Argumentos opcionales con nombre y valor por
  defecto (key)
• (defun f (x y key (z a) u (v b)) (list x y z u
  v))
• (f a b) gtgtgt (A B A NIL B)
• (f a b z c v d) gtgtgt (A B C NIL D)

35
DEBUGGING

• TRACE
• Función recursiva
• (defun factorial (n)
• (if ( n 0) 1 ( n (factorial (- n
  1)))))
• (trace factorial)
• gt (factorial 2)
• FACTORIAL call 5 depth 1 with arg 2
• FACTORIAL call 6 depth 2 with arg 1
• FACTORIAL call 7 depth 3 with arg 0
• FACTORIAL call 7 depth 3 returns value 1
• FACTORIAL call 6 depth 2 returns value 1
• FACTORIAL call 5 depth 1 returns value 2
• UNTRACE
• (untrace), (untrace factorial)
• Uso de PRINT, DESCRIBE, etc
• (describe factorial)
• No es posible uso de breakpoints, steps, etc

36
Funciones sobre strings

• Más corriente el uso de símbolos
• Funciones
• LENGTH, REVERSE
• STRING (sensible a mayúsculas),
• STRING-EQUAL
• (read-from-string ltstringgt) gtgtgt
• ltsimbologt
• (string ltsimbologt) gtgtgt ltstringgt
• (prin1-to-string ltnumerogt) gtgtgt
• ltstringgt
• (search ltstring1gt ltstring2gt)
• (subseq ltstringgt ltposiciongt) gtgtgt
• substring a partir de ltposiciongt
• (concatenate ltstringgt)

37
Arrays

• Acceso no secuencial a elementos
• En listas, el acceso a los elementos es
  secuencial
• Más eficiente el acceso a elementos en arrays que
  en listas
• gt (setf mi-array (make-array '(2 3)))
• gtgtgt 2A((NIL NIL NIL) (NIL NIL NIL))
• gt (setf (aref mi-array 0 1) 'a)
• gtgtgt A
• gt mi-array
• gtgtgt 2A((NIL A NIL) (NIL NIL NIL))
• Operadores MAKE-ARRAY, AREF

38
Estructuras, I

• Ejemplo
• gt (defstruct nombre-persona
• nombre
• (alias 'sin-alias)
• apellido)
• gtgtgt NOMBRE-PERSONA
• gt (setf persona1
• (make-nombre-persona nombre 'juan))
• gtgtgt S(NOMBRE-PERSONA
• NOMBRE JUAN ALIAS SIN-ALIAS
• APELLIDO NIL)
• gt (setf persona2
• (make-nombre-persona
• nombre 'pedro alias 'perico))
• gtgtgt S(NOMBRE-PERSONA
• NOMBRE PEDRO ALIAS PERICO
• APELLIDO NIL)

39
Estructuras, II

• gt (setf (nombre-persona-alias persona1)
• 'juanito)
• gtgtgt JUANITO
• gt persona1
• S(NOMBRE-PERSONA
• NOMBRE JUAN ALIAS JUANITO
• APELLIDO NIL)
• Funciones definidas automáticamente por LISP
• NOMBRE-PERSONA-MAKE
• NOMBRE-PERSONA -NOMBRE, NOMBRE-PERSONA -ALIAS,
  NOMBRE-PERSONA -APELLIDO

40
Alternativa a estructuras

• Las listas son una alternativa al uso de
  estructuras
• gt (setf persona1 '((NOMBRE JUAN)
• (ALIAS JUANITO)
• (APELLIDO NIL)))
• gtgtgt ((NOMBRE JUAN)
• (ALIAS JUANITO)
• (APELLIDO NIL))
• gt (assoc alias persona1)
• gtgtgt (ALIAS JUANITO)
• gt (first
• (member alias persona1
• test '(lambda (x y)
• (eql x
  (first y)))))
• gtgtgt (ALIAS JUANITO)
• ASSOC utiliza por defecto EQL

41
Ejemplos

• gt (defun producto (vector1 vector2)
• (apply ' (mapcar ' vector1 vector2)))
• gtgtgt PRODUCTO
• gt (producto '(2 3) '(4 5))
• gtgtgt 23
• gt (defun profundidad-maxima (expresion)
• (cond ((null expresion) 0)
• ((atom expresion) 1)
• (t ( 1
• (apply 'max
• (mapcar
• 'profundidad-maxim
  a
• expresion))))))
• gtgtgt PROFUNDIDAD-MAXIMA
• gt (profundidad-maxima '(1))
• gtgtgtgt 2
• gt (profundidad-maxima '((1 (2 (3))) 4))
• gtgtgtgt 5

42
Otros temas en LISP, I

• Comentarios
• Después de y hasta final de línea
• Macros
• Permiten definir operadores que no evalúan sus
  argumentos
• COND, SETF, DEFUN son macros
• (defmacro defun
• (nombre-funcion lista-argumentos
• rest formas)
• ......)
• Uso de backquote () y de arroba (_at_)
• Operadores adicionales al quote ()
• Muchas funciones ya implementadas en LISP
• SORT, LOOP generalizado, etc
• CLOS (programación orientada a objetos)

43
Otros temas en LISP, II

• Dotted-pairs (en desuso)
• gt (cons 'a 'b) gtgtgt (A . B)
• Edición, carga compilación
• COMPILE-FILE, LOAD-FILE
• Entrada-salida
• PRINT, READ, FORMAT, READ-LINE, READ-CHAR
• Otros operadores de iteración
• DO, DO (su diferencia es equivalente a la de LET
  y LET)
• (declare (special ltvariablegt))
• Argumentos opcionales (optional)
• Property-names de símbolos
• Copias de listas COPY-TREE
• Funciones sobre conjuntos UNION, INTERSECTION,
  etc. Paquetes