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