Techniques for implementing a call-by-value λ-calculus are well known,
including Reynolds's definitional interpreter and
techniques that Danvy developed for moving between
reduction rules and abstract machines. Most techniques focus
on ensuring that an implementation produces the same evaluation result
as a model, but time and space properties are also within reach.
Proper tail-call handling falls out of Reynolds's approach,
for example, but the stronger property of space safety is less readily
available, particularly if
worst-case time complexity matters. In this paper, we explore
an approach to space safety that is realized through the garbage
collector, instead of the interpreter loop, in the hope of finding a
convenient implementation technique that matches the asymptotic time
bounds of fast evaluation models and the asymptotic space bounds of
compact evaluation models. We arrive within a size-of-source factor of
achieving those bounds. Our implementation technique is comparable in
complexity to some other interpreter variants; specifically, it requires
some library functions for binary trees, specialized environment
traversals in the garbage collector, and a compilation pass to gather
the free variables of each expression and to rewrite each variable
reference to its binding depth.