Skip to content

Open Recursion

A shared object method calls through its current receiver so specialized receiver behavior can determine the internal call's target.

Version
v1 · 2026-10-31 · History
Domain-specific #
14543
Domain group
Applied Sciences & Engineering
Origin domain
Computer Science & Software Engineering

Core Idea

Open recursion lets a shared object method call another operation on its current receiver, so a specialized receiver can supply the called behavior. In a class system an inherited method may call a subclass override; in a delegation system a parent method may call a child-provided operation.[1][2]

How would you explain it like I'm…

Do Your Own Version

Imagine a teacher's rule for all kids: 'Now do your own dance.' Each kid who follows the rule does their own special dance, not the teacher's. In computer programs, open recursion lets a shared instruction say 'do your own version' and get the special version of whoever is running it.

Calling Your Own Special Version

In programming, objects can share instructions from a more general version, like a 'parent' class, while also having their own special versions of some steps. Open recursion means a shared instruction can call another step on the same object, and the computer picks that object's own special version. So the general code doesn't need to know ahead of time exactly which version will run. Despite the name, it doesn't have to mean a function calling itself over and over.

Late-Bound Self Dispatch

Open recursion is a feature of object-oriented programming where shared code can call another operation on the current object (often called self or this), and the version that runs is chosen based on that object's specialized behavior. For example, a method in a base class can call a method that a subclass has overridden, and the subclass's version runs. Similarly, with delegation, a method found on a parent object can still send messages to the original child object. The shared code never has to name the exact target in advance. It needs two things: the same receiving object available inside the shared method, and a lookup rule that can pick the specialization. 'Recursion' here refers to self-reference, not to a function repeatedly calling itself until a base case.

 

Open recursion lets shared object behavior invoke another operation on the current receiver, with the target selected by that receiver's specialized behavior. In class-based languages a base-class method can call a method that a subclass overrides, dispatching to the override; in delegation-based systems a method found on a parent can send messages to the original child receiver. The shared method therefore does not name its eventual target in advance. The mechanism requires two ingredients: the same receiver must be available inside the shared method (as self or this), and a lookup or dispatch rule must be able to select a specialization based on that receiver. The term describes self-reference within an extensible object structure. It does not imply that any particular execution calls itself repeatedly or terminates through a base case.

How It Works

The method retains the receiver, sends an operation to it, and the language's lookup rules select a target. A private or fixed base call may close this route. The pattern does not require a loop or a terminating recursive descent. How a call site selects JavaScript this is a separate receiver-binding question.

Examples

Aldrich's CountingSet illustrates a hypothetical base addAll change: its internal add calls reach the subclass override and increment a counter already incremented by subclass addAll.[1] Tanter's delegated point.add sends x? to its random-point receiver, selecting that child's computed accessor.[2] Ungar and Smith describe a related Self point design.[3]

Boundary

Dynamic dispatch to another object alone does not show a self-send. The broader source title This (computer programming) includes receiver-reference meanings outside this bounded article.

Neighborhood in Abstraction Space

Open Recursion sits in a sparse region of the domain-specific corpus (98th percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely.

Family — Unclustered & Miscellaneous (2835 abstractions)

Nearest neighbors

Computed from structural-signature embeddings · 2026-10-31

References

[1] Jonathan Aldrich, “Selective Open Recursion A Solution to the Fragile Base Class Problem”, figure 1 and §§1.1–2, directly inspected PDF text. registry ↩a ↩b

[2] Éric Tanter, “Forwarding and Delegation,” Object-Oriented Programming Languages: Application and Interpretation, §§4.3.2 and 4.4, directly inspected online textbook. registry ↩a ↩b

[3] David Ungar and Randall B. Smith, “Self The Power of Simplicity”, Lisp and Symbolic Computation 4, no. 3 (1991), §3 and figure 4, printed pp. 8–9, directly inspected PDF text and caption; figure layout not independently visually inspected. registry ↩