是否优化了阶乘尾叫（TCO）的延续样式实现？

Question

Here are two factorial implementation from this site :

Tail Call Optimized (TCO):

function fact(n) {
  return tail_fact(n,1) ;
}

function tail_fact(n,a) {
  if (n == 0)
    return a ;
  else
    return tail_fact(n-1,n*a) ;
}

And the one rewritten in continuation style programming (callback):

function fact(n,ret) {
  tail_fact(n,1,ret) ;
} 

function tail_fact(n,a,ret) {
  if (n == 0)
    ret(a) ;
  else
    tail_fact(n-1,n*a,ret) ;
}

It seems that the tutorial suggest that the second is also TCO, but the last thing the second version returns is undefined and its call is not in tail position according to this tutorial .

However it also seems that return is not used at all here and hence there is no need to create a new frame on stack with the address to return to. So is this what makes the second implemenation TCO?

Answer 1

Node7 with --harmony_tailcalls doesn't consider the second one valid for TCO, but TCO isn't 100% complete in V8 (hence being behind a runtime flag).

Axel Rauschmayer says no, it's not a tail call , because there's an implicit return undefined ; after it:

The function call bar() in the following code is not in tail position:

 function foo() { bar(); // this is not a tail call in JS } 

The reason is that the last action of foo() is not the function call bar() , it is (implicitly) returning undefined . In other words, foo() behaves like this:

 function foo() { bar(); return undefined; } 

Callers can rely on foo() always returning undefined . If bar() were to return a result for foo() , due to tail call optimization, then that would change foo's behavior.

So in other words, at the end of foo , we can't just jump to bar , because bar may issue a return with a value other than undefined , whereas foo doesn't return any value at all (and thus calling it is guaranteed to yield undefined ). Something has to stay behind (at least for now) when we call bar to say "but don't return bar 's return value." That something is a stack frame.

In theory , the JavaScript engine could pass some kind of flag when calling bar telling itself to throw away any value bar returns, thus allowing TCO in that case, but I don't see anything in the spec that does that.