Go to the previous, next section.

Continuations

procedure: call-with-current-continuation procedure

Procedure must be a procedure of one argument. Packages up the current continuation (see below) as an escape procedure and passes it as an argument to procedure. The escape procedure is a Scheme procedure of one argument that, if it is later passed a value, will ignore whatever continuation is in effect at that later time and will give the value instead to the continuation that was in effect when the escape procedure was created. The escape procedure created by call-with-current-continuation has unlimited extent just like any other procedure in Scheme. It may be stored in variables or data structures and may be called as many times as desired.

The following examples show only the most common uses of this procedure. If all real programs were as simple as these examples, there would be no need for a procedure with the power of call-with-current-continuation.

(call-with-current-continuation
  (lambda (exit)
    (for-each (lambda (x)
                (if (negative? x)
                    (exit x)))
              '(54 0 37 -3 245 19))
    #t))                                =>  -3

(define list-length
  (lambda (obj)
    (call-with-current-continuation
      (lambda (return)
        (letrec ((r
                  (lambda (obj)
                    (cond ((null? obj) 0)
                          ((pair? obj) (+ (r (cdr obj)) 1))
                          (else (return #f))))))
          (r obj))))))
(list-length '(1 2 3 4))                =>  4
(list-length '(a b . c))                =>  #f

A common use of call-with-current-continuation is for structured, non-local exits from loops or procedure bodies, but in fact call-with-current-continuation is quite useful for implementing a wide variety of advanced control structures.

Whenever a Scheme expression is evaluated a continuation exists that wants the result of the expression. The continuation represents an entire (default) future for the computation. If the expression is evaluated at top level, for example, the continuation will take the result, print it on the screen, prompt for the next input, evaluate it, and so on forever. Most of the time the continuation includes actions specified by user code, as in a continuation that will take the result, multiply it by the value stored in a local variable, add seven, and give the answer to the top-level continuation to be printed. Normally these ubiquitous continuations are hidden behind the scenes and programmers don't think much about them. On the rare occasions that you may need to deal explicitly with continuations, call-with-current-continuation lets you do so by creating a procedure that acts just like the current continuation.

procedure+: continuation? object

Returns #t if object is a continuation; otherwise returns #f.

procedure+: within-continuation continuation thunk

Continuation must be a continuation produced by call-with-current-continuation. Thunk must be a procedure of no arguments. Conceptually, within-continuation invokes continuation on the result of invoking thunk, but thunk is executed in the dynamic context of continuation. In other words, the "current" continuation is abandoned before thunk is invoked.

procedure+: dynamic-wind before-thunk action-thunk after-thunk

This facility is a generalization of Common Lisp unwind-protect, designed to take into account the fact that continuations produced by call-with-current-continuation may be reentered. The arguments before-thunk, action-thunk, and after-thunk must all be procedures of no arguments (thunks).

dynamic-wind behaves as follows. First before-thunk is called. Then action-thunk is called. Finally, after-thunk is called. The value returned by action-thunk is returned as the result of dynamic-wind. After-thunk is also called if action-thunk escapes from its continuation. If action-thunk captures its continuation as an escape procedure, escapes from it, then escapes back to it, after-thunk is invoked when escaping away, and before-thunk is invoked when escaping back.

dynamic-wind is useful, for example, for ensuring the proper maintenance of locks: locking would occur in the before-thunk, protected code would appear in the action-thunk, and unlocking would occur in the after-thunk.

The following two procedures support multiple values. A future revision of the Scheme standard will support a facility similar to, but almost certainly different from, this one.

procedure+: call-with-values thunk procedure

Thunk must be a procedure of no arguments, and procedure must be a procedure. Thunk is invoked with a continuation that expects to receive multiple values; specifically, the continuation expects to receive the same number of values that procedure accepts as arguments. Thunk must return multiple values using the values procedure. Then procedure is called with the multiple values as its arguments. The result yielded by procedure is returned as the result of call-with-values.

procedure+: values object ...

Returns multiple values. The continuation in effect when this procedure is called must be a multiple-value continuation that was created by call-with-values. Furthermore it must accept as many values as there are objects.

Go to the previous, next section.