Tail-call optimization

As explained in Functional Programming in JavaScript

A compiler optimization that reuses the current call frame for a function call in tail position instead of creating a new stack frame.

Tail-call optimization (TCO) makes certain recursive programs use the stack more like a loop. When the final operation is another function call, the runtime can discard the current frame instead of stacking a new one. section 7.4

A recursive call can use TCO when:

• The recursive call is in tail position: it is the last operation, with no multiplication, addition, or other work remaining afterward. section 7.4
• The function passes necessary state through arguments, often using an accumulator. section 7.4
• The compiler or runtime reuses a single execution frame rather than allowing recursive frames to accumulate. section 7.4

Accumulator-based factorial

const factorial = (n, current = 1) => (n === 1) ? current : factorial(n - 1, n * current); Each call carries the result accumulated so far. The recursive call is the final action, so evaluating factorial(4) can proceed through successive argument values instead of building a pyramid of pending multiplications. section 7.4

Figure 7.9. A detailed view of tail-recursive factorial(4) evaluation. As you can see, the function uses a single frame. TCO is in charge of throwing the current function frame to give way for a new one, as if factorial was being evaluated in a loop.

Shows tail-recursive factorial evaluation using a single reusable frame, making the stack benefit visible. section 7.4

How Functional Programming in JavaScript covers it

How deep it goes

Explains tail position, accumulated arguments, and single-frame reuse, but does not develop broader compiler behavior.

Examples

Uses factorial evaluation and accumulator-based array summation to contrast ordinary and tail-recursive forms.

What it assumes

Assumes basic recursion and stack behavior while introducing tail position and accumulator passing.

What you can do after

Apply it by converting recursive factorial or summation functions into accumulator-based tail-recursive forms.

How it connects

Connects recursion with loops, memoization, compiler optimization, and stack usage.

liveBookmanning.com

Read Functional Programming in JavaScript on liveBook Get the book at manning.com

Also explained in

• 

  liveBookmanning.com
  Elixir in Action, Third EditionTail-call optimization is a compiler or runtime optimization that reuses a caller's stack frame when its final operation is a function call.
• 

  liveBookmanning.com
  Functional Programming in Scala, Second EditionTail call elimination is a compiler optimization that implements eligible recursive calls without allocating a new call-stack frame for each call.

Compare how 3 books explain tail-call optimization →

Related concepts

• loop-recurimplemented by · In Clojure, loop/recur is a construct that re-enters a loop or function with replacement values without growing the call stack.
• tail calluses · A tail call is a function or method call that is the caller’s final operation, with its result returned directly without further computation.
• try-catch statementcontrasts with · A try-catch statement is a control-flow construct that executes code under exception handling and transfers control to a matching handler when an exception is raised.
• recursionused by · Recursion is a computational technique in which a definition or procedure refers to or invokes the same definition or procedure, directly or indirectly.
• stack overflowaddresses · A stack overflow is a runtime failure caused by exhausting the available capacity of a program’s call stack.

This explainer was generated by Manning's knowledge graph from the text of Functional Programming in JavaScript. The section links point to the parts of the book it draws on.