Equality Predicates

Contents Next: Checking for NIL Up: More Predicates and Previous: More Predicates and

Equality Predicates

Common LISP contains a number of equality predicates. Here are the four most commonly used:

=: (= x y) is true if and only x and y are numerically equal.
equal: As a rule of thumb, (equal x y) is true if their printed representations are the same (i.e. if they look the same when printed). Strictly, x and y are equal if and only if they are structurally isomorphic, but for present purposes, the rule of thumb is sufficient.
eq: (eq x y) is true if and only if they are the same object (in most cases, this means the same object in memory).
eql: (eql x y) is true if and only if they are either eq or they are numbers of the same type and value.

Generally = and equal are more widely used than eq and eql.

Here are some examples involving numbers:

>(= 3 3.0)
T

>(= 3/1 6/2)
T

>(eq 3 3.0)
NIL

>(eq 3 3)
T or NIL (depending on implementation of Common LISP)

>(eq 3 6/2)
T

>(eq 3.0 6/2)
NIL

>(eql 3.0 3/1)
NIL

>(eql 3 6/2)
T

>(equal 3 3)
T

>(equal 3 3.0)
T

Suppose now we have the following variable assignments:

>(setf a '(1 2 3 4))
(1 2 3 4)

>(setf b '(1 2 3 4))
(1 2 3 4)

>(setf c b)
(1 2 3 4)

Then:

>(eq a b)
NIL

>(eq b c)
T

>(equal a b)
T

>(equal b c)
T

>(eql a b)
NIL

>(eql b c)
T

>(= (first a) (first b))
T

>(eq (first a) (first b))
T or NIL (depending on implementation of Common LISP)

>(eql (first a) (first b))
T

In most cases, you will want to use either = or equal, and fortunately these are the easiest to understand. Next most frequently used is eq. Eql is used by advanced programmers.