tailcall

A tail call is a subroutine call that occurs as the final action of a procedure, with no additional work to perform after the call returns. When the caller’s only remaining operation is to return the callee’s result, the call is in tail position. A tail call to the same function is called a tail-recursive call, or tail recursion.

Tail call optimization is a technique used by some languages and runtimes to reuse the current function’s stack frame for the callee, allowing calls to be completed without growing the call stack. This can turn deep or infinite recursion into constant stack-space usage. To be optimizable, the call must be truly in tail position, and no work can be pending after the callee returns. An example is a tail-recursive factorial function that carries an accumulator: fact(n, acc) = if n == 0 then acc else fact(n-1, acc*n). In a language with TCO, this behaves like an iterative loop.

Language support for TCO varies. Scheme and other classic functional languages commonly guarantee tail-call optimization. Some other languages, such as Python and Java, do not provide portability guarantees of TCO, and implementations may or may not optimize tail calls. When TCO is unavailable, tail-recursive approaches can still be written with explicit loops or trampolines to prevent unbounded stack growth.

Practical considerations include the potential impact on debugging, since stack traces may omit intermediate frames when TCO is applied. For programmers who rely on recursion for readability, understanding whether a language guarantees TCO is important; otherwise, iterative equivalents may be preferred.