7. Predicados

Práctica 02

Escribe una función que determine si un elemento dado es miembro de una lista.

* (es-miembro 'b '(a b c d))
T

* (es-miembro 'z '(a b c d))
NIL

Teoría

Los predicados son funciones que devuelven un valor booleano: t (verdadero) o nil (falso). Por convención, los nombres de los predicados terminan con la letra p (o P en funciones compuestas como null-p que se escribe nullp).

Common Lisp trata cualquier valor distinto de nil como verdadero en contextos booleanos, pero por convención se usa t para representar explícitamente verdadero.

* (if 42
      "42 es verdadero"
      "42 es falso")
"42 es verdadero"

* (if nil
      "nil es verdadero"
      "nil es falso")
"nil es falso"

Algunos predicados básicos para trabajar con tipos:

* (null nil)
T

* (null '())
T

* (null '(a b c))
NIL

* (atom 'a)
T

* (atom '(a b))
NIL

* (listp '(a b c))
T

* (listp 'a)
NIL

* (consp '(a b c))
T

* (consp nil)
NIL

La diferencia entre listp y consp es sutil: listp devuelve verdadero tanto para listas como para nil (la lista vacía), mientras que consp solo devuelve verdadero para listas no vacías (cons cells).

Predicados numéricos:

* (zerop 0)
T

* (plusp 5)
T

* (minusp -3)
T

* (evenp 4)
T

* (oddp 3)
T

* (numberp 42)
T

* (integerp 3.14)
NIL

Predicados de comparación:

* (= 5 5)
T

* (= 5 3)
NIL

* (/= 5 3)
T

* (< 3 5)
T

* (> 10 2)
T

* (<= 5 5)
T

* (>= 10 5)
T

El predicado = solo funciona con números. Para comparar otros tipos, usa eq, eql, equal o equalp.

Para comparar símbolos y referencias:

* (eq 'a 'a)
T

* (eql 5 5)
T

* (equal '(a b c) '(a b c))
T

* (equalp "Hola" "hola")
T

Las diferencias son: - eq: compara si dos objetos son el mismo objeto en memoria (identidad). - eql: como eq, pero también funciona correctamente con números y caracteres del mismo valor. - equal: compara estructuralmente (listas, strings, etc.). - equalp: como equal, pero ignora diferencias de mayúsculas en strings y compara números de diferentes tipos.

Operadores lógicos para combinar predicados:

* (and t t)
T

* (and t nil)
NIL

* (or nil t)
T

* (or nil nil)
NIL

* (not t)
NIL

* (not nil)
T

Estos operadores evalúan de forma perezosa (short-circuit evaluation):

* (and (> 5 3) (< 2 10))
T

* (or (> 5 10) (< 2 10))
T