Continuation

First-class continuations

First-class continuations are a language's ability to completely control the execution order of instructions. They can be used to jump to a function that produced the call to the current function, or to a function that has previously exited. One can think of a first-class continuation as saving the execution state of the program. True first-class continuations do not save program data – unlike a process image – only the execution context. This is illustrated by the "continuation sandwich" description:

Say you're in the kitchen in front of the refrigerator, thinking about a sandwich. You take a continuation right there and stick it in your pocket. Then you get some turkey and bread out of the refrigerator and make yourself a sandwich, which is now sitting on the counter. You invoke the continuation in your pocket, and you find yourself standing in front of the refrigerator again, thinking about a sandwich. But fortunately, there's a sandwich on the counter, and all the materials used to make it are gone. So you eat it. :-)

In this description, the sandwich is part of the program data (e.g., an object on the heap), and rather than calling a "make sandwich" routine and then returning, the person called a "make sandwich with current continuation" routine, which creates the sandwich and then continues where execution left off.

Scheme was the first full production system providing first "catch" and then call/cc. Bruce Duba introduced call/cc into SML.

Continuations are also used in models of computation including denotational semantics, the actor model, process calculi, and lambda calculus. These models rely on programmers or semantics engineers to write mathematical functions in the so-called continuation-passing style. This means that each function consumes a function that represents the rest of the computation relative to this function call. To return a value, the function calls this "continuation function" with a return value; to abort the computation it returns a value.

Functional programmers who write their programs in continuation-passing style gain the expressive power to manipulate the flow of control in arbitrary ways. The cost is that they must maintain the invariants of control and continuations by hand, which can be a highly complex undertaking (but see 'continuation-passing style' below).

Uses

Continuations simplify and clarify the implementation of several common design patterns, including coroutines/green threads and exception handling, by providing the basic, low-level primitive which unifies these seemingly unconnected patterns. Continuations can provide elegant solutions to some difficult high-level problems, like programming a web server that supports multiple pages, accessed by the use of the forward and back buttons and by following links. The Smalltalk Seaside web framework uses continuations to great effect, allowing one to program the web server in procedural style, by switching continuations when switching pages.

More complex constructs for which "continuations provide an elegant description" also exist. For example, in C, longjmp can be used to jump from the middle of one function to another, provided the second function lies deeper in the stack (if it is waiting for the first function to return, possibly among others). Other more complex examples include coroutines in Simula 67, Lua, and Perl; tasklets in Stackless Python; generators in Icon and Python; continuations in Scala (starting in 2.8); fibers in Ruby (starting in 1.9.1); the backtracking mechanism in Prolog; monads in functional programming; and threads.

Examples

The Scheme programming language includes the control operator call-with-current-continuation (abbreviated as: call/cc) with which a Scheme program can manipulate the flow of control:

<span id="mwfg"></span><span class="w" id="mwfw"> </span><span class="p" id="mwgA">(</span><span class="k" id="mwgQ">define</span><span class="w" id="mwgg"> </span><span class="nv" id="mwgw">the-continuation</span><span class="w" id="mwhA"> </span><span class="no" id="mwhQ">#f</span><span class="p" id="mwhg">)</span> <span class="w" id="mwhw"> </span><span class="p" id="mwiA">(</span><span class="k" id="mwiQ">define</span><span class="w" id="mwig"> </span><span class="p" id="mwiw">(</span><span class="nf" id="mwjA">test</span><span class="p" id="mwjQ">)</span> <span class="w" id="mwjg"> </span><span class="p" id="mwjw">(</span><span class="k" id="mwkA">let</span><span class="w" id="mwkQ"> </span><span class="p" id="mwkg">((</span><span class="nf" id="mwkw">i</span><span class="w" id="mwlA"> </span><span class="mi" id="mwlQ">0</span><span class="p" id="mwlg">))</span> <span class="w" id="mwlw"> </span><span class="c1" id="mwmA">; call/cc calls its first function argument, passing</span> <span class="w" id="mwmQ"> </span><span class="c1" id="mwmg">; a continuation variable representing this point in</span> <span class="w" id="mwmw"> </span><span class="c1" id="mwnA">; the program as the argument to that function.</span> <span class="w" id="mwnQ"> </span><span class="c1" id="mwng">;</span> <span class="w" id="mwnw"> </span><span class="c1" id="mwoA">; In this case, the function argument assigns that</span> <span class="w" id="mwoQ"> </span><span class="c1" id="mwog">; continuation to the variable the-continuation.</span> <span class="w" id="mwow"> </span><span class="c1" id="mwpA">;</span> <span class="w" id="mwpQ"> </span><span class="p" id="mwpg">(</span><span class="nb" id="mwpw">call/cc</span><span class="w" id="mwqA"> </span><span class="p" id="mwqQ">(</span><span class="k" id="mwqg">lambda</span><span class="w" id="mwqw"> </span><span class="p" id="mwrA">(</span><span class="nf" id="mwrQ">k</span><span class="p" id="mwrg">)</span><span class="w" id="mwrw"> </span><span class="p" id="mwsA">(</span><span class="k" id="mwsQ">set!</span><span class="w" id="mwsg"> </span><span class="nv" id="mwsw">the-continuation</span><span class="w" id="mwtA"> </span><span class="nv" id="mwtQ">k</span><span class="p" id="mwtg">)))</span> <span class="w" id="mwtw"> </span><span class="c1" id="mwuA">;</span> <span class="w" id="mwuQ"> </span><span class="c1" id="mwug">; The next time the-continuation is called, we start here.</span> <span class="w" id="mwuw"> </span><span class="p" id="mwvA">(</span><span class="k" id="mwvQ">set!</span><span class="w" id="mwvg"> </span><span class="nv" id="mwvw">i</span><span class="w" id="mwwA"> </span><span class="p" id="mwwQ">(</span><span class="nb" id="mwwg">+</span><span class="w" id="mwww"> </span><span class="nv" id="mwxA">i</span><span class="w" id="mwxQ"> </span><span class="mi" id="mwxg">1</span><span class="p" id="mwxw">))</span> <span class="w" id="mwyA"> </span><span class="nv" id="mwyQ">i</span><span class="p" id="mwyg">))</span>

Using the above, the following code block defines a function test that sets the-continuation to the future execution state of itself:

<span id="mw0A"></span><span class="w" id="mw0Q"> </span><span class="nb" id="mw0g">></span><span class="w" id="mw0w"> </span><span class="p" id="mw1A">(</span><span class="nf" id="mw1Q">test</span><span class="p" id="mw1g">)</span> <span class="w" id="mw1w"> </span><span class="mi" id="mw2A">1</span> <span class="w" id="mw2Q"> </span><span class="nb" id="mw2g">></span><span class="w" id="mw2w"> </span><span class="p" id="mw3A">(</span><span class="nf" id="mw3Q">the-continuation</span><span class="p" id="mw3g">)</span> <span class="w" id="mw3w"> </span><span class="mi" id="mw4A">2</span> <span class="w" id="mw4Q"> </span><span class="nb" id="mw4g">></span><span class="w" id="mw4w"> </span><span class="p" id="mw5A">(</span><span class="nf" id="mw5Q">the-continuation</span><span class="p" id="mw5g">)</span> <span class="w" id="mw5w"> </span><span class="mi" id="mw6A">3</span> <span class="w" id="mw6Q"> </span><span class="nb" id="mw6g">></span><span class="w" id="mw6w"> </span><span class="c1" id="mw7A">; stores the current continuation (which will print 4 next) away</span> <span class="w" id="mw7Q"> </span><span class="nb" id="mw7g">></span><span class="w" id="mw7w"> </span><span class="p" id="mw8A">(</span><span class="k" id="mw8Q">define</span><span class="w" id="mw8g"> </span><span class="nv" id="mw8w">another-continuation</span><span class="w" id="mw9A"> </span><span class="nv" id="mw9Q">the-continuation</span><span class="p" id="mw9g">)</span> <span class="w" id="mw9w"> </span><span class="nb" id="mw-A">></span><span class="w" id="mw-Q"> </span><span class="p" id="mw-g">(</span><span class="nf" id="mw-w">test</span><span class="p" id="mw_A">)</span><span class="w" id="mw_Q"> </span><span class="c1" id="mw_g">; resets the-continuation</span> <span class="w" id="mw_w"> </span><span class="mi" id="mwAQA">1</span> <span class="w" id="mwAQE"> </span><span class="nb" id="mwAQI">></span><span class="w" id="mwAQM"> </span><span class="p" id="mwAQQ">(</span><span class="nf" id="mwAQU">the-continuation</span><span class="p" id="mwAQY">)</span> <span class="w" id="mwAQc"> </span><span class="mi" id="mwAQg">2</span> <span class="w" id="mwAQk"> </span><span class="nb" id="mwAQo">></span><span class="w" id="mwAQs"> </span><span class="p" id="mwAQw">(</span><span class="nf" id="mwAQ0">another-continuation</span><span class="p" id="mwAQ4">)</span><span class="w" id="mwAQ8"> </span><span class="c1" id="mwARA">; uses the previously stored continuation</span> <span class="w" id="mwARE"> </span><span class="mi" id="mwARI">4</span>

For a gentler introduction to this mechanism, see call-with-current-continuation.

Coroutines

This example shows a possible usage of continuations to implement coroutines as separate threads.

<span id="mwAR4"></span><span class="w" id="mwAR8"> </span><span class="c1" id="mwASA">;;; A naive queue for thread scheduling.</span> <span class="w" id="mwASE"> </span><span class="c1" id="mwASI">;;; It holds a list of continuations "waiting to run".</span> <span class="w" id="mwASM"> </span><span class="p" id="mwASQ">(</span><span class="k" id="mwASU">define</span><span class="w" id="mwASY"> </span><span class="nv" id="mwASc">*queue*</span><span class="w" id="mwASg"> </span><span class="o" id="mwASk">'</span><span class="p" id="mwASo">())</span> <span class="w" id="mwASs"> </span><span class="p" id="mwASw">(</span><span class="k" id="mwAS0">define</span><span class="w" id="mwAS4"> </span><span class="p" id="mwAS8">(</span><span class="nf" id="mwATA">empty-queue?</span><span class="p" id="mwATE">)</span> <span class="w" id="mwATI"> </span><span class="p" id="mwATM">(</span><span class="nb" id="mwATQ">null?</span><span class="w" id="mwATU"> </span><span class="nv" id="mwATY">*queue*</span><span class="p" id="mwATc">))</span> <span class="w" id="mwATg"> </span><span class="p" id="mwATk">(</span><span class="k" id="mwATo">define</span><span class="w" id="mwATs"> </span><span class="p" id="mwATw">(</span><span class="nf" id="mwAT0">enqueue</span><span class="w" id="mwAT4"> </span><span class="nv" id="mwAT8">x</span><span class="p" id="mwAUA">)</span> <span class="w" id="mwAUE"> </span><span class="p" id="mwAUI">(</span><span class="k" id="mwAUM">set!</span><span class="w" id="mwAUQ"> </span><span class="nv" id="mwAUU">*queue*</span><span class="w" id="mwAUY"> </span><span class="p" id="mwAUc">(</span><span class="nb" id="mwAUg">append</span><span class="w" id="mwAUk"> </span><span class="nv" id="mwAUo">*queue*</span><span class="w" id="mwAUs"> </span><span class="p" id="mwAUw">(</span><span class="nb" id="mwAU0">list</span><span class="w" id="mwAU4"> </span><span class="nv" id="mwAU8">x</span><span class="p" id="mwAVA">))))</span> <span class="w" id="mwAVE"> </span><span class="p" id="mwAVI">(</span><span class="k" id="mwAVM">define</span><span class="w" id="mwAVQ"> </span><span class="p" id="mwAVU">(</span><span class="nf" id="mwAVY">dequeue</span><span class="p" id="mwAVc">)</span> <span class="w" id="mwAVg"> </span><span class="p" id="mwAVk">(</span><span class="k" id="mwAVo">let</span><span class="w" id="mwAVs"> </span><span class="p" id="mwAVw">((</span><span class="nf" id="mwAV0">x</span><span class="w" id="mwAV4"> </span><span class="p" id="mwAV8">(</span><span class="nb" id="mwAWA">car</span><span class="w" id="mwAWE"> </span><span class="nv" id="mwAWI">*queue*</span><span class="p" id="mwAWM">)))</span> <span class="w" id="mwAWQ"> </span><span class="p" id="mwAWU">(</span><span class="k" id="mwAWY">set!</span><span class="w" id="mwAWc"> </span><span class="nv" id="mwAWg">*queue*</span><span class="w" id="mwAWk"> </span><span class="p" id="mwAWo">(</span><span class="nb" id="mwAWs">cdr</span><span class="w" id="mwAWw"> </span><span class="nv" id="mwAW0">*queue*</span><span class="p" id="mwAW4">))</span> <span class="w" id="mwAW8"> </span><span class="nv" id="mwAXA">x</span><span class="p" id="mwAXE">))</span> <span class="w" id="mwAXI"> </span><span class="c1" id="mwAXM">;;; This starts a new thread running (proc).</span> <span class="w" id="mwAXQ"> </span><span class="p" id="mwAXU">(</span><span class="k" id="mwAXY">define</span><span class="w" id="mwAXc"> </span><span class="p" id="mwAXg">(</span><span class="nf" id="mwAXk">fork</span><span class="w" id="mwAXo"> </span><span class="nv" id="mwAXs">proc</span><span class="p" id="mwAXw">)</span> <span class="w" id="mwAX0"> </span><span class="p" id="mwAX4">(</span><span class="nb" id="mwAX8">call/cc</span> <span class="w" id="mwAYA"> </span><span class="p" id="mwAYE">(</span><span class="k" id="mwAYI">lambda</span><span class="w" id="mwAYM"> </span><span class="p" id="mwAYQ">(</span><span class="nf" id="mwAYU">k</span><span class="p" id="mwAYY">)</span> <span class="w" id="mwAYc"> </span><span class="p" id="mwAYg">(</span><span class="nf" id="mwAYk">enqueue</span><span class="w" id="mwAYo"> </span><span class="nv" id="mwAYs">k</span><span class="p" id="mwAYw">)</span> <span class="w" id="mwAY0"> </span><span class="p" id="mwAY4">(</span><span class="nf" id="mwAY8">proc</span><span class="p" id="mwAZA">))))</span> <span class="w" id="mwAZE"> </span><span class="c1" id="mwAZI">;;; This yields the processor to another thread, if there is one.</span> <span class="w" id="mwAZM"> </span><span class="p" id="mwAZQ">(</span><span class="k" id="mwAZU">define</span><span class="w" id="mwAZY"> </span><span class="p" id="mwAZc">(</span><span class="nf" id="mwAZg">yield</span><span class="p" id="mwAZk">)</span> <span class="w" id="mwAZo"> </span><span class="p" id="mwAZs">(</span><span class="nb" id="mwAZw">call/cc</span> <span class="w" id="mwAZ0"> </span><span class="p" id="mwAZ4">(</span><span class="k" id="mwAZ8">lambda</span><span class="w" id="mwAaA"> </span><span class="p" id="mwAaE">(</span><span class="nf" id="mwAaI">k</span><span class="p" id="mwAaM">)</span> <span class="w" id="mwAaQ"> </span><span class="p" id="mwAaU">(</span><span class="nf" id="mwAaY">enqueue</span><span class="w" id="mwAac"> </span><span class="nv" id="mwAag">k</span><span class="p" id="mwAak">)</span> <span class="w" id="mwAao"> </span><span class="p" id="mwAas">((</span><span class="nf" id="mwAaw">dequeue</span><span class="p" id="mwAa0">)))))</span> <span class="w" id="mwAa4"> </span><span class="c1" id="mwAa8">;;; This terminates the current thread, or the entire program</span> <span class="w" id="mwAbA"> </span><span class="c1" id="mwAbE">;;; if there are no other threads left.</span> <span class="w" id="mwAbI"> </span><span class="p" id="mwAbM">(</span><span class="k" id="mwAbQ">define</span><span class="w" id="mwAbU"> </span><span class="p" id="mwAbY">(</span><span class="nf" id="mwAbc">thread-exit</span><span class="p" id="mwAbg">)</span> <span class="w" id="mwAbk"> </span><span class="p" id="mwAbo">(</span><span class="k" id="mwAbs">if</span><span class="w" id="mwAbw"> </span><span class="p" id="mwAb0">(</span><span class="nf" id="mwAb4">empty-queue?</span><span class="p" id="mwAb8">)</span> <span class="w" id="mwAcA"> </span><span class="p" id="mwAcE">(</span><span class="nb" id="mwAcI">exit</span><span class="p" id="mwAcM">)</span> <span class="w" id="mwAcQ"> </span><span class="p" id="mwAcU">((</span><span class="nf" id="mwAcY">dequeue</span><span class="p" id="mwAcc">))))</span>

The functions defined above allow for defining and executing threads through cooperative multitasking, i.e. threads that yield control to the next one in a queue:

<span id="mwAcw"></span><span class="w" id="mwAc0"> </span><span class="c1" id="mwAc4">;;; The body of some typical Scheme thread that does stuff:</span> <span class="w" id="mwAc8"> </span><span class="p" id="mwAdA">(</span><span class="k" id="mwAdE">define</span><span class="w" id="mwAdI"> </span><span class="p" id="mwAdM">(</span><span class="nf" id="mwAdQ">do-stuff-n-print</span><span class="w" id="mwAdU"> </span><span class="nv" id="mwAdY">str</span><span class="p" id="mwAdc">)</span> <span class="w" id="mwAdg"> </span><span class="p" id="mwAdk">(</span><span class="k" id="mwAdo">lambda</span><span class="w" id="mwAds"> </span><span class="p" id="mwAdw">()</span> <span class="w" id="mwAd0"> </span><span class="p" id="mwAd4">(</span><span class="k" id="mwAd8">let</span><span class="w" id="mwAeA"> </span><span class="nv" id="mwAeE">loop</span><span class="w" id="mwAeI"> </span><span class="p" id="mwAeM">((</span><span class="nf" id="mwAeQ">n</span><span class="w" id="mwAeU"> </span><span class="mi" id="mwAeY">0</span><span class="p" id="mwAec">))</span> <span class="w" id="mwAeg"> </span><span class="p" id="mwAek">(</span><span class="nb" id="mwAeo">format</span><span class="w" id="mwAes"> </span><span class="no" id="mwAew">#t</span><span class="w" id="mwAe0"> </span><span class="s" id="mwAe4">"~A ~A</span><span class="se" id="mwAe8">\n</span><span class="s" id="mwAfA">"</span><span class="w" id="mwAfE"> </span><span class="nv" id="mwAfI">str</span><span class="w" id="mwAfM"> </span><span class="nv" id="mwAfQ">n</span><span class="p" id="mwAfU">)</span> <span class="w" id="mwAfY"> </span><span class="p" id="mwAfc">(</span><span class="nf" id="mwAfg">yield</span><span class="p" id="mwAfk">)</span> <span class="w" id="mwAfo"> </span><span class="p" id="mwAfs">(</span><span class="nf" id="mwAfw">loop</span><span class="w" id="mwAf0"> </span><span class="p" id="mwAf4">(</span><span class="nb" id="mwAf8">+</span><span class="w" id="mwAgA"> </span><span class="nv" id="mwAgE">n</span><span class="w" id="mwAgI"> </span><span class="mi" id="mwAgM">1</span><span class="p" id="mwAgQ">)))))</span> <span class="w" id="mwAgU"> </span><span class="c1" id="mwAgY">;;; Create two threads, and start them running.</span> <span class="w" id="mwAgc"> </span><span class="p" id="mwAgg">(</span><span class="nf" id="mwAgk">fork</span><span class="w" id="mwAgo"> </span><span class="p" id="mwAgs">(</span><span class="nf" id="mwAgw">do-stuff-n-print</span><span class="w" id="mwAg0"> </span><span class="s" id="mwAg4">"This is AAA"</span><span class="p" id="mwAg8">))</span> <span class="w" id="mwAhA"> </span><span class="p" id="mwAhE">(</span><span class="nf" id="mwAhI">fork</span><span class="w" id="mwAhM"> </span><span class="p" id="mwAhQ">(</span><span class="nf" id="mwAhU">do-stuff-n-print</span><span class="w" id="mwAhY"> </span><span class="s" id="mwAhc">"Hello from BBB"</span><span class="p" id="mwAhg">))</span> <span class="w" id="mwAhk"> </span><span class="p" id="mwAho">(</span><span class="nf" id="mwAhs">thread-exit</span><span class="p" id="mwAhw">)</span>

The previous code will produce this output:

This is AAA 0 Hello from BBB 0 This is AAA 1 Hello from BBB 1 This is AAA 2 Hello from BBB 2 ...

Implementation

A program must allocate space in memory for the variables its functions use. Most programming languages use a call stack for storing the variables needed because it allows for fast and simple allocating and automatic deallocation of memory. Other programming languages use a heap for this, which allows for flexibility at a higher cost for allocating and deallocating memory. Both of these implementations have benefits and drawbacks in the context of continuations.

Programming language support

Many programming languages exhibit first-class continuations under various names; specifically:

• Common Lisp: cl-cont. One can also use custom macros
• C++: roughly implemented using co_await, co_return, co_yield
• C# / VB.NET: async and await: "sign up the rest of method as the continuation, and then return to your caller immediately; the task will invoke the continuation when it completes". Asynchronous Programming for C#
• Factor: callcc0 and callcc1
• Haskell: The Continuation monad in Control.Monad.Cont
• Haxe: haxe-continuation
• Icon, Unicon : create, suspend, @ operator: coexpressions
• Java: Lightwolf javaflow (requires bytecode manipulation at runtime or compile time)
• Kotlin: kotlin.coroutines.Continuation
• JavaScript Rhino: Continuation
• Parrot: Continuation PMC; uses continuation-passing style for all control flow
• Perl: Coro and Continuity
• Pico: call(exp()) and continue(aContinuation, anyValue)
• Python: PyPy's _continuation.continulets
• Racket: call-with-current-continuation (commonly shortened to call/cc)
• Ruby: callcc
• Scala: scala.util.continuations provides shift/reset
• Scheme: call-with-current-continuation (commonly shortened to call/cc)
• Smalltalk: Continuation currentDo:; in most modern Smalltalk environments continuations can be implemented without additional VM support.
• Standard ML of New Jersey: SMLofNJ.Cont.callcc
• Unlambda: c, the flow control operation for call with current continuation

In any language which supports closures and proper tail calls, it is possible to write programs in continuation-passing style and manually implement call/cc. (In continuation-passing style, call/cc becomes a simple function that can be written with lambda.) This is a particularly common strategy in Haskell, where it is easy to construct a "continuation-passing monad" (for example, the Cont monad and ContT monad transformer in the mtl library). The support for proper tail calls is needed because in continuation-passing style no function ever returns; all calls are tail calls.

In Web development

One area that has seen practical use of continuations is in Web programming. The use of continuations shields the programmer from the stateless nature of the HTTP protocol. In the traditional model of web programming, the lack of state is reflected in the program's structure, leading to code constructed around a model that lends itself very poorly to expressing computational problems. Thus continuations enable code that has the useful properties associated with inversion of control, while avoiding its problems. "Inverting back the inversion of control or, Continuations versus page-centric programming" is a paper that provides a good introduction to continuations applied to web programming.

Kinds

Support for continuations varies widely. A programming language supports re-invocable continuations if a continuation may be invoked repeatedly (even after it has already returned). Re-invocable continuations were introduced by Peter J. Landin using his J (for Jump) operator that could transfer the flow of control back into the middle of a procedure invocation. Re-invocable continuations have also been called "re-entrant" in the Racket language. However this use of the term "re-entrant" can be easily confused with its use in discussions of multithreading.

A more limited kind is the escape continuation that may be used to escape the current context to a surrounding one. 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/longjmp are also equivalent: they can only be used to unwind the stack. Escape continuations can also be used to implement tail call elimination.

One generalization of continuations are delimited continuations. Continuation operators like call/cc capture the entire remaining computation at a given point in the program and provide no way of delimiting this capture. Delimited continuation operators address this by providing two separate control mechanisms: a prompt that delimits a continuation operation and a reification operator such as shift or control. Continuations captured using delimited operators thus only represent a slice of the program context.

Disadvantages

Continuations are the functional expression of the GOTO statement, and the same caveats apply. While they are a sensible option in some special cases such as web programming, use of continuations can result in code that is difficult to follow. In fact, the esoteric programming language Unlambda includes call-with-current-continuation as one of its features solely because expressions involving it "tend to be hopelessly difficult to track down". The external links below illustrate the concept in more detail.

Linguistics

In "Continuations and the nature of quantification", Chris Barker introduced the "continuation hypothesis", that

some linguistic expressions (in particular, QNPs [quantificational noun phrases]) have denotations that manipulate their own continuations.

Barker argued that this hypothesis could be used to explain phenomena such as duality of NP meaning (e.g., the fact that the QNP "everyone" behaves very differently from the non-quantificational noun phrase "Bob" in contributing towards the meaning of a sentence like "Alice sees [Bob/everyone]"), scope displacement (e.g., that "a raindrop fell on every car" is interpreted typically as ${\displaystyle \mathrm{\forall }c\mathrm{\exists }r,\text{fell}(r,c)}$ rather than as ${\displaystyle \mathrm{\exists }r\mathrm{\forall }c,\text{fell}(r,c)}$), and scope ambiguity (that a sentence like "someone saw everyone" may be ambiguous between ${\displaystyle \mathrm{\exists }x\mathrm{\forall }y,\text{saw}(x,y)}$ and ${\displaystyle \mathrm{\forall }y\mathrm{\exists }x,\text{saw}(x,y)}$). He also observed that this idea is in a way just a natural extension of Richard Montague's approach in "The Proper Treatment of Quantification in Ordinary English" (PTQ), writing that "with the benefit of hindsight, a limited form of continuation-passing is clearly discernible at the core of Montague's (1973) PTQ treatment of NPs as generalized quantifiers".

The extent to which continuations can be used to explain other general phenomena in natural language is a topic of current research.