¿Cuál es la diferencia entre eq, eql, equal y equalp, en Common Lisp? Entiendo que algunos de ellos verifican los tipos, algunos de ellos comprueban los tipos y todo eso, pero ¿cuál es cuál? ¿Cuándo es mejor usar uno que los otros?¿Cuál es la diferencia entre eq, eql, equal y equalp, en Common Lisp?
De Common Lisp: Equality Predicates
(eq x y)es cierto si y sólo sixyyson el mismo objeto idénticos.El predicado
eqles verdadero si sus argumentos soneq, o si son números del mismo tipo con el mismo valor, o si son objetos de caracteres que representan el mismo carácter.El predicado
equales verdadero si sus argumentos son objetos estructuralmente similares (isomorfos). Una regla aproximada es que dos objetos son iguales si y solo si sus representaciones impresas son las mismas.dos objetos son
equalpsi son iguales; si son personajes y satisfacen caracteres iguales, lo que ignora el caso alfabético y ciertos otros atributos de los caracteres; si son números y tienen el mismo valor numérico, incluso si son de diferentes tipos; o si tienen componentes que son todosequalp.
Éstos son algunos ejemplos de la misma página que he vinculado anteriormente:
(eq 'a 'b) is false.
(eq 'a 'a) is true.
(eq 3 3) might be true or false, depending on the implementation.
(eq 3 3.0) is false.
(eq 3.0 3.0) might be true or false, depending on the implementation.
(eq #c(3 -4) #c(3 -4))
might be true or false, depending on the implementation.
(eq #c(3 -4.0) #c(3 -4)) is false.
(eq (cons 'a 'b) (cons 'a 'c)) is false.
(eq (cons 'a 'b) (cons 'a 'b)) is false.
(eq '(a . b) '(a . b)) might be true or false.
(progn (setq x (cons 'a 'b)) (eq x x)) is true.
(progn (setq x '(a . b)) (eq x x)) is true.
(eq #\A #\A) might be true or false, depending on the implementation.
(eq "Foo" "Foo") might be true or false.
(eq "Foo" (copy-seq "Foo")) is false.
(eq "FOO" "foo") is false.
(eql 'a 'b) is false.
(eql 'a 'a) is true.
(eql 3 3) is true.
(eql 3 3.0) is false.
(eql 3.0 3.0) is true.
(eql #c(3 -4) #c(3 -4)) is true.
(eql #c(3 -4.0) #c(3 -4)) is false.
(eql (cons 'a 'b) (cons 'a 'c)) is false.
(eql (cons 'a 'b) (cons 'a 'b)) is false.
(eql '(a . b) '(a . b)) might be true or false.
(progn (setq x (cons 'a 'b)) (eql x x)) is true.
(progn (setq x '(a . b)) (eql x x)) is true.
(eql #\A #\A) is true.
(eql "Foo" "Foo") might be true or false.
(eql "Foo" (copy-seq "Foo")) is false.
(eql "FOO" "foo") is false.
(equal 'a 'b) is false.
(equal 'a 'a) is true.
(equal 3 3) is true.
(equal 3 3.0) is false.
(equal 3.0 3.0) is true.
(equal #c(3 -4) #c(3 -4)) is true.
(equal #c(3 -4.0) #c(3 -4)) is false.
(equal (cons 'a 'b) (cons 'a 'c)) is false.
(equal (cons 'a 'b) (cons 'a 'b)) is true.
(equal '(a . b) '(a . b)) is true.
(progn (setq x (cons 'a 'b)) (equal x x)) is true.
(progn (setq x '(a . b)) (equal x x)) is true.
(equal #\A #\A) is true.
(equal "Foo" "Foo") is true.
(equal "Foo" (copy-seq "Foo")) is true.
(equal "FOO" "foo") is false.
(equalp 'a 'b) is false.
(equalp 'a 'a) is true.
(equalp 3 3) is true.
(equalp 3 3.0) is true.
(equalp 3.0 3.0) is true.
(equalp #c(3 -4) #c(3 -4)) is true.
(equalp #c(3 -4.0) #c(3 -4)) is true.
(equalp (cons 'a 'b) (cons 'a 'c)) is false.
(equalp (cons 'a 'b) (cons 'a 'b)) is true.
(equalp '(a . b) '(a . b)) is true.
(progn (setq x (cons 'a 'b)) (equalp x x)) is true.
(progn (setq x '(a . b)) (equalp x x)) is true.
(equalp #\A #\A) is true.
(equalp "Foo" "Foo") is true.
(equalp "Foo" (copy-seq "Foo")) is true.
(equalp "FOO" "foo") is true.
Algunos más notas:
funciones más CL utilizan implícitamente EQL cuando se especifica ninguna prueba
Véase también CADENA-EQUAL, = y el árbol-EQUAL
En el núcleo de EQ es por lo general una comparación puntero
Y una guía aproximada:
To compare against... Use...
Objects/Structs EQ
NIL EQ (but the function NULL is more concise and probably cheaper)
T EQ (or just the value but then you don't care for the type)
Precise numbers EQL
Floats =
Characters EQL or CHAR-EQUAL
Lists, Conses, Sequences EQ (if you want the exact same object)
EQUAL (if you just care about elements)
Strings EQUAL (case-sensitive), EQUALP (case-insensitive)
STRING-EQUAL (if you throw symbols into the mix)
Trees (lists of lists) TREE-EQUAL (with appropriate :TEST argument)
Tenga en cuenta que para la eficiencia general de EQ >> >> EQL EQUAL >> EQUALP.
De here y se desliza de mi maestro
eq pruebas para ver si sus argumentos (representados por el mismo trozo de la memoria del ordenador) son mismo símbolo o no.
Por ejemplo:
(eq 'A' B) NIL
(EQ 'RAM' RAM) T
(EQ (cons 'a 'b) (cons una' B')) ; Esto se debe a diferentes llamadas se realizan tanto para los contras por lo que, obviamente, se asignarán diferentes trozos de memoria
eql primeras pruebas para ver si sus argumentos satisfacen EQ, si no, se trata de ver si son números del mismo tipo y valores.
Por ejemplo:
(eql 4 4,0) NIL
(eql 4 4) T
Ahora observamos una diferencia :
(eq 4,0 4,0) NIL; Depend en la plataforma como se describe en la primera respuesta (aceptada)
(eql 4.0 4.0) T; el tipo y el valor de los argumentos es el mismo
En algunas implementaciones (eq 4.0 4.0) puede devolver verdadero porque no está especificado en el estándar si una implementación debe mantener solo una copia de números y caracteres en la memoria, como lo hace con los símbolos). Como regla generalno use eq en números y caracteres, a menos que realmente sepa lo que está haciendo.
igual es una función de comparación “más sano”. Como regla general, puede pensar que le indica si dos objetos tienen el mismo aspecto (estructuralmente similares o isomorfos). Probablemente es el operador que desea utilizar para la igualdad general. Se comporta como eql para números, caracteres y símbolos, pero para las listas (conses) y cadenas que dice si sus elementos
Por ejemplo:
(igual 4 4) T
(igual (+ 2 2) 4) T
Ahora observamos una diferencia
(EQL (cons 'a' b) (cons 'a' b)) NIL
(iguales (cons 'a' b) (cons 'a' b)) T; igual es generalmente cierto para las cosas que imprime el mismo
equalp es como iguales, sólo más avanzada. La comparación de números es insensible al tipo. La comparación de caracteres y cadenas no distingue entre mayúsculas y minúsculas.
Por ejemplo:
(equalp (cons 'a' b) (cons 'a' b)) T; mismo como igual
Ahora observamos una diferencia
igual (4 4.0) NIL
equalp (4 4.0) T; Como la igualdad trata los números insensiblemente