On this page:
equal?
equal-always?
eqv?
eq?
equal?/  recur
equal-always?/  recur
4.1.1 Object Identity and Comparisons
4.1.2 Equality and Hashing
equal-hash-code
equal-secondary-hash-code
equal-always-hash-code
equal-always-secondary-hash-code
eq-hash-code
eqv-hash-code
4.1.3 Implementing Equality for Custom Types
gen:  equal+  hash
gen:  equal-mode+  hash
prop:  equal+  hash
4.1.4 Honest Custom Equality
8.6

4.1 Equality

Equality is the concept of whether two values are “the same.” Racket supports a few different kinds of equality by default, although equal? is preferred for most uses.

procedure

(equal? v1 v2)  boolean?

  v1 : any/c
  v2 : any/c
Two values are equal? if and only if they are eqv?, unless otherwise specified for a particular datatype.

Datatypes with further specification of equal? include strings, byte strings, pairs, mutable pairs, vectors, boxes, hash tables, and inspectable structures. In the last six cases, equality is recursively defined; if both v1 and v2 contain reference cycles, they are equal when the infinite unfoldings of the values would be equal. See also gen:equal+hash and prop:impersonator-of.

Examples:
> (equal? 'yes 'yes)

#t

> (equal? 'yes 'no)

#f

> (equal? (* 6 7) 42)

#t

> (equal? (expt 2 100) (expt 2 100))

#t

> (equal? 2 2.0)

#f

> (let ([v (mcons 1 2)]) (equal? v v))

#t

> (equal? (mcons 1 2) (mcons 1 2))

#t

> (equal? (integer->char 955) (integer->char 955))

#t

> (equal? (make-string 3 #\z) (make-string 3 #\z))

#t

> (equal? #t #t)

#t

procedure

(equal-always? v1 v2)  boolean?

  v1 : any/c
  v2 : any/c
Indicates whether v1 and v2 are equal and will always stay equal independent of mutations. Generally, for to values to be equal-always, corresponding immutable values within v1 and v2 must be equal?, while corresponding mutable values within them must be eq?.

Two values v1 and v2 are equal-always? if and only if there exists a third value v3 such that v1 and v2 are both chaperones of v3, meaning (chaperone-of? v1 v3) and (chaperone-of? v2 v3) are both true.

For values that include no chaperones or other impersonators, v1 and v2 can be considered equal-always if they are equal?, except that corresponding mutable vectors, boxes, hash tables, strings, byte strings, mutable pairs, and mutable structures within v1 and v2 must be eq?, and equality on structures can be specialized for equal-always? through gen:equal-mode+hash.

Examples:
> (equal-always? 'yes 'yes)

#t

> (equal-always? 'yes 'no)

#f

> (equal-always? (* 6 7) 42)

#t

> (equal-always? (expt 2 100) (expt 2 100))

#t

> (equal-always? 2 2.0)

#f

> (equal-always? (list 1 2) (list 1 2))

#t

> (let ([v (mcons 1 2)]) (equal-always? v v))

#t

> (equal-always? (mcons 1 2) (mcons 1 2))

#f

> (equal-always? (integer->char 955) (integer->char 955))

#t

> (equal-always? (make-string 3 #\z) (make-string 3 #\z))

#f

> (equal-always? (string->immutable-string (make-string 3 #\z))
                 (string->immutable-string (make-string 3 #\z)))

#t

> (equal-always? #t #t)

#t

Added in version 8.5.0.3 of package base.

procedure

(eqv? v1 v2)  boolean?

  v1 : any/c
  v2 : any/c
Two values are eqv? if and only if they are eq?, unless otherwise specified for a particular datatype.

The number and character datatypes are the only ones for which eqv? differs from eq?. Two numbers are eqv? when they have the same exactness, precision, and are both equal and non-zero, both +0.0, both +0.0f0, both -0.0, both -0.0f0, both +nan.0, or both +nan.fconsidering real and imaginary components separately in the case of complex numbers. Two characters are eqv? when their char->integer results are equal.

Generally, eqv? is identical to equal? except that the former cannot recursively compare the contents of compound data types (such as lists and structs) and cannot be customized by user-defined data types. The use of eqv? is lightly discouraged in favor of equal?.

Examples:
> (eqv? 'yes 'yes)

#t

> (eqv? 'yes 'no)

#f

> (eqv? (* 6 7) 42)

#t

> (eqv? (expt 2 100) (expt 2 100))

#t

> (eqv? 2 2.0)

#f

> (let ([v (mcons 1 2)]) (eqv? v v))

#t

> (eqv? (mcons 1 2) (mcons 1 2))

#f

> (eqv? (integer->char 955) (integer->char 955))

#t

> (eqv? (make-string 3 #\z) (make-string 3 #\z))

#f

> (eqv? #t #t)

#t

procedure

(eq? v1 v2)  boolean?

  v1 : any/c
  v2 : any/c
Return #t if v1 and v2 refer to the same object, #f otherwise. As a special case among numbers, two fixnums that are = are also the same according to eq?. See also Object Identity and Comparisons.

Examples:
> (eq? 'yes 'yes)

#t

> (eq? 'yes 'no)

#f

> (eq? (* 6 7) 42)

#t

> (eq? (expt 2 100) (expt 2 100))

#f

> (eq? 2 2.0)

#f

> (let ([v (mcons 1 2)]) (eq? v v))

#t

> (eq? (mcons 1 2) (mcons 1 2))

#f

> (eq? (integer->char 955) (integer->char 955))

#t

> (eq? (make-string 3 #\z) (make-string 3 #\z))

#f

> (eq? #t #t)

#t

procedure

(equal?/recur v1 v2 recur-proc)  boolean?

  v1 : any/c
  v2 : any/c
  recur-proc : (any/c any/c -> any/c)
Like equal?, but using recur-proc for recursive comparisons (which means that reference cycles are not handled automatically). Non-#f results from recur-proc are converted to #t before being returned by equal?/recur.

Examples:
> (equal?/recur 1 1 (lambda (a b) #f))

#t

> (equal?/recur '(1) '(1) (lambda (a b) #f))

#f

> (equal?/recur '#(1 1 1) '#(1 1.2 3/4)
                (lambda (a b) (<= (abs (- a b)) 0.25)))

#t

procedure

(equal-always?/recur v1 v2 recur-proc)  boolean?

  v1 : any/c
  v2 : any/c
  recur-proc : (any/c any/c -> any/c)
Like equal-always?, but using recur-proc for recursive comparisons (which means that reference cycles are not handled automatically). Non-#f results from recur-proc are converted to #t before being returned by equal-always?/recur.

Examples:
> (equal-always?/recur 1 1 (lambda (a b) #f))

#t

> (equal-always?/recur '(1) '(1) (lambda (a b) #f))

#f

> (equal-always?/recur (vector-immutable 1 1 1) (vector-immutable 1 1.2 3/4)
                       (lambda (a b) (<= (abs (- a b)) 0.25)))

#t

4.1.1 Object Identity and Comparisons

The eq? operator compares two values, returning #t when the values refer to the same object. This form of equality is suitable for comparing objects that support imperative update (e.g., to determine that the effect of modifying an object through one reference is visible through another reference). Also, an eq? test evaluates quickly, and eq?-based hashing is more lightweight than equal?-based hashing in hash tables.

In some cases, however, eq? is unsuitable as a comparison operator, because the generation of objects is not clearly defined. In particular, two applications of + to the same two exact integers may or may not produce results that are eq?, although the results are always equal?. Similarly, evaluation of a lambda form typically generates a new procedure object, but it may re-use a procedure object previously generated by the same source lambda form.

The behavior of a datatype with respect to eq? is generally specified with the datatype and its associated procedures.

4.1.2 Equality and Hashing

All comparable values have at least one hash code an arbitrary integer (more specifically a fixnum) computed by applying a hash function to the value. The defining property of these hash codes is that equal values have equal hash codes. Note that the reverse is not true: two unequal values can still have equal hash codes. Hash codes are useful for various indexing and comparison operations, especially in the implementation of hash tables. See Hash Tables for more information.

procedure

(equal-hash-code v)  fixnum?

  v : any/c
Returns a hash code consistent with equal?. For any two calls with equal? values, the returned number is the same. A hash code is computed even when v contains a cycle through pairs, vectors, boxes, and/or inspectable structure fields. Additionally, user-defined data types can customize how this hash code is computed by implementing gen:equal+hash or gen:equal-mode+hash.

For any v that could be produced by read, if v2 is produced by read for the same input characters, the (equal-hash-code v) is the same as (equal-hash-code v2) even if v and v2 do not exist at the same time (and therefore could not be compared by calling equal?).

Changed in version 6.4.0.12 of package base: Strengthened guarantee for readable values.

procedure

(equal-secondary-hash-code v)  fixnum?

  v : any/c
Like equal-hash-code, but computes a secondary hash code suitable for use in double hashing.

procedure

(equal-always-hash-code v)  fixnum?

  v : any/c
Returns a hash code consistent with equal-always?. For any two calls with equal-always? values, the returned number is the same.

As equal-always-hash-code traverses v, immutable values within v are hashed with equal-hash-code, while mutable values within v are hashed with eq-hash-code.

procedure

(equal-always-secondary-hash-code v)  fixnum?

  v : any/c
Like equal-always-hash-code, but computes a secondary hash code suitable for use in double hashing.

procedure

(eq-hash-code v)  fixnum?

  v : any/c
Returns a hash code consistent with eq?. For any two calls with eq? values, the returned number is the same.

Equal fixnums are always eq?.

procedure

(eqv-hash-code v)  fixnum?

  v : any/c
Returns a hash code consistent with eqv?. For any two calls with eqv? values, the returned number is the same.

4.1.3 Implementing Equality for Custom Types

A generic interface (see Generic Interfaces) for types that can be compared for equality using equal?. The following methods must be implemented:

Take care to ensure that hash-proc and hash2-proc are consistent with equal-proc. Specifically, hash-proc and hash2-proc should produce the same value for any two structures for which equal-proc produces a true value.

The equal-proc is not only used for equal?, it is also used for equal?/recur, and impersonator-of?. Furthermore, if the structure type has no mutable fields, equal-proc is used for equal-always?, and chaperone-of?. Likewise hash-proc and hash2-proc are used for equal-always-hash-code and equal-always-secondary-hash-code, respectively, when the structure type has no mutable fields. Instances of these methods should follow the guidelines in Honest Custom Equality to implement all of these operations reasonably. In particular, these methods should not access mutable data unless the struct is declared mutable.

When a structure type has no gen:equal+hash or gen:equal-mode+hash implementation, then transparent structures (i.e., structures with an inspector that is controlled by the current inspector) are equal? when they are instances of the same structure type (not counting sub-types), and when they have equal? field values. For transparent structures, equal-hash-code and equal-secondary-hash-code (in the case of no mutable fields) derive hash code using the field values. For a transparent structure type with at least one mutable field, equal-always? is the same as eq?, and an equal-secondary-hash-code result is based only on eq-hash-code. For opaque structure types, equal? is the same as eq?, and equal-hash-code and equal-secondary-hash-code results are based only on eq-hash-code. If a structure has a prop:impersonator-of property, then the prop:impersonator-of property takes precedence over gen:equal+hash if the property value’s procedure returns a non-#f value when applied to the structure.

Examples:
(define (farm=? farm1 farm2 recursive-equal?)
  (and (= (farm-apples farm1)
          (farm-apples farm2))
       (= (farm-oranges farm1)
          (farm-oranges farm2))
       (= (farm-sheep farm1)
          (farm-sheep farm2))))
 
(define (farm-hash-code farm recursive-equal-hash)
  (+ (* 10000 (farm-apples farm))
     (* 100 (farm-oranges farm))
     (* 1 (farm-sheep farm))))
 
(define (farm-secondary-hash-code farm recursive-equal-hash)
  (+ (* 10000 (farm-sheep farm))
     (* 100 (farm-apples farm))
     (* 1 (farm-oranges farm))))
 
(struct farm (apples oranges sheep)
  #:methods gen:equal+hash
  [(define equal-proc farm=?)
   (define hash-proc  farm-hash-code)
   (define hash2-proc farm-secondary-hash-code)])
 
(define eastern-farm (farm 5 2 20))
(define western-farm (farm 18 6 14))
(define northern-farm (farm 5 20 20))
(define southern-farm (farm 18 6 14))

 

> (equal? eastern-farm western-farm)

#f

> (equal? eastern-farm northern-farm)

#f

> (equal? western-farm southern-farm)

#t

A generic interface (see Generic Interfaces) for types that may specify differences between equal? and equal-always?. The following methods must be implemented:

The hash-mode-proc implementation is used both for a primary hash code and secondary hash code.

When implementing these methods, follow the guidelines in Honest Custom Equality. In particular, these methods should only access mutable data if the “mode” argument is true to indicate equal? or impersonator-of?.

Implementing gen:equal-mode+hash is most useful for types that specify differences between equal? and equal-always?, such as a structure type that wraps mutable data with getter and setter procedures:

Examples:
> (define (get gs) ((getset-getter gs)))
> (define (set gs new) ((getset-setter gs) new))
> (struct getset (getter setter)
     #:methods gen:equal-mode+hash
     [(define (equal-mode-proc self other rec mode)
        (and mode (rec (get self) (get other))))
      (define (hash-mode-proc self rec mode)
        (if mode (rec (get self)) (eq-hash-code self)))])
> (define x 1)
> (define y 2)
> (define gsx (getset (lambda () x) (lambda (new) (set! x new))))
> (define gsy (getset (lambda () y) (lambda (new) (set! y new))))
> (equal? gsx gsy)

#f

> (equal-always? gsx gsy)

#f

> (set gsx 3)
> (set gsy 3)
> (equal? gsx gsy)

#t

> (equal-always? gsx gsy)

#f

> (equal-always? gsx gsx)

#t

Added in version 8.5.0.3 of package base.

A structure type property (see Structure Type Properties) that supplies an equality predicate and hashing functions for a structure type. Using the prop:equal+hash property is an alternative to using the gen:equal+hash or gen:equal-mode+hash generic interface.

A prop:equal+hash property value is a list of either three procedures (list equal-proc hash-proc hash2-proc) or two procedures (list equal-mode-proc hash-mode-proc):

When implementing these methods, follow the guidelines in Honest Custom Equality. In particular, these methods should only access mutable data if the struct is declared mutable or the mode is true.

Changed in version 8.5.0.3 of package base: Added support for two-procedure values to customize equal-always?.

4.1.4 Honest Custom Equality

Since the equal-proc or equal-mode-proc is used for more than just equal?, instances of them should follow certain guidelines to make sure that they work correctly for equal-always?, chaperone-of?, and impersonator-of?.

Due to the differences between these operations, avoid calling equal? within them. Instead, use the third argument to “recur” on the pieces, which allows equal?/recur to work properly, lets the other operations behave in their own distinct ways on the pieces, and enables some cycle detection.

good

(define (equal-proc self other rec)
  (rec (fish-size self) (fish-size other)))

bad

(define (equal-proc self other rec)
  (equal? (fish-size self) (fish-size other)))

The operations equal? and equal-always? should be symmetric, so equal-proc instances should not change their answer when the arguments swap:

good

(define (equal-proc self other rec)
  (rec (fish-size self) (fish-size other)))

bad

(define (equal-proc self other rec)
  (<= (fish-size self) (fish-size other)))

However, the operations chaperone-of? and impersonator-of? are not symmetric, so when calling the third argument to “recur” on pieces, pass the pieces in the same order they came in:

good

(define (equal-proc self other rec)
  (rec (fish-size self) (fish-size other)))

bad

(define (equal-proc self other rec)
  (rec (fish-size other) (fish-size self)))

Mutable structs will only use the custom equality for equal? and impersonator-of?, so that equal-always? and chaperone-of? don’t change on mutation. Structs that represent mutable data should either be declared mutable, or use equal-mode-proc from gen:equal-mode+hash instead of equal-proc from gen:equal+hash, and only access mutable data when the mode is true:

good

(struct mcell (value) #:mutable
  #:methods gen:equal+hash
  [(define (equal-proc self other rec)
     (rec (mcell-value self)
          (mcell-value other)))
   (define (hash-proc self rec)
     (+ (eq-hash-code struct:mcell)
        (rec (mcell-value self))))
   (define (hash2-proc self rec)
     (+ (eq-hash-code struct:mcell)
        (rec (mcell-value self))))])

bad

(struct mcell (box)
  ; not declared mutable,
  ; but represents mutable data anyway
  #:methods gen:equal+hash
  [(define (equal-proc self other rec)
     (rec (unbox (mcell-box self))
          (unbox (mcell-box other))))
   (define (hash-proc self rec)
     (+ (eq-hash-code struct:mcell)
        (rec (unbox (mcell-value self)))))
   (define (hash2-proc self rec)
     (+ (eq-hash-code struct:mcell)
        (rec (unbox (mcell-value self)))))])

also good

(struct mcell (value) #:mutable
  ; only accesses mutable data when mode is true
  #:methods gen:equal-mode+hash
  [(define (equal-mode-proc self other rec mode)
     (and mode
          (rec (mcell-value self)
               (mcell-value other))))
   (define (hash-mode-proc self rec mode)
     (if mode
         (+ (eq-hash-code struct:mcell)
            (rec (mcell-value self)))
         (eq-hash-code self)))])

still bad

(struct mcell (value) #:mutable
  ; accesses mutable data ignoring mode
  #:methods gen:equal-mode+hash
  [(define (equal-mode-proc self other rec mode)
     (rec (mcell-value self)
          (mcell-value other)))
   (define (hash-mode-proc self rec mode)
     (+ (eq-hash-code struct:mcell)
        (rec (mcell-value self))))])