Thank you for your comment

Beau­tiful Racket / explainers

Equality

Racket has more than one func­tion for testing the equality of two items. Why? So that special­ized equality func­tions can be opti­mized to run faster. But if you’re not comparing data types that are appro­priate, you’ll get inac­cu­rate results. Choose with care.

equal? gives the right answer for all data types, though it’s the slowest of the equality func­tions. When in doubt, use this. It dili­gently inspects every value, including values enclosed in two lists:

(equal? "foobar" (string-append "foo" "bar")) ; #t
(equal? '(1 2 3 4) (append '(1 2) '(3 4))) ; #t
(equal? 42 (* 6 7)) ; #t
(equal? 'symbol (string->symbol "symbol")) ; #t
1
2
3
4
(equal? "foobar" (string-append "foo" "bar")) ; #t
(equal? '(1 2 3 4) (append '(1 2) '(3 4))) ; #t
(equal? 42 (* 6 7)) ; #t
(equal? 'symbol (string->symbol "symbol")) ; #t
copy to clipboard

eq? is mostly restricted to symbols, small inte­gers (called fixnums), and objects. eq? can be much faster than equal? because it doesn’t actu­ally inspect the values of the two items. Rather, it simply checks if the items refer to the same chunk of memory. (Those familiar with memory oper­a­tions might know this as pointer compar­ison.)

(eq? "foobar" (string-append "foo" "bar")) ; #f
(eq? '(1 2 3 4) (append '(1 2) '(3 4))) ; #f
(eq? 42 (* 6 7)) ; #t
(eq? 'symbol (string->symbol "symbol")) ; #t
1
2
3
4
(eq? "foobar" (string-append "foo" "bar")) ; #f
(eq? '(1 2 3 4) (append '(1 2) '(3 4))) ; #f
(eq? 42 (* 6 7)) ; #t
(eq? 'symbol (string->symbol "symbol")) ; #t
copy to clipboard

Its reliance on pointer compar­ison, however, is why eq? is limited to symbols and a handful of other data types that are interned. Conversely, it’s also why you’ll see symbols chosen for situ­a­tions where speedy compar­isons are needed, because then you can use eq?.

Take extra care with eq?, which can lead newcomers astray with its ability to give seem­ingly accu­rate results in simple test cases (like numbers and strings), then seem­ingly fail when the input gets more complex. In those cases, eq? is right; your expec­ta­tions are wrong.

(eq? "foobar" "foobar") ; #t, but ...
(eq? "foobar" (string-append "foo" "bar")) ; #f
(eq? 42 (* 6 7)) ; #t, but ...
(eq? (expt 9 999) (expt 9 999)) ; #f
1
2
3
4
(eq? "foobar" "foobar") ; #t, but ...
(eq? "foobar" (string-append "foo" "bar")) ; #f
(eq? 42 (* 6 7)) ; #t, but ...
(eq? (expt 9 999) (expt 9 999)) ; #f
copy to clipboard

eqv? is like eq?, but handles char­ac­ters and all numbers consis­tently.

(eqv? 'symbol (string->symbol "symbol")) ; #t
(eqv? 42 (* 6 7)) ; #t
(eqv? (expt 9 999) (expt 9 999)) ; #t, but was #f with `eq?`
1
2
3
(eqv? 'symbol (string->symbol "symbol")) ; #t
(eqv? 42 (* 6 7)) ; #t
(eqv? (expt 9 999) (expt 9 999)) ; #t, but was #f with `eq?`
copy to clipboard

= is like eqv?, but limited to numbers, and can be faster than equal?.

(= 42 (* 6 7)) ; #t
(= '(1 2 3 4) (append '(1 2) '(3 4))) ; error
1
2
(= 42 (* 6 7)) ; #t
(= '(1 2 3 4) (append '(1 2) '(3 4))) ; error
copy to clipboard

Further

← prev next →