eq? -- r7rs Definition

§

Kind

§

comparator;

Extended by

§

• equivalent-by-identity? (from vonuvoli);

Procedure signature

§

Procedure variants:

• ((any any) -> (boolean))
  • inputs:
    • a value of type any;
    • a value of type any;
  • output: a value of type boolean;

Exports

§

• scheme:base -- (scheme base);

Exports recursive

§

• scheme -- (scheme);

Description

§

(eq? obj_1 obj_2)

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, equal? is the coarsest, and eqv? is slightly less discriminating than eq?.

The eq? procedure is similar to eqv? except that in some cases it is capable of discerning distinctions finer than those detectable by eqv?. It must always return #f when eqv? also would, but may return #f in some cases where eqv? would return #t.

On symbols, booleans, the empty list, pairs, and records, and also on non-empty strings, vectors, and bytevectors, eq? and eqv? are guaranteed to have the same behavior. On procedures, eq? must return true if the arguments' location tags are equal. On numbers and characters, eq?'s behavior is implementation-dependent, but it will always return either true or false. On empty strings, empty vectors, and empty bytevectors, eq? may also behave differently from eqv?.

(eq? 'a 'a)                     ===>  #t
(eq? '(a) '(a))                 ===>  #unspecified
(eq? (list 'a) (list 'a))       ===>  #f
(eq? "a" "a")                   ===>  #unspecified
(eq? "" "")                     ===>  #unspecified
(eq? '() '())                   ===>  #t
(eq? 2 2)                       ===>  #unspecified
(eq? #\A #\A)                   ===>  #unspecified
(eq? car car)                   ===>  #t
(let ((n (+ 2 3)))
  (eq? n n))                    ===>  #unspecified
(let ((x '(a)))
  (eq? x x))                    ===>  #t
(let ((x '#()))
  (eq? x x))                    ===>  #t
(let ((p (lambda (x) x)))
  (eq? p p))                    ===>  #t

Rationale: It will usually be possible to implement eq? much more efficiently than eqv?, for example, as a simple pointer comparison instead of as some more complicated operation. One reason is that it is not always possible to compute eqv? of two numbers in constant time, whereas eq? implemented as pointer comparison will always finish in constant time.

---

The text herein was sourced and adapted as described in the "R7RS attribution of various text snippets" appendix.

Referenced-types

§

• any;
• boolean;