A *(term) from _(functional) programming where a function is used to capture the whole of the rest of the computation from a specific point in the lexical _(scope). It can be seen as a function which also has a _(side effect), i.e. full replacement of the current evaluation _(context) with another one. A continuation also accepts a parameter and functionally behaves as an identity, with the caveat that the produced value will be used in the context the continuation itself sets up. As an example, in a _(LISP)-like language if <code>c</code> is a continuation storing the context <code>(+ 3 [])</code>, the evaluation of <code>(- 5 (c 2))</code> produces <code>(+ 3 2)</code>. Let us suppose that the evaluation strategy of the language selects the redex <code>(c 2)</code> to be evaluated. In first place, the evaluation context of the redex <code>(- 5 [])</code> is replaced with that stored in the continuation <code>(+ 3 [])</code>. In second place the functional evaluation of <code>(c 2)</code> is performed. We told that a continuation functionally behaves as an identity, and therefore the value <code>2</code> is produced. This value is put back in the evaluation context, which now is <code>(+ 3 [])</code>, and the resulting expression <code>(+ 3 2)</code> is evaluated. 

Continuations as _(object)s are powerful in that passing them around as arguments allows implementing very flexible control-flow structures; Essentially, they are _(high-level) goto's. Continuations in most languages have a _(security) flaw, however, since they are not implemented with _(linear|linear logic) usage restrictions: A continuation may be freely (re-)evaluated by any part of the system that receives a reference to it.

There is a means of implementing functional-style language using continuations as a low-level control-flow model, and a standard means of embedding normal lexical scoping in terms of it, called continuation-passing style.
