Move everything to old

[lambda.git] / hints / cps_hint_4.mdwn

diff --git a/hints/cps_hint_4.mdwn b/hints/cps_hint_4.mdwn
deleted file mode 100644 (file)
index 028504c..0000000
--- a/hints/cps_hint_4.mdwn
+++ /dev/null
@@ -1,56 +0,0 @@
-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
-