Using phrases such as “the same thing” of course begs the question of what it means for two values to be “the same.” As you’ll see in future chapters, Common Lisp provides a number of type-specific equality predicates: **=** is used to compare numbers, **CHAR=** to compare characters, and so on. In this section I’ll discuss the four “generic” equality predicates—functions that can be passed any two Lisp objects and will return true if they’re equivalent and false otherwise. They are, in order of discrimination, **EQ**, **EQL**, **EQUAL**, and **EQUALP**.

tests for “object identity”—two objects are **EQ** if they’re identical. Unfortunately, the object identity of numbers and characters depends on how those data types are implemented in a particular Lisp. Thus, **EQ** may consider two numbers or two characters with the same value to be equivalent, or it may not. Implementations have enough leeway that the expression (eq 3 3) can legally evaluate to either true or false. More to the point, (eq x x) can evaluate to either true or false if the value of x happens to be a number or character.

Thus, Common Lisp defines **EQL** to behave like **EQ** except that it also is guaranteed to consider two objects of the same class representing the same numeric or character value to be equivalent. Thus, (eql 1 1) is guaranteed to be true. And (eql 1 1.0) is guaranteed to be false since the integer value 1 and the floating-point value are instances of different classes.

There are two schools of thought about when to use **EQ** and when to use **EQL**: The “use **EQ** when possible” camp argues you should use **EQ** when you know you aren’t going to be com-paring numbers or characters because (a) it’s a way to indicate that you aren’t going to be comparing numbers or characters and (b) it will be marginally more efficient since **EQ** doesn’t have to check whether its arguments are numbers or characters.

The code in this book is written in the “always use **EQL**“ style.18

The other two equality predicates, **EQUAL** and , are general in the sense that they can operate on all types of objects, but they’re much less fundamental than **EQ** or **EQL**. They each define a slightly less discriminating notion of equivalence than **EQL**, allowing different objects to be considered equivalent. There’s nothing special about the particular notions of equivalence these functions implement except that they’ve been found to be handy by Lisp programmers in the past. If these predicates don’t suit your needs, you can always define your own predicate function that compares different types of objects in the way you need.

**EQUALP** is similar to **EQUAL** except it’s even less discriminating. It considers two strings equivalent if they contain the same characters, ignoring differences in case. It also considers two characters equivalent if they differ only in case. Numbers are equivalent under **EQUALP** if they represent the same mathematical value. Thus, (equalp 1 1.0) is true. Lists with **EQUALP** elements are **EQUALP**; likewise, arrays with **EQUALP** elements are **EQUALP**. As with **EQUAL**, there are a few other data types that I haven’t covered yet for which **EQUALP** can consider two objects equivalent that neither **EQL** nor **EQUAL** will. For all other data types, **EQUALP** falls back on **EQL**.