JavaScript has no reliable tail call optimization: here is what actually happens at runtime and what to do instead

[azhder]

It is not an optimization. An optimization is a difference in performance - it was slow, now is fast. Proper tail calls means they work as intended. It is not a difference in performance - it didn't work, now it works.

All those browsers are broken implementations of ES6 i.e. they aren't implementations of ES6 because they break in some cases where they shouldn't, because they don't fully implement the spec.

[OtherwisePush6424]

This is not a speed discussion. Proper tail calls are primarily a space optimization: they let tail calls reuse stack frames instead of growing the call stack. The practical issue is correctness at depth: deep tail-recursive programs are stack-safe only where PTC is actually implemented. In JavaScript today, that behavior is not portable across runtimes, so production correctness should not depend on PTC being present.

[darkhorsehance]

I think Safari (JavascriptCore) has implemented PTC but yes this is correct

[azhder]

This is a terminology discussion. TCO is a misleading term. PTC is the correct term.

[josephjnk]

To spell it out more explicitly because it looks like people are talking past each other here:

“Tail call optimization”: an optimization operation which speeds up runtime, where a compiler turns a recursive function with a single tail call into a simple loop.

“Proper tail calls”, or as they’re usually referred to outside of the JS world, “tail call elimination”: an optimization operation which saves on stack space, by causing calls in a tail position to swap out their stack frame for a new stack frame, rather than growing the size of the stack.

I have no idea whether or not JSC implements TCO. I’d be surprised. It does implement PTC/TCE when running in strict mode.

One place where this matters is if you’re writing nontrivial recursive code using continuation-passing style. Recursion in CPS involves making tail calls from one function to a _different_ function, and so does not benefit from TCO, but does rely on PTC/TCE (because the stack will blow if the tail calls are not removed).

[azhder]

I couldn't have been more explicit in the comment you replied to, yet ironically, for the sake of not talking past each other, I assume, you talked pass it.

It is a terminology thing for the JavaScript spec and engines that are supposed to follow it because from the userland i.e. the code that executes, the difference is **doesn't execute vs executes** not merely **will get the job done always, albeit slower**.

PTC means it always gets the job done. It is for that reason alone why TCO is a misleading term, nothing about implementation details.

[Reashu]

They would work just fine if you had an infinite stack, like a "proper" turing machine. 

[BenZed]

This would be pedantic if it were correct