我尝试在Javascript中实现延续monad,以处理延续传递样式和异步控制流。这是我继续学习的单子(monad):
// 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
似乎很合适,因为它提供了一个转义继续机制,用于续奏单子(monad),如http://hackage.haskell.org/所述。但是我不知道如何应用
callcc
,也没有找到描述这种应用程序的合适资源。 最佳答案
简而言之
连续是一个强大的抽象。让我强调一下。延展是极大的强大抽象。为什么延续如此强大?这是因为延续只是函数[1]和“functions have a dangerous property of being invokable.”,稍后再介绍。
那么,如果延续只是一个函数,那为什么如此特别呢?
是的,延续只是一个功能。但是,使延续如此特别的是它所代表的含义。延续表示“计算的其余部分”(也称为计算上下文)。例如,考虑以下Scheme表达式:
(add1 (* 3 x))
; |_____|
; |
; computation
(add1 [])
; |_______|
; |
; context
在此,计算
(* 3 x)
具有上下文(add1 [])
,其中[]
表示一个孔。可以将计算结果塞入孔中。对于某些(add1 [result])
,它被写为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)的语言中,延续性和功能之间是有区别的。但是,即使延续不是函数,它仍然可以调用,就像函数一样。