A predicate is a procedure that always returns a boolean value (#t
or
#f
). An equivalence predicate is the computational analogue of a
mathematical equivalence relation (it is symmetric, reflexive, and
transitive). Of the equivalence predicates described in this section,
eq?
is the finest or most discriminating, and equal?
is the coarsest.
Eqv?
is slightly less discriminating than eq?
.
eqv? obj1 obj2 | R5RS |
The eqv? procedure defines a useful equivalence relation on objects.
Briefly, it returns #t if obj1 and obj2 should normally be regarded
as the same object. This relation is left slightly open to interpretation,
but the following partial specification of eqv? holds for all
implementations of Scheme.
The
Note: STKLOS extends R5RS
Here are some examples: (eqv? 'a 'a) => #t (eqv? 'a 'b) => #f (eqv? 2 2) => #t (eqv? :foo :foo) => #t (eqv? :foo :bar) => #f (eqv? '() '()) => #t (eqv? 100000000 100000000) => #t (eqv? (cons 1 2) (cons 1 2)) => #f (eqv? (lambda () 1) (lambda () 2)) => #f (eqv? #f 'nil) => #f (let ((p (lambda (x) x))) (eqv? p p)) => #t The following examples illustrate cases in which the above rules do
not fully specify the behavior of (eqv? "" "") => unspecified (eqv? '#() '#()) => unspecified (eqv? (lambda (x) x) (lambda (x) x)) => unspecified (eqv? (lambda (x) x) (lambda (y) y)) => unspecified Note: In fact, the value returned by STKLOS depends of
the way code is entered and can yield See R5RS
for more details on |
eq? obj1 obj2 | R5RS |
Eq? is similar to eqv? except that in some cases it is capable of
discerning distinctions finer than those detectable by eqv? .
Note: STKLOS extends R5RS
Note: In STKLOS, comparison of character returns (eq? 'a 'a) => #t (eq? '(a) '(a)) => unspecified (eq? (list 'a) (list 'a)) => #f (eq? "a" "a") => unspecified (eq? "" "") => unspecified (eq? :foo :foo) => #t (eq? :foo :bar) => #f (eq? '() '()) => #t (eq? 2 2) => unspecified (eq? #\A #\A) => #t (unspecified in R5RS) (eq? car car) => #t (let ((n (+ 2 3))) (eq? n n)) => #t (unspecified in R5RS) (let ((x '(a))) (eq? x x)) => #t (let ((x '#())) (eq? x x)) => #t (let ((p (lambda (x) x))) (eq? p p)) => #t (eq? :foo :foo) => #t (eq? :bar bar:) => #t (eq? :bar :foo) => #f |
equal? obj1 obj2 | R5RS |
Equal? recursively compares the contents of pairs, vectors, and
strings, applying eqv? on other objects such as numbers and symbols.
A rule of thumb is that objects are generally equal? if they print the
same. Equal? may fail to terminate if its arguments are circular
data structures.
(equal? 'a 'a) => #t (equal? '(a) '(a)) => #t (equal? '(a (b) c) '(a (b) c)) => #t (equal? "abc" "abc") => #t (equal? 2 2) => #t (equal? (make-vector 5 'a) (make-vector 5 'a)) => #t |