LISP - Symbols

Lisp - Equality Predicates

Quiz

Lisp provides various equality predicates which can be used as per the required scenario. In this chapter, we'll uncover each of them with examples.

The following table shows the list of equality predicates −

Sr.No.	Predicate & Description
1	eq It takes two arguments and returns t if they are same identical objects, sharing the same memory location or nil otherwise.
2	eql It takes two arguments and returns t if the arguments are eq, or if they are numbers of the same type with the same value, or if they are character objects that represent the same character, or nil otherwise.
3	equal It takes two arguments and returns t if they are structurally equal or nil otherwise.
4	equalp It takes two arguments and returns t if they are structurally equal or nil otherwise.

Example - eq

eq predicate tests for identity. Two objects are same if both are equal in memory.
symbols with same name will be equal.
list if they've same structure and all elements are equal but created seperately are not equal.
In case of strings, if two same strings are pointing to same memory, then equal
eq predicate tests for numbers may vary as it is implementation specific.

Following code shows various scenarios.

main.lisp

(write(eq 'abc 'abc))                    ; T, symbols are the same objects
(terpri)
(write(eq (cons 'a 'b) (cons 'a 'b)))   ; nil, lists with the same elements are different objects
(terpri)
(setq x '(1 2 3))                       ; set x as (1 2 3)
(setq y x)                              ; set y as (1 2 3)
(write(eq x y))                         ; T,  x and y are pointing to the same list

Output

When you execute the code, it returns the following result −

T 
NIL
T

Example - eql

eql is similar to eq predicate but with more restrictions. It is same as eq for symbols.
for numbers, eql returns t if numbers have same value and same type. integer and float with same value comparison will be nil.
For character, eql is a case-sensitive comparison predicate.
For objects, eql is same as eq.

Following code shows various scenarios.

main.lisp

(write(eql 'abc 'abc))                ; T
(terpri)
(write(eql 10 10))                    ; T
(terpri)
(write(eql 10 10.0))                  ; NIL, type is different
(terpri)
(write(eql #\A #\A))                  ; T
(terpri)
(write(eql #\A #\a))                  ; NIL, case sensitive

Output

When you execute the code, it returns the following result −

T
T
NIL
T
NIL

Example - equal

equal predicate tests for structural equality.
symbols, numbers and characters are checked if they are same object in memory.
list elments are compared recursively. Two lists are equal, if they've same structure and all elements are equal.
In case of strings, all characters are compared for equality.
equal predicate tests for other data structure may vary.

Following code shows various scenarios.

main.lisp

(write(equal 'abc 'abc))          ; T
(terpri)
(write(equal 10 10))              ; T
(terpri)
(write(equal '(a b c) '(a b c)))  ; T, lists with the same structure and elements
(terpri)
(write(equal "hello" "hello"))    ; T, strings with the same characters

Output

When you execute the code, it returns the following result −

T 
T 
T 
T

Example - equalp

equalp predicate tests for structural equality similar to equal with some liberty.
numbers are same if their values are same even if their types are different.
characters and strings are compared using case-insensitive way

Following code shows various scenarios.

main.lisp

(write(equalp 'abc 'abc))          ; T
(terpri)
(write(equalp 10 10.0))            ; T
(terpri)
(write(equalp "hello" "Hello"))     ; T, strings with different case

Output

When you execute the code, it returns the following result −

T 
T 
T

Print Page