10.4 Continuations (original) (raw)

10.4 Continuations🔗ℹ

Continuations in The Racket Guide introduces continuations.

See Sub-expression Evaluation and Continuations and Prompts, Delimited Continuations, and Barriers for general information about continuations. Racket’s support for prompts and composable continuations [Flatt07] closely resembles Sitaram’s % andfcontrol operator [Sitaram93].

Racket installs a continuation barrier around evaluation in the following contexts, preventing full-continuation jumps into the evaluation context protected by the barrier:

applying an exception handler, an error escape handler, or an error display handler (see Exceptions);
applying a macro transformer (see Syntax Transformers), evaluating a compile-time expression, or applying a module name resolver (see Resolving Module Names);
applying a custom-port procedure (see Custom Ports), an event guard procedure (see Events), or a parameter guard procedure (see Parameters);
applying a security-guard procedure (seeSecurity Guards);
applying a will procedure (see Wills and Executors); or
evaluating or loading code from the stand-alone Racket command line (see Running Racket or GRacket).

In addition, extensions of Racket may install barriers in additional contexts. Finally,call-with-continuation-barrier applies a thunk barrier between the application and the current continuation.

Applies proc to the given args with the current continuation extended by a prompt. The prompt is tagged byprompt-tag, which must be a result from eitherdefault-continuation-prompt-tag (the default) ormake-continuation-prompt-tag. The call tocall-with-continuation-prompt returns the result ofproc.

The handler argument specifies a handler procedure to be called in tail position with respect to thecall-with-continuation-prompt call when the installed prompt is the target of an abort-current-continuation call withprompt-tag; the remaining arguments ofabort-current-continuation are supplied to the handler procedure. If handler is #f, the default handler accepts a single abort-thunk argument and calls(call-with-continuation-prompt abort-thunk prompt-tag #f); that is, the default handler re-installs the prompt and continues with a given thunk.

Resets the current continuation to that of the nearest prompt tagged by prompt-tag in the current continuation; if no such prompt exists, the exn:fail:contract:continuation exception is raised. The vs are delivered as arguments to the target prompt’s handler procedure.

The protocol for vs supplied to an abort is specific to theprompt-tag. When abort-current-continuation is used with(default-continuation-prompt-tag), generally, a single thunk should be supplied that is suitable for use with the default prompt handler. Similarly, when call-with-continuation-prompt is used with (default-continuation-prompt-tag), the associated handler should generally accept a single thunk argument.

Each thread’s continuation starts with a prompt for(default-continuation-prompt-tag) that uses the default handler, which accepts a single thunk to apply (with the prompt intact).

Creates a prompt tag that is not equal? to the result of any other value (including prior or future results frommake-continuation-prompt-tag). The optional nameargument, if supplied, specifies the name of the prompt tag for printing or object-name.

Changed in version 7.9.0.13 of package base: The name argument gives the name of the prompt tag.

Returns a constant prompt tag for which a prompt is installed at the start of every thread’s continuation; the handler for each thread’s initial prompt accepts any number of values and returns. The result ofdefault-continuation-prompt-tag is the default tag for any procedure that accepts a prompt tag.

Captures the current continuation up to the nearest prompt tagged byprompt-tag; if no such prompt exists, theexn:fail:contract:continuation exception is raised. The truncated continuation includes only continuation marks and dynamic-wind frames installed since the prompt.

The captured continuation is delivered to proc, which is called in tail position with respect to thecall-with-current-continuation call.

If the continuation argument to proc is ever applied, then it removes the portion of the current continuation up to the nearest prompt tagged by prompt-tag (not including the prompt; if no such prompt exists, the exn:fail:contract:continuation exception is raised), or up to the nearest continuation frame (if any) shared by the current and captured continuations—whichever is first. While removing continuation frames, dynamic-wind post-thunks are executed. Finally, the (unshared portion of the) captured continuation is appended to the remaining continuation, applyingdynamic-wind pre-thunks.

The arguments supplied to an applied procedure become the result values for the restored continuation. In particular, if multiple arguments are supplied, then the continuation receives multiple results.

If, at application time, a continuation barrier would be introduced by replacing the current continuation with the applied one, then the exn:fail:contract:continuation exception is raised.

A continuation can be invoked from the thread (seeThreads) other than the one where it was captured.

The call/cc binding is an alias for call-with-current-continuation.

Similar to call-with-current-continuation, but applying the resulting continuation procedure does not remove any portion of the current continuation. Instead, application always extends the current continuation with the captured continuation (without installing any prompts other than those captured in the continuation).

When call-with-composable-continuation is called, if a continuation barrier appears in the continuation before the closest prompt tagged by prompt-tag, theexn:fail:contract:continuation exception is raised (because attempting to apply the continuation would always fail).

Like call-with-current-continuation, but proc is not called in tail position, and the continuation procedure supplied toproc can only be called during the dynamic extent of thecall-with-escape-continuation call.

A continuation obtained from call-with-escape-continuation is actually a kind of prompt. Escape continuations are provided mainly for backwards compatibility, since they pre-date general prompts in Racket. In the BC implementation of Racket,call-with-escape-continuation is implemented more efficiently than call-with-current-continuation, socall-with-escape-continuation can sometimes replacecall-with-current-continuation to improve performance in those older Racket variants.

The call/ec binding is an alias for call-with-escape-continuation.

Similar to applying the continuation k, but instead of delivering values to the continuation, proc is called withk as the continuation of the call (so the result ofproc is returned to the continuation). If kis a composable continuation, the continuation of the call toproc is the current continuation extended with k.

Examples:

Added in version 7.6.0.17 of package base.

Equivalent to (call/cc (lambda (k) body ...)).

Equivalent to (call/ec (lambda (k) body ...)).

Applies thunk with a continuation barrier between the application and the current continuation. The results ofthunk are the results of thecall-with-continuation-barrier call.

Returns #t if cont, which must be a continuation, includes a prompt tagged by prompt-tag, #fotherwise.

Return #t ifv is a continuation as produced bycall-with-current-continuation,call-with-composable-continuation, orcall-with-escape-continuation, #f otherwise.

Returns #t if v is a continuation prompt tag as produced bydefault-continuation-prompt-tag or make-continuation-prompt-tag.

(dynamic-wind pre-thunk value-thunk post-thunk) → any

pre-thunk : (-> any)

value-thunk : (-> any)

post-thunk : (-> any)

(dynamic-wind pre-thunk value-thunk post-thunk) → any
pre-thunk : (-> any)
value-thunk : (-> any)
post-thunk : (-> any)

Applies its three thunk arguments in order. The value of adynamic-wind expression is the value returned byvalue-thunk. The pre-thunk procedure is invoked before calling value-thunk and post-thunk is invoked after value-thunk returns. The special properties ofdynamic-wind are manifest when control jumps into or out of the value-thunk application (either due to a prompt abort or a continuation invocation): every time control jumps into thevalue-thunk application, pre-thunk is invoked, and every time control jumps out of value-thunk,post-thunk is invoked. (No special handling is performed for jumps into or out of the pre-thunk and post-thunkapplications.)

When dynamic-wind calls pre-thunk for normal evaluation of value-thunk, the continuation of thepre-thunk application calls value-thunk (withdynamic-wind’s special jump handling) and thenpost-thunk. Similarly, the continuation of thepost-thunk application returns the value of the precedingvalue-thunk application to the continuation of the entiredynamic-wind application.

When pre-thunk is called due to a continuation jump, the continuation of the call to pre-thunk

jumps to a more deeply nested pre-thunk, if any, or jumps to the destination continuation; then
continues the same as the enclosing dynamic-wind call in the destination continuation (i.e., matching the continuation of the original dynamic-wind call up to the enclosing prompt that delimited capture).

Normally, the second part of this continuation is never reached, due to a jump in the first part. However, the second part is relevant because it enables jumps to escape continuations that are contained in the continuation of the dynamic-wind call within the destination continuation. Furthermore, it means that the continuation marks (see Continuation Marks) and parameterization (seeParameters) for pre-thunk correspond to those of the enclosing dynamic-wind call. The pre-thunk call, however, is parameterize-breaked to disable breaks (see alsoBreaks).

Similarly, when post-thunk is called due to a continuation jump, the continuation of calling post-thunk jumps to a less deeply nested post-thunk, if any, or jumps to apre-thunk protecting the destination, if any, or jumps to the destination continuation, then continues the same as the enclosingdynamic-wind call within the originating continuation for the jump. As for pre-thunk, the continuation marks and parameterization of the dynamic-wind call are in place forpost-thunk, except that the call is furtherparameterize-breaked to disable breaks.

In both cases, the destination for a jump is recomputed after eachpre-thunk or post-thunk completes. When a prompt-delimited continuation (see Prompts, Delimited Continuations, and Barriers) is captured in a post-thunk, it might be delimited and instantiated in such a way that the destination of a jump turns out to be different when the continuation is applied than when the continuation was captured. There may even be no appropriate destination, if a relevant prompt or escape continuation is not in the continuation after the restore; in that case, the first step in a pre-thunk orpost-thunk’s continuation can raise an exception.

Examples:

10.4.1 Additional Control Operators🔗ℹ

The bindings documented in this section are provided by the racket/control library, not racket/base or racket.

The racket/control library provides various control operators from the research literature on higher-order control operators, plus a few extra convenience forms. These control operators are implemented in terms of call-with-continuation-prompt,call-with-composable-continuation, etc., and they generally work sensibly together. Many are redundant; for example,reset and prompt are interchangeable.

The call/prompt binding is an alias for call-with-continuation-prompt.

The abort/cc binding is an alias for abort-current-continuation.

The call/comp binding is an alias for call-with-composable-continuation.

Returns the vs to a prompt using the default continuation prompt tag and the default abort handler.

That is, (abort v ...) is equivalent to

Example:

(% expr)(% expr handler-expr)(% expr handler-expr #:tag tag-expr)

(fcontrol v #:tag prompt-tag) → any v : any/c prompt-tag : (default-continuation-prompt-tag)

(% expr)(% expr handler-expr)(% expr handler-expr #:tag tag-expr)
(fcontrol v #:tag prompt-tag) → any v : any/c prompt-tag : (default-continuation-prompt-tag)

Sitaram’s operators [Sitaram93].

The essential reduction rules are:

(% val proc) => val

(% E[(fcontrol val)] proc) => (proc val (lambda (x) E[x]))

; where E has no %

(% val proc) => val
(% E[(fcontrol val)] proc) => (proc val (lambda (x) E[x]))
; where E has no %

When handler-expr is omitted, % is the same asprompt. If prompt-tag is provided, %uses specific prompt tags like prompt-at.

Examples:

The essential reduction rules are:

Examples:

> (prompt (+ 2 (control k (k 5))))

7

> (prompt (+ 2 (control k 5)))

5

> (prompt (+ 2 (control k (+ 1 (control k1 (k1 6))))))

7

> (prompt (+ 2 (control k (+ 1 (control k1 (k 6))))))

8

> (prompt (+ 2 (control k (control k1 (control k2 (k2 6))))))

6

> (prompt (+ 2 (control k (k 5))))
7
> (prompt (+ 2 (control k 5)))
5
> (prompt (+ 2 (control k (+ 1 (control k1 (k1 6))))))
7
> (prompt (+ 2 (control k (+ 1 (control k1 (k 6))))))
8
> (prompt (+ 2 (control k (control k1 (control k2 (k2 6))))))
6

(prompt-at prompt-tag-expr expr ...+)

(control-at prompt-tag-expr id expr ...+)

(prompt-at prompt-tag-expr expr ...+)
(control-at prompt-tag-expr id expr ...+)

Like prompt and control, but using specific prompt tags:

(prompt-at tag val) => val

(prompt-at tag E[(control-at tag k expr)]) => (prompt-at tag

((lambda (k) expr)

(lambda (v) E[v])))

; where E has no prompt-at for tag

(prompt-at tag val) => val
(prompt-at tag E[(control-at tag k expr)]) => (prompt-at tag
((lambda (k) expr)
(lambda (v) E[v])))
; where E has no prompt-at for tag

Danvy and Filinski’s operators [Danvy90].

The essential reduction rules are:

The reset and prompt forms are interchangeable.

(reset-at prompt-tag-expr expr ...+)

(shift-at prompt-tag-expr identifier expr ...+)

(reset-at prompt-tag-expr expr ...+)
(shift-at prompt-tag-expr identifier expr ...+)

Like reset and shift, but using the specified prompt tags.

(prompt0 expr ...+)

(control0 id expr ...+)

(shift0 id expr ...+)

(prompt0 expr ...+)
(control0 id expr ...+)
(shift0 id expr ...+)

Generalizations of prompt, etc. [Shan04].

The essential reduction rules are:

The reset0 and prompt0 forms are interchangeable. Furthermore, the following reductions apply:

That is, both the prompt/reset andcontrol/shift sites must agree for 0-like behavior, otherwise the non-0 behavior applies.

(prompt0-at prompt-tag-expr expr ...+)

(reset0-at prompt-tag-expr expr ...+)

(control0-at prompt-tag-expr id expr ...+)

(shift0-at prompt-tag-expr id expr ...+)

(prompt0-at prompt-tag-expr expr ...+)
(reset0-at prompt-tag-expr expr ...+)
(control0-at prompt-tag-expr id expr ...+)
(shift0-at prompt-tag-expr id expr ...+)

Variants of prompt0, etc., that accept a prompt tag.

The operators of Hieb and Dybvig [Hieb90].

The essential reduction rules are:

(spawn proc)

=> (prompt/spawn tag

(proc (lambda (proc) (abort/spawn tag proc))))

; where tag is a freshly generated prompt tag

(prompt/spawn tag val)

=> val

(prompt/spawn tag E[(abort/spawn tag proc)])

=> (proc (lambda (x) (prompt/spawn tag E[x])))

; where E has no prompt/spawn for tag

(spawn proc)
=> (prompt/spawn tag
(proc (lambda (proc) (abort/spawn tag proc))))
; where tag is a freshly generated prompt tag
(prompt/spawn tag val)
=> val
(prompt/spawn tag E[(abort/spawn tag proc)])
=> (proc (lambda (x) (prompt/spawn tag E[x])))
; where E has no prompt/spawn for tag

The operator of Queinnec and Serpette [Queinnec91].

The essential reduction rules are:

(splitter proc)

=> (prompt/splitter tag

(proc (lambda (thunk) (abort/splitter tag thunk))

(lambda (proc) (control0/splitter tag k (proc k)))))

; where tag is a freshly generated prompt tag

(prompt/splitter tag val)

=> val

(prompt/splitter tag E[(abort/splitter tag thunk)])

=> (thunk)

; where E has no prompt/splitter for tag

(prompt/splitter tag E[(control0/splitter tag k expr)])

=> ((lambda (k) expr)

(lambda (x) E[x]))

; where E has no prompt/splitter for tag

(splitter proc)
=> (prompt/splitter tag
(proc (lambda (thunk) (abort/splitter tag thunk))
(lambda (proc) (control0/splitter tag k (proc k)))))
; where tag is a freshly generated prompt tag
(prompt/splitter tag val)
=> val
(prompt/splitter tag E[(abort/splitter tag thunk)])
=> (thunk)
; where E has no prompt/splitter for tag
(prompt/splitter tag E[(control0/splitter tag k expr)])
=> ((lambda (k) expr)
(lambda (x) E[x]))
; where E has no prompt/splitter for tag

(set prompt-expr expr ...+)

(cupto prompt-expr id expr ...+)

(set prompt-expr expr ...+)
(cupto prompt-expr id expr ...+)

The operators of Gunter et al. [Gunter95].

In this library, new-prompt is an alias formake-continuation-prompt-tag, set is an alias forprompt0-at, and cupto is an alias for control0-at.

Changed in version 8.11.0.3 of package base: The new-prompt function is now really an alias for make-continuation-prompt-tag.