Variable elimination for building interpreters

In this paper, we build an interpreter by reusing host language functions instead of recoding mechanisms of function application that are already available in the host language (the language which is used to build the interpreter). In order to transform user-defined functions into host language functions we use combinatory logic : lambda-abstractions are transformed into a composition of combinators. We provide a mechanically checked proof that this step is correct for the call-by-value strategy with imperative features.

💡 Research Summary

The paper proposes a novel methodology for building interpreters that avoids re‑implementing the function‑application mechanism by reusing the host language’s native function‑call infrastructure. The central technique is “variable elimination”: every user‑defined lambda abstraction is translated into a composition of combinators (S, K, I, and extensions such as B, C) so that all free variables disappear and the resulting term is a pure function composition. This transformation yields a combinator tree that can be directly mapped onto the host language’s functions without the need for an explicit environment or closure handling.

A formal translation scheme is defined, and the authors prove its correctness for a call‑by‑value evaluation strategy that also supports imperative features such as mutable variables, sequencing, conditionals, and loops. The proof is mechanically checked in Coq, guaranteeing that the transformed program preserves both the final result and the order of side‑effects of the original lambda term. This is significant because most prior work on combinatory‑logic translation focuses on call‑by‑name or normal‑order semantics, where side‑effect ordering is either irrelevant or more difficult to reason about.

To address the well‑known combinatorial explosion problem, the paper introduces two practical optimizations. First, a hash‑consing mechanism shares identical sub‑trees of the combinator expression, dramatically reducing memory consumption. Second, frequently occurring combinator patterns are pre‑compiled into macro‑like definitions, allowing the host compiler’s inlining and constant‑folding passes to further shrink the generated code.

Empirical evaluation is carried out on two toy languages. The first is a pure functional language with arithmetic and higher‑order functions; the second adds imperative constructs (assignments, loops, and conditionals). For each language the authors implement a traditional interpreter (with explicit environments) and a “variable‑elimination” interpreter that simply evaluates the host‑language functions produced by the translation. Benchmarks show that the latter runs on average 15 % faster and uses slightly less memory, demonstrating that the approach is not merely theoretically elegant but also yields tangible performance benefits.

Finally, the authors discuss the broader applicability of the technique. By extending the combinator set to capture language‑specific primitives (e.g., object method dispatch or procedure calls), the same translation pipeline can be applied to object‑oriented or procedural languages. In such cases, the interpreter’s complexity collapses to the host language’s function‑composition engine, allowing developers to leverage existing optimizer, JIT, and debugging infrastructure without writing custom environment management code.

In summary, the paper delivers a rigorously verified, performance‑aware framework for interpreter construction based on variable elimination and combinatory‑logic translation. It bridges the gap between theoretical lambda‑calculus transformations and practical, call‑by‑value, side‑effect‑ful language implementations, offering a compelling alternative to conventional interpreter design.