cps: add some begins

[lambda.git] / cps_and_continuation_operators.mdwn

diff --git a/cps_and_continuation_operators.mdwn b/cps_and_continuation_operators.mdwn
index fadd34d..f619fc0 100644 (file)
--- a/cps_and_continuation_operators.mdwn
+++ b/cps_and_continuation_operators.mdwn
@@ -357,10 +357,10 @@ Here is the hardest example. Try to figure out what this function does:
                             ; is this the only case where walk returns a non-atom?
                             [(null? l) '()]
                             [(atom? (car l)) (begin
-                                               (let/cc k2
+                                               (let/cc k2 (begin
                                                  (set! resume k2) ; now what will happen when resume is called?
                                                  ; when the next line is executed, what will yield be bound to?
-                                                 (yield (car l)))
+                                                 (yield (car l))))
                                                ; when will the next line be executed?
                                                (walk (cdr l)))]
                             [else (begin
@@ -368,10 +368,10 @@ Here is the hardest example. Try to figure out what this function does:
                                     (walk (car l))
                                     (walk (cdr l)))]))]
                   [next (lambda () ; next is a thunk
-                          (let/cc k3
+                          (let/cc k3 (begin
                             (set! yield k3) ; now what will happen when yield is called?
                             ; when the next line is executed, what will resume be bound to?
-                            (resume 'blah)))]
+                            (resume 'blah))))]
                   [check (lambda (prev)
                            (let ([n (next)])
                              (cond
@@ -380,11 +380,11 @@ Here is the hardest example. Try to figure out what this function does:
                                ; when will n fail to be an atom?
                                [else #f])))])
            (lambda (lst)
-             (let ([fst (let/cc k1
+             (let ([fst (let/cc k1 (begin
                           (set! yield k1) ; now what will happen when yield is called?
                           (walk lst)
                           ; when will the next line be executed?
-                          (yield '()))])
+                          (yield '())))])
                (cond
                  [(atom? fst) (check fst)]
                  ; when will fst fail to be an atom?