Talk:Call-with-current-continuation

; A convenience function to apply 'display' to a list of items.
 
(define (displayList . items) (for-each display items))
 
 
; call-cc does what call/cc does, but displays what's going on before and after.
 
; 'toBeCalled' is the function that is to be called by call-with-current-continuation.
 
; If given, 'id' is a string (or whatever) that appears in every line that is
; displayed, so you can use it to tag each use of call-cc with a unique identifier,
; and therefore distinguish between them in the log.
 
(define (call-cc toBeCalled . id)
  ; The lambda expression allows me to display the continuation that is created here
  ; (the 'current continuation') before actually calling 'toBeCalled' with that
  ; continuation as its argument.
 
  ; 'return-value' captures the value that call-with-current-continuation returns, 
  ; so I can display it before returning it to the original caller.
 
  (let* (
         (tag (if (> (length id) 0) (car id) "?")) ; for when no id is given.
 
         (return-value (call-with-current-continuation 
                        (lambda (continuation) 
                          (displayList "call-cc of '" toBeCalled "' at '" tag 
                                       "' creates continuation " continuation "\n")
                          (toBeCalled continuation))))) ; the actual call-with-cc
 
    (displayList "\tcall-cc returned " return-value " to '" tag "'\n")
    return-value))

; Function make-yielding-iterator creates a closure such that each time function get-next
; is called, it returns the next element in the iteration over the given list.
 
; Get-next interacts with function yield, which is called in each pass of the  iteration.
; Yield stores the current list element in yielded-value, then calls a continuation that
; resumes in get-next; this then takes the saved value and returns it to its caller. When
; get-next is next called, it calls a continuation that resumes the iteration from where
; yield jumped out.
 
(define (make-yielding-iterator list)
  ; The initial values of these two variables are unimportant, as they are both reset
  ; before use.
 
  (define yielded-value #f)       ; The next element to be returned.
  (define return-to-get-next #f)  ; A continuation for returning control to get-next.
 
 
 
  ; resume-iteration (below) is the procedure to be called, by get-next, in order to
  ; resume iterating over the list. On all but the first use, we will want to resume
  ; from where we last yielded a value, but on the first call, we want to 'resume'
  ; by starting the iteration. Therefore, resume-iteration is initially defined as a 
  ; function for performing the iteration. Thereafter, each time yield returns control
  ; to get-next, resume-iteration is set to a continuation for resuming from where 
  ; the loop yielded, i.e. a continuation representing the remainder of the iteration.
 
  ; The first call of resume-iteration (via call/cc) also initializes return-to-get-next
  ; so that yield will return control to get-next.
 
  (define (resume-iteration get-next-continuation)
    (set! return-to-get-next get-next-continuation)
    (for-each yield list) ; The iteration itself.
    (yield #f))           ; Yield 'false' after we fall off the end of the list.
 
 
 
  ; The  functions get-next and yield call/cc each other alternately. They depend on
  ; the fact that when you call call/cc with a continuation as its argument, execution
  ; resumes where that continuation was created, and the thing returned there is a 
  ; continuation for resuming from where you came.
 
  (define (yield current-list-element)
    (set! yielded-value current-list-element) ; Save it, for get-next to return to the caller.
 
    ; Resume in get-next, giving it a continuation to come back here for the next iteration.
    ; When get-next returns here, it gives us a new continuation for going back to it next time.
 
    (set! return-to-get-next (call-cc return-to-get-next "yield")))
 
 
 
  (define (get-next)
    ; Resume in yield, giving it a continuation to come back here after the next iteration.
    ; When yield returns here, it gives us a new continuation for going back to it next time.
 
    (set! resume-iteration (call-cc resume-iteration "get-next"))
 
    yielded-value) ; Return the last-yielded value to the caller.
 
 
 
  ; 'Export' get-next by returning it from make-yielding-iterator
  ; (nothing else of this closure will be visible outside it.)
 
  get-next)   ; end of make-yielding-iterator
 
 
 
(define get-next-digit (make-yielding-iterator `(0 1 2 3 4 5 6 7 8 9)))
(define get-next-alpha (make-yielding-iterator `("a" "b" "c" "d" "e")))
 
(get-next-alpha) ; a
(get-next-digit) ;     0
(get-next-digit) ;     1
(get-next-alpha) ; b
(get-next-alpha) ; c
(get-next-digit) ;     2
(get-next-alpha) ; d
(get-next-digit) ;     3
(get-next-alpha) ; e
(get-next-digit) ;     4
(get-next-alpha) ; false
(get-next-digit) ;     5
(get-next-alpha) ; false