一般来说，是否有可能将递归 function 转换为在 JavaScript 中使用手动堆栈的一个？

Question

Mind the following function:

function count(n) {
  if (n === 0) {
    return 0;
  } else {
    return 1 + count(n - 1);
  }
}

It is the simplest recursive function that counts from 0 to N . Since JavaScript has a small stack limit, that function easily overflows. In general, any recursive function can be converted in one that uses a manual stack and, thus, can't stack overflow; but doing so is complex. Is it possible, for the general case, to convert a JavaScript recursive function in one that uses its own stack, without using a continuation-passing style? In other words, suppose we had written:

const count = no_overflow(function(count) {
  return function(n) {
    if (n === 0) {
      return 0;
    } else {
      return 1 + count(n - 1);
    }
  }
});

Is it possible to implement no_overflow in such a way that this new count function is equivalent to the old one, except without stack overflows?

Notes:

1. This is not about tail call optimization, since no_overflow should work for non-tail-recursive functions.

2. Trampolining is not helpful since, for the general case, it requires the function to be written in a continuation-passing style, which it isn't.

3. Writing the function with yield doesn't work either for a similar reason: you can't yield from inner lambdas.

4. That no_overflow would, essentially, work like a stack-free Y-combinator.

Answer 1

In JavaScript, calling a function f(x, y, ...) subjects us to the underlying implementation details of the stack and frames. If you recur using function application, you will absolutely, unavoidably run into a stack overflow.

However, if we can adopt a slightly different notation, such as call(f, x, y, ...) , we can control function application however we want -

const add1 = x =>
  x + 1

const count = (n = 0) =>
  n === 0
    ? 0
    : call(add1, call(count, n - 1)) // <-- count not in tail pos

console.log(noOverflow(count(99999)))
// 99999

Implementing noOverflow is a wrapper around loop , defined in this Q&A -

const noOverflow = t =>
  loop(_ => t)

Unsurprisingly this is a non-trivial problem but the answer(s) there should help detail the things you have to consider and some good test cases, should you choose to implement a solution of your own.

Expand the snippet below to verify the results in your browser -

 const call = (f, ...values) => ({ type: call, f, values }) const recur = (...values) => ({ type: recur, values }) const identity = x => x const loop = (f) => { const aux1 = (expr = {}, k = identity) => expr.type === recur? call (aux, expr.values, values => call (aux1, f (...values), k)): expr.type === call? call (aux, expr.values, values => call (aux1, expr.f (...values), k)): call (k, expr) const aux = (exprs = [], k) => call ( exprs.reduce ( (mr, e) => k => call (mr, r => call (aux1, e, x => call (k, [...r, x ]))), k => call (k, []) ), k ) return run (aux1 (f ())) } const run = r => { while (r && r.type === call) r = r.f (...r.values) return r } const noOverflow = t => loop(_ => t) const add1 = x => x + 1 const count = (n = 0) => n === 0? 0: call(add1, call(count, n - 1)) console.log(noOverflow(count(99999))) // 99999