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? v1v2)→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? (* 67)42)

#t
> (equal? (expt 2100)(expt 2100))

#t
> (equal? 22.0)

#f
> (let ([v(mcons 12)])(equal? vv))

#t
> (equal? (mcons 12)(mcons 12))

#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? v1v2)→boolean?
v1:any/c
v2:any/c

Indicates whether v1 and v2 are equal and will always stay equal independent of mutations. Generally, for two values to be equal-always, corresponding immutable values within v1 and v2 must be equal? , while corresponding mutable values within them must be eq? . Precedents for this operator in other languages include egal [Baker93].

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? v1v3) and (chaperone-of? v2v3) 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? (* 67)42)

#t
> (equal-always? (expt 2100)(expt 2100))

#t
> (equal-always? 22.0)

#f
> (equal-always? (list 12)(list 12))

#t
> (let ([v(mcons 12)])(equal-always? vv))

#t
> (equal-always? (mcons 12)(mcons 12))

#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? v1v2)→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.f—considering 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? (* 67)42)

#t
> (eqv? (expt 2100)(expt 2100))

#t
> (eqv? 22.0)

#f
> (let ([v(mcons 12)])(eqv? vv))

#t
> (eqv? (mcons 12)(mcons 12))

#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? v1v2)→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? (* 67)42)

#t
> (eq? (expt 2100)(expt 2100))

#f
> (eq? 22.0)

#f
> (let ([v(mcons 12)])(eq? vv))

#t
> (eq? (mcons 12)(mcons 12))

#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 v1v2recur-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 11(lambda (ab)#f))

#t
> (equal?/recur '(1)'(1)(lambda (ab)#f))

#f

> (equal?/recur '#(111)'#(11.23/4)
(lambda (ab)(<= (abs (- ab))0.25)))

#t

procedure
( equal-always?/recur v1v2recur-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 11(lambda (ab)#f))

#t
> (equal-always?/recur '(1)'(1)(lambda (ab)#f))

#f

> (equal-always?/recur (vector-immutable 111)(vector-immutable 11.23/4)
(lambda (ab)(<= (abs (- ab))0.25)))

#t

4.1.1Object Identity and Comparisons🔗 i

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.2Equality and Hashing🔗 i

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 read able values.

procedure
( equal-hash-code/recur vrecur-proc)→fixnum?
v:any/c
recur-proc:(-> any/c exact-integer? )

Like equal-hash-code , but using recur-proc for recursive hashing within v.

Examples:

> (define (rational-hashx)
(cond
[(rational? x)(equal-hash-code (inexact->exact x))]
[else (equal-hash-code/recur xrational-hash)]))
> (= (rational-hash0.0)(rational-hash-0.0))

#t
> (= (rational-hash1.0)(rational-hash-1.0))

#f

> (= (rational-hash(list (list (list 4.00.0)9.0)6.0))
(rational-hash(list (list (list 40)9)6)))

#t

Added in version 8.8.0.9 of package base.

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-hash-code/recur vrecur-proc)→fixnum?
v:any/c
recur-proc:(-> any/c exact-integer? )

Like equal-always-hash-code , but using recur-proc for recursive hashing within v.

Added in version 8.8.0.9 of package base.

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.3Implementing Equality for Custom Types🔗 i

value
gen:equal+hash :any/c

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

equal-proc:(-> any/c any/c (-> any/c any/c boolean? )any/c ) — tests whether the first two arguments are equal, where both values are instances of the structure type to which the generic interface is associated (or a subtype of the structure type).
The third argument is an equal? predicate to use for recursive equality checks; use the given predicate instead of equal? to ensure that data cycles are handled properly and to work with equal?/recur (but beware that an arbitrary function can be provided to equal?/recur for recursive checks, which means that arguments provided to the predicate might be exposed to arbitrary code).
The equal-proc is called for a pair of structures only when they are not eq? , and only when they both have a gen:equal+hash value inherited from the same structure type. With this strategy, the order in which equal? receives two structures does not matter. It also means that, by default, a structure sub-type inherits the equality predicate of its parent, if any.
hash-proc:(-> any/c (-> any/c exact-integer? )exact-integer? ) — computes a hash code for the given structure, like equal-hash-code . The first argument is an instance of the structure type (or one of its subtypes) to which the generic interface is associated.
The second argument is an equal-hash-code -like procedure to use for recursive hash-code computation; use the given procedure instead of equal-hash-code to ensure that data cycles are handled properly.
Although the result of hash-proc can be any exact integer, it will be truncated for most purposes to a fixnum (e.g., for the result of equal-hash-code ). Roughly, truncation uses bitwise-and to take the lower bits of the number. Thus, variation in the hash-code computation should be reflected in the fixnum-compatible bits of hash-proc’s result. Consumers of a hash code are expected to use variation within the fixnum range appropriately, and producers are not responsible to reflect variation in hash codes across the full range of bits that fit within a fixnum.
hash2-proc:(-> any/c (-> any/c exact-integer? )exact-integer? ) — computes a secondary hash code for the given structure. This procedure is like hash-proc, but analogous to equal-secondary-hash-code .

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=?farm1farm2recursive-equal?)
(and (= (farm-applesfarm1)
(farm-applesfarm2))
(= (farm-orangesfarm1)
(farm-orangesfarm2))
(= (farm-sheepfarm1)
(farm-sheepfarm2))))

(define (farm-hash-codefarmrecursive-equal-hash)
(+ (* 10000(farm-applesfarm))
(* 100(farm-orangesfarm))
(* 1(farm-sheepfarm))))

(define (farm-secondary-hash-codefarmrecursive-equal-hash)
(+ (* 10000(farm-sheepfarm))
(* 100(farm-applesfarm))
(* 1(farm-orangesfarm))))

(struct farm(applesorangessheep)
#:methodsgen:equal+hash
[(define equal-procfarm=?)
(define hash-procfarm-hash-code)
(define hash2-procfarm-secondary-hash-code)])

(define eastern-farm(farm5220))
(define western-farm(farm18614))
(define northern-farm(farm52020))
(define southern-farm(farm18614))

> (equal? eastern-farmwestern-farm)

#f
> (equal? eastern-farmnorthern-farm)

#f
> (equal? western-farmsouthern-farm)

#t

Changed in version 8.7.0.5 of package base: Added a check so that omitting any of equal-proc, hash-proc, and hash2-proc is now a syntax error.

value
gen:equal-mode+hash :any/c

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

equal-mode-proc:(-> any/c any/c (-> any/c any/c boolean? )boolean? any/c ) — the first two arguments are the values to compare, the third argument is an equality function to use for recursive comparisons, and the last argument is the mode: #t for an equal? or impersonator-of? comparison or #f for an equal-always? or chaperone-of? comparison.
hash-mode-proc:(-> any/c (-> any/c exact-integer? )boolean? exact-integer? ) — the first argument is the value to compute a hash code for, the second argument is a hashing function to use for recursive hashing, and the last argument is the mode: #t for equal? hashing or #f for equal-always? hashing.

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 (getgs)((getset-gettergs)))
> (define (set gsnew )((getset-settergs)new ))

> (struct getset(gettersetter)
#:methodsgen:equal-mode+hash
[(define (equal-mode-procselfotherrecmode)
(and mode(rec(getself)(getother))))
(define (hash-mode-procselfrecmode)
(if mode(rec(getself))(eq-hash-code self)))])
> (define x1)
> (define y2)
> (define gsx(getset(lambda ()x)(lambda (new )(set! xnew ))))
> (define gsy(getset(lambda ()y)(lambda (new )(set! ynew ))))
> (equal? gsxgsy)

#f
> (equal-always? gsxgsy)

#f
> (set gsx3)
> (set gsy3)
> (equal? gsxgsy)

#t
> (equal-always? gsxgsy)

#f
> (equal-always? gsxgsx)

#t

Added in version 8.5.0.3 of package base.
Changed in version 8.7.0.5: Added a check so that omitting either equal-mode-proc or hash-mode-proc is now a syntax error.

value
prop:equal+hash :struct-type-property?

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-prochash-prochash2-proc) or two procedures (list equal-mode-prochash-mode-proc):

The three-procedure case corresponds to the procedures of gen:equal-hash:
- equal-proc:(-> any/c any/c (-> any/c any/c boolean? )any/c )
- hash-proc:(-> any/c (-> any/c exact-integer? )exact-integer? )
- hash2-proc:(-> any/c (-> any/c exact-integer? )exact-integer? )
The two-procedure case corresponds to the procedures of gen:equal-mode-hash:
- equal-mode-proc:(-> any/c any/c (-> any/c any/c boolean? )boolean? any/c )
- hash-mode-proc:(-> any/c (-> any/c exact-integer? )boolean? exact-integer? )

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.4Honest Custom Equality🔗 i

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-procselfotherrec)
(rec(fish-sizeself)(fish-sizeother)))

bad
(define (equal-procselfotherrec)
(equal? (fish-sizeself)(fish-sizeother)))

Don’t use the third argument to “recur” on counts of elements. When a data structure cares about discrete numbers, it can use = on those, not equal? or “recur”. Using “recur” on counts is bad when a “recur” argument from equal?/recur is too tolerant on numbers within some range of each other.

good
(define (equal-procselfotherrec)
(and (= (tuple-lengthself)(tuple-lengthother))
(for/and ([i(in-range (tuple-lengthself))])
(rec((tuple-getterself)i)
((tuple-getterother)i)))))

bad
(define (equal-procselfotherrec)
(and (rec(tuple-lengthself)(tuple-lengthother))
(for/and ([i(in-range (tuple-lengthself))])
(rec((tuple-getterself)i)
((tuple-getterother)i)))))

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-procselfotherrec)
(rec(fish-sizeself)(fish-sizeother)))

bad
(define (equal-procselfotherrec)
(<= (fish-sizeself)(fish-sizeother)))

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-procselfotherrec)
(rec(fish-sizeself)(fish-sizeother)))

bad
(define (equal-procselfotherrec)
(rec(fish-sizeother)(fish-sizeself)))

The operations equal-always? and chaperone-of? shouldn’t change on mutation, so equal-proc instances should not access potentially-mutable data. This includes avoiding string=? , since strings can be mutable. Type-specific equality functions for immutable types, such as symbol=? , are fine.

fine
(define (equal-procselfotherrec)
;symbols are immutable: no problem
(symbol=? (thing-nameself)(thing-nameother)))

bad
(define (equal-procselfotherrec)
;strings can be mutable: accesses mutable data
(string=? (thing-nameself)(thing-nameother)))

Declaring a struct as mutable makes equal-always? and chaperone-of? avoid using equal-proc, so equal-proc instances are free to access mutable data if the struct is declared mutable:

good
(struct mcell(value)#:mutable
#:methodsgen:equal+hash
[(define (equal-procselfotherrec)
(rec(mcell-valueself)
(mcell-valueother)))
(define (hash-procselfrec)
(+ (eq-hash-code struct:mcell)
(rec(mcell-valueself))))
(define (hash2-procselfrec)
(+ (eq-hash-code struct:mcell)
(rec(mcell-valueself))))])

bad
(struct mcell(box )
;not declared mutable,
;but represents mutable data anyway
#:methodsgen:equal+hash
[(define (equal-procselfotherrec)
(rec(unbox (mcell-boxself))
(unbox (mcell-boxother))))
(define (hash-procselfrec)
(+ (eq-hash-code struct:mcell)
(rec(unbox (mcell-valueself)))))
(define (hash2-procselfrec)
(+ (eq-hash-code struct:mcell)
(rec(unbox (mcell-valueself)))))])

Another way for a struct to control access to mutable data is by implementing gen:equal-mode+hash instead of gen:equal+hash . When the mode is true, equal-mode-proc instances are free to access mutable data, and when the mode is false, they shouldn’t:

also good
(struct mcell(value)#:mutable
;only accesses mutable data when mode is true
#:methodsgen:equal-mode+hash
[(define (equal-mode-procselfotherrecmode)
(and mode
(rec(mcell-valueself)
(mcell-valueother))))
(define (hash-mode-procselfrecmode)
(if mode
(+ (eq-hash-code struct:mcell)
(rec(mcell-valueself)))
(eq-hash-code self)))])

still bad
(struct mcell(value)#:mutable
;accesses mutable data ignoring mode
#:methodsgen:equal-mode+hash
[(define (equal-mode-procselfotherrecmode)
(rec(mcell-valueself)
(mcell-valueother)))
(define (hash-mode-procselfrecmode)
(+ (eq-hash-code struct:mcell)
(rec(mcell-valueself))))])

4.1.5Combining Hash Codes🔗 i

(require racket/hash-code ) package: base

The bindings documented in this section are provided by the racket/hash-code library, not racket/base or racket.

Added in version 8.8.0.5 of package base.

procedure
( hash-code-combine hc...)→fixnum?
hc:exact-integer?

Combines the hcs into a hash code that depends on the order of the inputs. Useful for combining the hash codes of different fields in a structure.

Examples:

> (require racket/hash-code)

> (struct ordered-triple(fstsndthd)
#:methodsgen:equal+hash
[(define (equal-procselfotherrec)
(and (rec(ordered-triple-fstself)(ordered-triple-fstother))
(rec(ordered-triple-sndself)(ordered-triple-sndother))
(rec(ordered-triple-thdself)(ordered-triple-thdother))))
(define (hash-procselfrec)
(hash-code-combine (eq-hash-code struct:ordered-triple)
(rec(ordered-triple-fstself))
(rec(ordered-triple-sndself))
(rec(ordered-triple-thdself))))
(define (hash2-procselfrec)
(hash-code-combine (eq-hash-code struct:ordered-triple)
(rec(ordered-triple-fstself))
(rec(ordered-triple-sndself))
(rec(ordered-triple-thdself))))])
> (equal? (ordered-triple'A'B'C)(ordered-triple'A'B'C))

#t

> (= (equal-hash-code (ordered-triple'A'B'C))
(equal-hash-code (ordered-triple'A'B'C)))

#t
> (equal? (ordered-triple'A'B'C)(ordered-triple'C'B'A))

#f

> (= (equal-hash-code (ordered-triple'A'B'C))
(equal-hash-code (ordered-triple'C'B'A)))

#f
> (equal? (ordered-triple'A'B'C)(ordered-triple'C'A'B))

#f

> (= (equal-hash-code (ordered-triple'A'B'C))
(equal-hash-code (ordered-triple'C'A'B)))

#f

With one argument, (hash-code-combine hc) mixes the hash code so that it isn’t just hc.

Examples:

> (require racket/hash-code)

> (struct wrap(value)
#:methodsgen:equal+hash
[(define (equal-procselfotherrec)
(rec(wrap-valueself)(wrap-valueother)))
(define (hash-procselfrec)
;demonstrates `hash-code-combine` with only one argument
;but it's good to combine `(eq-hash-code struct:wrap)` too
(hash-code-combine (rec(wrap-valueself))))
(define (hash2-procselfrec)
(hash-code-combine (rec(wrap-valueself))))])
> (equal? (wrap'A)(wrap'A))

#t

> (= (equal-hash-code (wrap'A))
(equal-hash-code (wrap'A)))

#t
> (equal? (wrap'A)'A)

#f

> (= (equal-hash-code (wrap'A))
(equal-hash-code 'A))

#f

procedure
( hash-code-combine-unordered hc...)→fixnum?
hc:exact-integer?

Combines the hcs into a hash code that does not depend on the order of the inputs. Useful for combining the hash codes of elements of an unordered set.

Examples:

> (require racket/hash-code)

> (struct flip-triple(leftmidright)
#:methodsgen:equal+hash
[(define (equal-procselfotherrec)
(and (rec(flip-triple-midself)(flip-triple-midother))
(or
(and (rec(flip-triple-leftself)(flip-triple-leftother))
(rec(flip-triple-rightself)(flip-triple-rightother)))
(and (rec(flip-triple-leftself)(flip-triple-rightother))
(rec(flip-triple-rightself)(flip-triple-leftother))))))
(define (hash-procselfrec)
(hash-code-combine (eq-hash-code struct:flip-triple)
(rec(flip-triple-midself))
(hash-code-combine-unordered
(rec(flip-triple-leftself))
(rec(flip-triple-rightself)))))
(define (hash2-procselfrec)
(hash-code-combine (eq-hash-code struct:flip-triple)
(rec(flip-triple-midself))
(hash-code-combine-unordered
(rec(flip-triple-leftself))
(rec(flip-triple-rightself)))))])
> (equal? (flip-triple'A'B'C)(flip-triple'A'B'C))

#t

> (= (equal-hash-code (flip-triple'A'B'C))
(equal-hash-code (flip-triple'A'B'C)))

#t
> (equal? (flip-triple'A'B'C)(flip-triple'C'B'A))

#t

> (= (equal-hash-code (flip-triple'A'B'C))
(equal-hash-code (flip-triple'C'B'A)))

#t
> (equal? (flip-triple'A'B'C)(flip-triple'C'A'B))

#f

> (= (equal-hash-code (flip-triple'A'B'C))
(equal-hash-code (flip-triple'C'A'B)))

#f

> (struct rotate-triple(rockpaperscissors)
#:methodsgen:equal+hash
[(define (equal-procselfotherrec)
(or
(and (rec(rotate-triple-rockself)(rotate-triple-rockother))
(rec(rotate-triple-paperself)(rotate-triple-paperother))
(rec(rotate-triple-scissorsself)(rotate-triple-scissorsother)))
(and (rec(rotate-triple-rockself)(rotate-triple-paperother))
(rec(rotate-triple-paperself)(rotate-triple-scissorsother))
(rec(rotate-triple-scissorsself)(rotate-triple-rockother)))
(and (rec(rotate-triple-rockself)(rotate-triple-scissorsother))
(rec(rotate-triple-paperself)(rotate-triple-rockother))
(rec(rotate-triple-scissorsself)(rotate-triple-paperother)))))
(define (hash-procselfrec)
(define r(rec(rotate-triple-rockself)))
(define p(rec(rotate-triple-paperself)))
(define s(rec(rotate-triple-scissorsself)))
(hash-code-combine
(eq-hash-code struct:rotate-triple)
(hash-code-combine-unordered
(hash-code-combine rp)
(hash-code-combine ps)
(hash-code-combine sr))))
(define (hash2-procselfrec)
(define r(rec(rotate-triple-rockself)))
(define p(rec(rotate-triple-paperself)))
(define s(rec(rotate-triple-scissorsself)))
(hash-code-combine
(eq-hash-code struct:rotate-triple)
(hash-code-combine-unordered
(hash-code-combine rp)
(hash-code-combine ps)
(hash-code-combine sr))))])
> (equal? (rotate-triple'A'B'C)(rotate-triple'A'B'C))

#t

> (= (equal-hash-code (rotate-triple'A'B'C))
(equal-hash-code (rotate-triple'A'B'C)))

#t
> (equal? (rotate-triple'A'B'C)(rotate-triple'C'B'A))

#f

> (= (equal-hash-code (rotate-triple'A'B'C))
(equal-hash-code (rotate-triple'C'B'A)))

#f
> (equal? (rotate-triple'A'B'C)(rotate-triple'C'A'B))

#t

> (= (equal-hash-code (rotate-triple'A'B'C))
(equal-hash-code (rotate-triple'C'A'B)))

#t

procedure
( hash-code-combine* hc...hcs)→fixnum?
hc:exact-integer?
hcs:(listof exact-integer? )

Like hash-code-combine , but the last argument is used as a list of arguments for hash-code-combine , so (hash-code-combine* hc... hcs) is the same as (apply hash-code-combine hc... hcs). In other words, the relationship between hash-code-combine and hash-code-combine* is similar to the one between list and list* .

procedure
( hash-code-combine-unordered* hc...hcs)→fixnum?
hc:exact-integer?
hcs:(listof exact-integer? )

Like hash-code-combine-unordered , but the last argument is used as a list of arguments for hash-code-combine-unordered , so (hash-code-combine-unordered* hc... hcs) is the same as (apply hash-code-combine-unordered hc... hcs). In other words, the relationship between hash-code-combine-unordered and hash-code-combine-unordered* is similar to the one between list and list* .

top ← prev up next →