Type Predicates
Predicates
This package defines two Common Lisp predicates, eql and
equalp.
eq, except that if a
and b are numbers of the same type, it compares them for numeric
equality (as if by equal instead of eq). This makes a
difference only for versions of Emacs that are compiled with
floating-point support, such as Emacs 19. Emacs floats are allocated
objects just like cons cells, which means that (eq 3.0 3.0)
will not necessarily be true---if the two 3.0s were allocated
separately, the pointers will be different even though the numbers are
the same. But (eql 3.0 3.0) will always be true.
The types of the arguments must match, so (eql 3 3.0) is
still false.
Note that Emacs integers are ``direct'' rather than allocated, which
basically means (eq 3 3) will always be true. Thus eq
and eql behave differently only if floating-point numbers are
involved, and are indistinguishable on Emacs versions that don't
support floats.
There is a slight inconsistency with Common Lisp in the treatment of
positive and negative zeros. Some machines, notably those with IEEE
standard arithmetic, represent +0 and -0 as distinct
values. Normally this doesn't matter because the standard specifies
that (= 0.0 -0.0) should always be true, and this is indeed
what Emacs Lisp and Common Lisp do. But the Common Lisp standard
states that (eql 0.0 -0.0) and (equal 0.0 -0.0) should
be false on IEEE-like machines; Emacs Lisp does not do this, and in
fact the only known way to distinguish between the two zeros in Emacs
Lisp is to format them and check for a minus sign.
equal. In
particular, it compares strings case-insensitively, and it compares
numbers without regard to type (so that (equalp 3 3.0) is
true). Vectors and conses are compared recursively. All other
objects are compared as if by equal.
This function differs from Common Lisp equalp in several
respects. First, Common Lisp's equalp also compares
characters case-insensitively, which would be impractical
in this package since Emacs does not distinguish between integers
and characters. In keeping with the idea that strings are less
vector-like in Emacs Lisp, this package's equalp also will
not compare strings against vectors of integers. Finally, Common
Lisp's equalp compares hash tables without regard to
ordering, whereas this package simply compares hash tables in
terms of their underlying structure (which means vectors for Lucid
Emacs 19 hash tables, or lists for other hash tables).
Also note that the Common Lisp functions member and assoc
use eql to compare elements, whereas Emacs Lisp follows the
MacLisp tradition and uses equal for these two functions.
In Emacs, use member* and assoc* to get functions
which use eql for comparisons.
Type Predicates
Predicates