This function is developed in The Seasoned Schemer pp. 165-177. It accepts a list lst and returns #t or #f depending on whether any atom appears in lst twice in a row. The list is interpreted as though it were flattened: all embedded lists are collapsed into the topmost level, and empty list elements are ignored. However, no flattened copy of the list is ever constructed.

#lang racket

(define (atom? x)
  (and (not (pair? x)) (not (null? x))))

(define delta
  (letrec ([yield (lambda (x) x)]
           [resume (lambda (x) x)]
           [walk (lambda (l)
                   (cond
                     ; this is the only case where walk terminates naturally
                     [(null? l) '()]
                     [(atom? (car l)) (begin
                                        (let/cc k2 (begin
                                          (set! resume k2) ; now calling resume with val will ignore val
                                                           ; and continue with the final line of (begin ... (walk (cdr l)))
                                          ; when the next line is executed, yield will be bound to k1 or k3
                                          (yield (car l))))
                                        ; the previous yield line will never return, but the following line will be executed when resume is called
                                        (walk (cdr l)))]
                     [else (begin
                             ; walk will only ever return when a '() is reached, and will in that case return a '()
                             (walk (car l))
                             (walk (cdr l)))]))]
           [next (lambda () ; next is a thunk
                   (let/cc k3 (begin
                     (set! yield k3) ; now calling yield with val will return val from the call to next
                     ; when the next line is executed, resume will be bound to k2
                     (resume 'blah))))]
           [check (lambda (prev)
                    (let ([n (next)])
                      (cond
                        [(eq? n prev) #t]
                        [(atom? n) (check n)]
                        ; n will fail to be an atom iff we've walked to the end of the list, and (resume 'blah) returned naturally
                        [else #f])))])
    (lambda (lst)
      (let ([fst (let/cc k1 (begin
                   (set! yield k1) ; now calling yield with val will bind fst to val and continue with the (cond ...) block below
                   (walk lst)
                   ; the next line will be executed when we've walked to the end of lst
                   (yield '())))])
        (cond
          [(atom? fst) (check fst)]
          [else #f])
        ))))

(delta '(((a b) ()) (c (d ()))))   ; ~~> #f
(delta '(((a b) ()) (b (d ()))))   ; ~~> #t
(delta '(((a b) ()) (c (d (d)))))  ; ~~> #t
(delta '(((a b c) ()) (c (d ())))) ; ~~> #t
(delta '(((a b) ()) (c (d ()) c))) ; ~~> #f
(delta '((() ()) ()))              ; ~~> #f