What is the difference between eq?, eqv?, equal?, and = in Scheme?

by

I’ll answer this question incrementally. Let’s start with the = equivalence predicate. The = predicate is used to check whether two numbers are equal. If you supply it anything else but a number then it will raise an error:

(= 2 3)     => #f
(= 2.5 2.5) => #t
(= '() '()) => error

The eq? predicate is used to check whether its two parameters respresent the same object in memory. For example:

(define x '(2 3))
(define y '(2 3))
(eq? x y)         => #f
(define y x)
(eq? x y)         => #t

Note however that there’s only one empty list '() in memory (actually the empty list doesn’t exist in memory, but a pointer to the memory location 0 is considered as the empty list). Hence when comparing empty lists eq? will always return #t (because they represent the same object in memory):

(define x '())
(define y '())
(eq? x y)      => #t

Now depending upon the implementation eq? may or may not return #t for primitive values such as numbers, strings, etc. For example:

(eq? 2 2)     => depends upon the implementation
(eq? "a" "a") => depends upon the implementation

This is where the eqv? predicate comes into picture. The eqv? is exactly the same as the eq? predicate, except that it will always return #t for same primitive values. For example:

(eqv? 2 2)     => #t
(eqv? "a" "a") => depends upon the implementation

Hence eqv? is a superset of eq? and for most cases you should use eqv? instead of eq?.

Finally we come to the equal? predicate. The equal? predicate is exactly the same as the eqv? predicate, except that it can also be used to test whether two lists, vectors, etc. have corresponding elements which satisfy the eqv? predicate. For example:

(define x '(2 3))
(define y '(2 3))
(equal? x y)      => #t
(eqv? x y)        => #f

In general:

  1. Use the = predicate when you wish to test whether two numbers are equivalent.
  2. Use the eqv? predicate when you wish to test whether two non-numeric values are equivalent.
  3. Use the equal? predicate when you wish to test whether two lists, vectors, etc. are equivalent.
  4. Don’t use the eq? predicate unless you know exactly what you’re doing.

More Related Contents:

  1. Functional Programming: what is an “improper list”?
  2. What is “point free” style (in Functional Programming)?
  3. Spanning repeatable keys
  4. What is a ‘Closure’?
  5. Elegant ways to support equivalence (“equality”) in Python classes
  6. What is (functional) reactive programming?
  7. Set operations (union, intersection) on Swift array?
  8. What is referential transparency?
  9. What is a Y-combinator? [closed]
  10. Advantages of stateless programming?
  11. How can you do anything useful without mutable state?
  12. What is the difference between procedural programming and functional programming? [closed]
  13. What is ‘Pattern Matching’ in functional languages?
  14. “Closures are poor man’s objects and vice versa” – What does this mean?
  15. What is the exact definition of a closure?
  16. Functional programming and non-functional programming
  17. What is Hindley-Milner?
  18. How to understand curry and function composition using Lodash flow?
  19. How can I get a flat result from a list comprehension instead of a nested list?
  20. In Functional Programming, what is a functor?
  21. How to compose functions in Rust?
  22. How can a time function exist in functional programming?
  23. Pass a typed function as a parameter in Dart
  24. Specification for a Functional Reactive Programming language
  25. Are there problems that cannot be written using tail recursion?
  26. So: what’s the point?
  27. What is dependent typing?
  28. Merge two arrays with alternating values
  29. Y combinator discussion in “The Little Schemer”
  30. How do I make a callable JS object with an arbitrary prototype? [duplicate]

Leave a Comment