This page is about the computer science continuation. See analytic continuation for the use of the term in complex analysis; see Continuation War for the Finno-Soviet conflict during World War II; and see continuation application for the special type of patent application.

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)
• Standard ML of New Jersey: SMLofNJ.CONT.callcc
• C: setcontext et al. (UNIX System V and GNU libc)
• Ruby: callcc
• 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 language Unlambda 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 are also closely related via the Curry-Howard isomorphism to double negation translations from classical logic to intuitionistic logic and Peirce's law.

See also

• GOTO
• COMEFROM

External links

• Continuations Made Simple and Illustrated (http://www.ps.uni-sb.de/~duchier/python/continuations.html). An explanation, using the Python programming language.
• Continuations and Stackless Python (http://www.stackless.com/spcpaper.htm) by Christian Tismer
• setjmp/longjmp Illustrated (http://www.linuxgazette.com/issue90/raghu.html) from Linux Gazette
• On-line proceedings of the Fourth Workshop on Continuations (http://www.cs.bham.ac.uk/~hxt/cw04/cw04-program.html)
• Continuation, functions and jumps (http://www.cs.bham.ac.uk/~hxt/research/Logiccolumn8.pdf)
• Using continuations for web programming (http://www.phubuh.org/Media/Writing/Continuations/)

it:Continuazione