如何为continuation monad实现stack-safe chainRec操作符？

Question

我目前正在试验延续monad。 Cont实际上在javascript中很有用，因为它从回调模式中抽象出来。

当我们处理monadic递归时，总是存在堆栈溢出的风险，因为递归调用不在尾部位置：

const chain = g => f => k =>
  g(x => f(x) (k));

const of = x => k =>
  k(x);
  
const id = x =>
  x;

const inc = x =>
  x + 1;

const repeat = n => f => x => 
  n === 0
    ? of(x)
    : chain(of(f(x))) (repeat(n - 1) (f));

console.log(
  repeat(1e6) (inc) (0) (id) // stack overflow
);

但是，即使我们能够将某些情况转换为尾递归，我们仍然注定要失败，因为Javascript没有TCO。因此，我们必须在某个时刻回到循环。

puresrcipt有一个MonadRec类型类，带有tailRecM运算符，可以为某些monad进行尾递归monadic计算。所以我尝试在Javascript中实现chainRec主要是根据幻想的土地规范：

const chain = g => f => k => g(x => f(x) (k));
const of = x => k => k(x);
const id = x => x;

const Loop = x =>
  ({value: x, done: false});

const Done = x =>
  ({value: x, done: true});

const chainRec = f => x => {
  let step = f(Loop, Done, x);

  while (!step.done) {
    step = f(Loop, Done, step.value);
  }

  return of(step.value);
};

const repeat_ = n => f => x => 
  chainRec((Loop, Done, [n, x]) => n === 0 ? Done(x) : Loop([n - 1, f(x)])) ([n, x]);

console.log(
  repeat_(1e6) (n => n + 1) (0) (id) // 1000000
);

这有效，但它看起来很像作弊，因为它似乎绕过了monadic链接，从而绕过了Cont的背景。在这种情况下，上下文只是“计算的其余部分”，即。反向的函数组成，结果返回预期值。但它对任何单子都有效吗？

为了清楚我的意思，请查看以下outstanding answer的代码片段：

const Bounce = (f,x) => ({ isBounce: true, f, x })

const Cont = f => ({
  _runCont: f,
  chain: g =>
    Cont(k =>
      Bounce(f, x =>
        Bounce(g(x)._runCont, k)))
})

// ...

const repeat = n => f => x => {
  const aux = (n,x) =>
    n === 0 ? Cont.of(x) : Cont.of(f(x)).chain(x => aux(n - 1, x))
  return runCont(aux(n,x), x => x)
}

这里chain以某种方式结合到递归算法中，即可以发生monadic效应。不幸的是，我无法破译此运算符或将其与堆栈不安全版本协调（但Bounce(g(x)._runCont, k)似乎是f(x) (k)部分）。

最后，我的问题是，如果我搞砸了chainRecor的实施，误解了FL规范或者两者都没有，或者都没有？

[编辑]

通过从不同的角度看问题并且值得接受，两个给出的答案都非常有用。因为我只能接受一个 - 嘿stackoverflow，世界并不那么简单！ - 我不接受任何。

Answer 1

另一答案