In computing, a continuation is a way to represent the execution state (i.e. the stack) of a program at a given point. Many languages have constructs that allow a programmer to save the current state as a continuation, and then to resume execution from that state at a later point in time. This technique is typical of functional programming, but in fact many programming languages exhibit such a feature under various names; specifically:
Scheme: call/cc (short for call-with-current-continuation)
Python: (see below) used to have a continuation module, but it has been removed.
Support for continuations varies widely. A programming language supports re-entrant or first-class continuations if a continuation may be invoked repeatedly to re-enter the same context. (This use of the term "re-entrant" is distinct from its use in discussions of multitasking.)
If a continuation may only be used to escape the current context to a surrounding one, the language supports escape continuations. Many languages which do not explicitly support continuations support exception handling, which is equivalent to escape continuations and can be used for the same purposes. C's setjmp and longjmp are also equivalent: they can only be used to unwind the stack, not to restore a previously saved continuation.
First_class continuations can also be used to implement tail-call optimization. The presence of both first-class continuations and guaranteed tail-call optimization is one of the distinctions of the Scheme programming language from other Lisp languages.
Many programmers who are unaccustomed to continuations find them difficult to understand. In fact, the esoteric programming languageUnlambda includes call-to-current-continuation as one of its features solely because of its resistance to understanding. The external links below illustrate the concept in more detail.
Continuations Made Simple and Illustrated (http://www.ps.uni-sb.de/~duchier/python/continuations.html). An explanation, using the Python programming language.
In computing, a continuation is a representation of the execution state of a program (for example, the callstack or values of variables) at a certain point.
Continuations are also used in models of computation including the Actor model, process calculi, and the lambda calculus.
Continuations are the functional expression of the GOTO statement, and the same caveats apply.
The continuation behaves like an ordinary function, except that it does not return inside the caller; instead, control flow continues after the call to call/cc.
However, when f is passed to call/cc (as in the last line of the example), applying the parameter (the continuation) to 1 forces execution the program to jump to the point where call/cc was called and causes call/cc to return the value 1.
The power of call/cc lies in the ability for the continuation to be called more than once and even from outside the lexical context of the call/cc construction: there are no rules stating that the continuation has to "stay inside" call/cc.
Feeds |
Contact