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)
NIL

```
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.

© Colin Allen & Maneesh Dhagat
March 2007