Continuationpassing

Continuation-passing style (CPS) is a programming style in which control is passed explicitly as a continuation. Instead of returning a result to the caller, a function receives an additional argument, the continuation, which it invokes with the result. The continuation represents the rest of the computation and determines what happens next. In CPS, functions do not return in the traditional sense; they always pass their result to the provided continuation.

Mechanics: in CPS, every function has an extra parameter, typically named k or cont, for the continuation. When a function would normally return, it instead calls the continuation with the value. This makes control flow explicit and allows non-standard flow such as early exits, exceptions, or asynchronous steps to be modeled as ordinary function calls.

Example:

Direct style:

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

CPS:

def add_cps(a, b, k): k(a + b)

A small composition in CPS would chain continuations to represent subsequent steps without returning to a caller.

Applications: CPS is foundational in compiler design and language theory. It enables advanced control-flow features, such as coroutines, generators, backtracking, and non-blocking I/O. It has been used as a target form for compiling languages with first-class continuations (notably Scheme) and as a technique for implementing asynchronous patterns in languages like JavaScript and others through explicit continuations or transformation-based approaches.

Advantages and limitations: CPS makes control flow explicit, simplifying certain optimizations and features (e.g., non-local exits, concurrency models). However, it produces more verbose code, can be harder to read, and may incur performance costs unless optimizations such as tail-call optimization are applied.

Related concepts include delimited continuations and the continuation monad, which provide structured ways to manage and compose continuations.