Continuation

Description

A Continuation is an abstract representation of the state of a program’s control flow at a specific point in time. It captures “what to do next” in the execution, allowing a program to pause, save its execution context, and resume later—often in a different thread, function, or even machine.

Continuations are powerful tools for implementing non-linear control flows such as:

• Coroutines
• Generators
• Backtracking
• Asynchronous programming
• Exception handling
• Cooperative multitasking

In languages that support first-class continuations, a continuation can be stored in a variable, passed to functions, or resumed like a callback.

Conceptual Understanding

Think of a continuation as the bookmark of a computation. When invoked, it restores the state of the program to that point—like rewinding time or jumping to a future event that hasn’t happened yet.

Real-Life Analogy

Imagine watching a movie and pressing “pause.” You walk away, come back later, and press “play.” The movie resumes exactly where you left off. The continuation is the pause state: it knows where you were and what happens next.

Technical Structure

At a low level, a continuation captures:

Languages That Support Continuations

Example: Scheme’s call/cc

(define (example)
  (call/cc (lambda (k)
             (k 42)
             100)))

This will return 42 immediately and skip 100. The continuation k remembers the context before returning.

Example: Python Generator (Simulated Continuation)

def simple_gen():
    yield 1
    yield 2

g = simple_gen()
print(next(g))  # 1
print(next(g))  # 2

Here, each yield captures the current point in the function, acting as a limited continuation.

Continuation-Passing Style (CPS)

A programming style where control is explicitly passed via functions. Instead of returning values, functions receive another function (continuation) to call with the result.

Example in JavaScript:

function square(x, cont) {
  cont(x * x);
}

square(5, function(result) {
  console.log("Result:", result);
});

This defers the computation using cont.

Advantages

Disadvantages

Continuation in Web Programming

In frameworks like Seaside (Smalltalk) or Racket, continuations let developers treat multi-step web forms as linear code—even if user input and page loading happen in separate HTTP requests.

Code Patterns

Continuation in CPS Style (Python Simulated)

def add(a, b, cont):
    cont(a + b)

def mult(x, cont):
    cont(x * 2)

add(2, 3, lambda sum_result: mult(sum_result, print))

JavaScript Callback Continuation

function fetchData(url, cont) {
  fetch(url)
    .then(response => response.json())
    .then(data => cont(data));
}

Continuation Monad (Haskell)

import Control.Monad.Cont

example :: Cont r String
example = return "Hello from continuation!"

runCont example print

This is useful for building computations with deferred execution.

Common Use Cases

Evaluation in Functional Programming

Continuations often allow powerful constructs like:

• Delimited Continuations: Only part of the call stack is captured
• Call/cc Transformations: Programs rewritten into continuation-passing style
• Trampolines: Emulate recursion without growing the stack

Related Concepts

Related Keywords

• Call With Current Continuation
• Continuation Monad
• Continuation-Passing Style
• Coroutine
• Delimited Continuation
• Execution Context
• Lambda Calculus
• Non-Blocking Flow
• Stack Reification
• Trampolining