ÁTOMOS O LISTAS:

ATOM

Sabemos que dentro de las expresiones LISP se distinguen los átomos y las listas. El predicado ATOM verifica si un elemento determinado es un átomo
(atom elemento)
Devuelve nil si elemento es una lista y devuelve T en caso contrario. Debe tenerse cuidado, si se trata de un átomo simbólico, en tener claro si lo que se quiere evaluar es el síbolo o su contenido. Si no está precedido de QUOTE <'>, lo que se evalúa es el valor asociado:

                _$ (atom a)
                T
                _$ (atom 'a)
                T
                _$ (setq a '(a b c))
                (A B C)
                _$ (atom a)
                nil
                _$ (atom 'a)
                T

LISTP

Comprueba si un elemento es una lista
(listp elemento)
Devuelve T si elemento es una lista y devuelve nil en caso contrario. Obsérvese que como NIL es una lista vacía, (listp nil) devolverá T. Es decir, que todo átomo simbólico no asociado a un valor, devoverá T tanto para ATOM como para LISTP:

                _$ !b
                nil
                _$ (atom b)
                T
                _$ (listp b)
                T
                _$ (listp 'b)
                nil

ÁTOMOS SIMBÓLICOS:

VL-SYMBOLP

Identifica si un objeto especificado es o no un símbolo.
(vl-symbolp objeto)
Devuelve T si el objeto es un símbolo y nil si se trata de una constante (número o cadena) o una lista.
Este predicado ha sido incorporado por Visual LISP

                _$ (vl-symbolp 'a)
                T
                _$ (vl-symbolp 15)
                nil
                _$ (vl-symbolp "abc")
                nil
                _$ (vl-symbolp '(a b c))
                nil

BOUNDP

Cuando se trata de un átomo simbólico, puede ser necesario determinar si tiene asociado un valor. BOUNDP verifica la existencia de dicha asociación.
(boundp sím)
Devuelve T si sím tiene un valor asociado. Si no hay ningún valor asociado a sím (o se ha asociado a nil), boundp devuelve nil. Si sím es un símbolo no definido, se crea y se asocia a nil de forma automática.

NUMÉRICOS:

NUMBERP

Los átomos no simbólicos o constantes pueden ser números o cadenas. NUMBERP comprueba si el objeto es un número (real o entero)
(numberp elemento)
Devuelve T si elemento es un valor numérico y devuelve nil en caso contrario. El predicado complementario STRINGP, que comprobaría si se trata de una cadena no está definido en Visual LISP, aunque se puede encontrar entre los mensajes de error a la hora de depurar un programa. En el ejemplo que sigue el mensaje "STRINGP 2" significaría que se ha recibido un valor numérico (2) en lugar del argumento esperado del tipo cadena.

                _$ (strcat 2 "b")
                ; error: bad argument type: stringp 2

MINUSP

Tratándose de valores numéricos en ocasiones se deberá comprobar si son negativos. MINUSP realiza dicha comprobación.
(minusp número)
Devuelve T si número es negativo y nil en caso contrario. Si el argumento no es numérico se recibirá un mensaje de error.

ZEROP

Igual que en el caso anterior, cuando se trata de valores numéricos ZEROP permite comprobar si un elemento se evalúa como cero
(zerop número)
Devuelve T si número es cero y nil en caso contrario.

LISTAS VACÍAS O CONSES:

En LISP el valor asociado al símbolo NIL (condición de falso) es la lista vacía <'()>. Cualquier símbolo que evalúe como NIL, devolverá T (cierto) al pasarlo al predicado LISTP. Para comprobar que se trata efectivamente de una lista, pero que dicha lista contiene algo (aunque fuera NIL) en las versiones anteriores de AutoLISP era necesario utilizar además de LISTP otros predicados tales como BOUNDP o NULL.

NULL

Comprueba si un elemento está definido como nil
(null elemento)
Devuelve T si elemento está asociado a nil y devuelve nil en caso contrario.
Puede emplearse para probar si se ha alcanzado el fin de una lista en sustitución del predicado ENDP de Common Lisp que falta en Visual LISP

                _$ (null (caddr '(a b)))
                T

VL-CONSP

La situación descrita en el párrafo anterior se resuelve empleando en su lugar el predicado CONSP (vl-consp para Visual LISP), que comprueba si el elemento analizado evalúa como una lista no nula
(vl-consp elem-lista)
Devuelve T, si elem-lista es una lista y no está vacía, de lo contrario devuelve nil. El término CONSP se deriva de la función básica de construcción de listas, que es la función CONS. Una lista no vacía es el resultado de aplicar, al menos una vez la función CONS.
Este predicado ha sido incorporado por Visual LISP

                _$ (vl-consp a)
                nil
                _$ (setq a (cons 1 a))
                (1)
                _$ (vl-consp a)
                T

El valor contenido en la lista puede incluso ser una lista vacía:

                _$ (setq b (cons nil b))
                (nil)
                _$ (vl-consp b)
                T
                _$ (vl-consp '(())) ;equivalente a la línea anterior
                T

PERTENENCIA A UNA LISTA:

MEMBER

Es un tipo particular de predicado, que comprueba si un átomo pertenece a una lista dada.
(member expr lista)
Si expr no aparece en la lista, member devuelve NIL. En caso de encontrarlo, devuelve el resto de la lista, desde el primer caso de la expresión encontrada. Lo devuelto por MEMBER actúa como T (cierto) ya que cualquier valor no nulo actuará como la negación de NIL (not NIL), es decir, cierto. Debe tenerse cuidado en el caso de los átomos simbólicos de pasar el nombre del símbolo precedido de QUOTE <'>.

                _$ (member a '(c d 2 4 a '(a b) "a" 3.0 j))
                nil
                _$ (member 'a '(c d 2 4 a '(a b) "a" 3.0 j))
                (A (QUOTE (A B)) "a" 3.0 J)

IGUALDAD O IDENTIDAD

Dos expresiones pueden considerarse iguales sin necesidad de que sean idénticas. Los predicados EQUAL y EQ permiten comprobar estas situaciones.

EQUAL

Determina si dos expresiones son iguales
(equal expr1 expr2 [aproximación])
La función equal determina si expr1 y expr2 se evalúan igual. Cuando se comparan dos números reales (o dos listas de números reales, como en el caso de los puntos), los dos números idénticos pueden presentar ligeras diferencias derivadas de los métodos utilizados para su cálculo. Para resolver esta situación, puede utilizarse un argumento numérico optativo, aproximación, para especificar la diferencia máxima que se puede admitir entre expr1 y expr2, para que sigan considerándose iguales.

EQ

Determina si dos expresiones son idénticas
(eq expr1 expr2)
La función eq determina si expr1 y expr2 están asociadas al mismo objeto (si apuntan a la misma dirección de memoria). Devuelve T si las dos expresiones son iguales y nil en caso contrario.

                _$ (setq a (list 'm 'n 'o))
                (M N O)
                _$ (setq b (list 'm 'n 'o))
                (M N O)
                _$ (equal a b) ;las listas a y b son iguales
                T
                _$ (eq a b)    ;pero NO son la misma lista
                nil
                _$ (eq (cons 'a 'b) (cons 'a 'b))
                nil            ;cada llamada a cons crea una nueva lista
                _$ (eq '(a . b) '(a . b))
                nil

En el caso de los valores constantes, equal y eq devuelven resultados similares, salvo lo explicado respecto a los números reales.

                _$ (setq a 8)
                8
                _$ (setq b (+ 5 3))
                8
                _$ (eq a b)
                T