Snippets for blog article on continuations

cfcc-1.scm

(lambda (n) (+ n 1))

cfcc-2.scm

c(call/cc f) --> c(f c)     ; Not Scheme. c(...) represents the current continuation.

cfcc-3.scm

(call/cc
  (lambda (return)
    (+ 2 (return 4) 1)))

cfcc-4.scm

(define (has-sym? lst s)
  (cond
    ((empty? lst) #f)               ; Nothing left, must not be present.
    ((list? (car lst))              ; Is a sublist, inspect it also.
      (or (has-sym? (car lst) s)
          (has-sym? (cdr lst) s)))
    ((eq? s (car lst)) #t)          ; Found a match, return true to the caller!
    (else
      (has-sym? (cdr lst) s))))     ; Nothing yet, keep looking...

cfcc-5.scm

(define (has-sym? lst s)
  (call/cc
    (lambda (return)
      (define (find lst)            ; Helper proc, local to lambda argument of call/cc.
        (cond
          ((empty? lst) #f)
          ((list? (car lst))
            (or (find (car lst))
                (find (cdr lst))))
          ((eq? s (car lst))
            (return #t))            ; A match! Invoke 'return' for an early-escape!
          (else
            (find (cdr lst)))))
      (find lst))))                 ; We end up here when/if 'return' is invoked.

cfcc-6.scm

(define add-10 #f)
(display
  (+ 10
     (call/cc (lambda (k)
                (set! add-10 k) 0))))

(add-10 20)
(add-10 12)

cfcc-7.scm

(define (fact n)
  (let* ((total n)
         (k (call/cc (lambda (kk) kk))))
    (set! n (- n 1))
    (set! total (* total n))
    (if (<= n 1)
      total
      (k k))))