如何应用 callcc 以便它提供转义延续机制以与延续单子一起使用

Question

我尝试在 Javascript 中实现 continuation monad 来处理 continuation 传递样式和异步控制流。这是我学习的延续单子：

// auxiliary functions

const log = prefix => x => console.log(prefix, x);
const addk = x => y => k => setTimeout((x, y) => k(x + y), 0, x, y);
const inck = x => k => setTimeout(x => k(x + 1), 0, x);
const sqr = x => x * x;


// continuation monad

const cont = {
  of: x => k => k(x),

  map: ftor => f => k => ftor(x => k(f(x))),

  ap: ftor => gtor => k => ftor(x => gtor(f => k(f(x)))),

  chain: ftor => mf => k => ftor(x => mf(x) (k)),

  callcc: f => k => f(x => () => k(x)) (k)
};


// map a normal, unary function with an asynchronous function:

cont.map(inck(9)) (sqr) (log("map"));


// chain two asynchronous CPS computations with an asynchronous binary CPS function

const comp1 = cont.map(inck(4)) (sqr);
const comp2 = cont.map(inck(9)) (sqr);

cont.chain(comp1) (x => cont.chain(comp2) (y => addk(x) (y))) (log("chain"));

除了cont.ap，我没有发现他的好处，一切都很好。

现在我想模仿 Javascript 中同步控制流的throw/catch 机制。 callcc 似乎很合适，因为它提供了一种转义延续机制，可与延续单子一起使用，如http://hackage.haskell.org/ 所述。

但我不知道如何申请callcc，而且我还没有找到任何合适的来源来描述这样的申请。

Answer 1

简述延续

延续是一种强大的抽象。让我强调一下。延续是一个非常强大的抽象。为什么延续如此强大？这是因为延续只是一个函数^[1] 和“functions have a dangerous property of being invokable.” 稍后会详细介绍。

那么，如果延续只是一个函数，那它为什么这么特别呢？

是的，延续只是一个函数。然而，让延续如此特别的是它所代表的东西。延续代表“计算的其余部分”（也称为计算上下文）。例如，考虑以下 Scheme 表达式：

  (add1 (* 3 x))
;       |_____|
;          |
;     computation

  (add1 [])
; |_______|
;     |
;  context

这里的计算(* 3 x) 具有上下文(add1 [])，其中[] 表示一个洞。可以用计算的结果来堵住这个洞。对于某些result，这写为(add1 [result])。延续只是上下文的表示。例如函数(lambda (result) (add1 result))代表上下文(add1 [])。

另一方面，计算(* 3 x) 也可以表示为一个函数。它表示为函数(lambda (context) (context (* 3 x)))，其中context 是表示计算上下文的延续。需要注意的是，Haskell 中的 Cont 类型代表计算本身，而不是其上下文。

好的，但是是什么让延续如此强大？

正如我之前所说，延续只是一个函数，“functions have a dangerous property of being invokable.” 特别是，一个函数不仅可以调用一次，还可以任意多次，甚至根本不调用。这就是让延续如此强大的原因。

例如，将上述计算(* 3 x) 表示为一个函数：

(lambda (context)
  (context (* 3 x)))

如果我们多次申请context 会怎样？我们可以使用它来使结果加倍，如下所示：

(lambda (context)
  (+
    (context (* 3 x))
    (context (* 3 x))))

如果给定的context 是add1，那么这将产生答案(* 2 (add1 (* 3 x)))。

另一方面，如果我们从未申请过context 怎么办？我们可以短路评估：

(lambda (context)
  (* 3 x))

这正是call/cc 所做的。它通过忽略上下文并简单地返回答案来缩短评估。例如，考虑：

(call/cc (lambda (short-circuit)
  (add1 (short-circuit (* 3 x)))))

这里，计算(* 3 x) 具有上下文add1。但是，我们通过将call/cc（即short-circuit）的上下文应用于计算结果来缩短计算。因此，我们忽略了原始上下文（即add1）并返回了答案。

call/cc是如何实现的？

现在我们了解了延续，让我们看看 Haskell 中callCC 的定义：

callCC :: ((a -> Cont r b) -> Cont r a) -> Cont r a
       -- |___________________________|
       --               |
       --               f
callCC f = Cont $ \k -> runCont (f (\a -> Cont $ \_ -> k a)) k
       --        __|___            |______________________|
       --       |      |                       |
       --       (a -> r)                 short-circuit

需要注意的是k是当前的延续（即整个表达式的延续）。函数f 是callCC 的唯一输入。它返回一个Cont r a，它表示要执行的整个计算。我们将其应用于k 以获取计算结果。

但是，在计算内部，只要我们想短路计算，我们就可以调用short-circuit。此函数接受一个结果并返回一个忽略其上下文的计算并将当前延续 k 应用于结果，从而使评估短路。

用 JavaScript 把它们放在一起。

我们了解了 Scheme 中的延续。我们了解 callCC 在 Haskell 中的工作原理。让我们使用我们新发现的知识在 JavaScript 中实现延续和callCC：

var Cont = defclass({
    constructor: function (runCont) {
        this.runCont = runCont;
    },
    map: function (f) {
        return new Cont(k => this.runCont(x => k(f(x))));
    },
    apply: function (g) {
        return new Cont(k => this.runCont(f => g.runCont(x => k(f(x)))));
    },
    bind: function (f) {
        return new Cont(k => this.runCont(x => f(x).runCont(k)));
    }
});

Cont.of = x => new Cont(k => k(x));

var callCC = f => new Cont(k => f(x => new Cont(_ => k(x))).runCont(k));

var log = prefix => x => console.log(prefix, x);

var add1 = x => Cont.of(x + 1);

callCC(short_circuit => short_circuit(15).bind(add1)).runCont(log("short"));

callCC(short_circuit => Cont.of(15).bind(add1)).runCont(log("no short"));

function defclass(prototype) {
    var constructor = prototype.constructor;
    constructor.prototype = prototype;
    return constructor;
}

注意，callCC 可以用来实现goto。

callCC 的强大功能允许您创建任意控制流结构，如throw、协程甚至goto，如下所示：

var Cont = defclass({
    constructor: function (runCont) {
        this.runCont = runCont;
    },
    map: function (f) {
        return new Cont(k => this.runCont(x => k(f(x))));
    },
    apply: function (g) {
        return new Cont(k => this.runCont(f => g.runCont(x => k(f(x)))));
    },
    bind: function (f) {
        return new Cont(k => this.runCont(x => f(x).runCont(k)));
    }
});

Cont.of = x => new Cont(k => k(x));

var callCC = f => new Cont(k => f(x => new Cont(_ => k(x))).runCont(k));

var log = (x, ms) => new Cont(k => setTimeout(_ => k(console.log(x)), ms));

var omega = x => x(x); // This is a very dangerous function. Run `omega(omega)`.

callCC(omega).bind(cc => log("loop", 1000).bind(_ => cc(cc))).runCont(x => x);

function defclass(prototype) {
    var constructor = prototype.constructor;
    constructor.prototype = prototype;
    return constructor;
}

这段代码相当于：

forever:
    delay(1000);
    print("loop");
    goto forever;

因此，在使用延续时应该小心。

---

^[1] 延续通常使用一等函数来实现。然而，在像 Scheme 这样具有一流延续的语言中，延续和函数是有区别的。尽管如此，即使延续不是一个函数，它仍然像一个函数，因为它是可调用的。