The Scheme reports do not require that the procedure equal? terminates when the input is looped, as can happen with set-car! and such. Below is a simple implementation of an Equal? that is guaranteed to return #t or #f even for looped structures. This is possible in OCaml but not in a general way. See list compare and tree compare.

This algorithm occurs in the two level grammar for Algol 68 where it is used to test for equivalence of recursive types. 

(define (Equal? a b) 
  (let e ((a a)(b b)(h '()))(or (let be ((s h))(and (pair? s)
   (or (and (eq? a (caar s))(eq? b (cdar s)))(be (cdr s)))))
 (let ((h (cons (cons a b) h))) (or
  (eqv? a b)
  (and (pair? a)(pair? b) (e (car a)(car b) h)(e (cdr a)(cdr b) h))
  (and (vector? a)(vector? b) (let ((k (vector-length a)))(and
    (= k (vector-length b))
    (let x ((n (- k 1))) (or (negative? n)
     (and (e (vector-ref a n)(vector-ref b n) h) (x (- n 1)))))))))))))

; Trivial tests
(define a '(2 3 4))
(set-cdr! (cddr a) a)
; (2 3 4 2 3 4 ...)
(define b '(2 3 4 2 3 4))
(set-cdr! (cddr (cdddr b)) b) ; b -> (2 3 4 2 3 4 2 3 4 ...)
(Equal? a b)  ; -> #t

(define c '(2 2 2))
(define d '(2 2 3))
(set-cdr! (cddr c) c)
(set-cdr! (cdr d) d)
(Equal? c d)  ; -> #t
; both print as (2 2 2 2 2 ...)
(Equal? c (cdr c)) ; -> #t