152

我一直在浏览整个网络以寻找关于延续的启示,令人难以置信的是,最简单的解释如何完全让像我这样的 JavaScript 程序员感到困惑。当大多数文章用 Scheme 中的代码解释延续或使用 monad 时,尤其如此。

现在我终于认为我已经理解了延续的本质,我想知道我所知道的是否真的是事实。如果我认为是真的不是真的,那是无知而不是开悟。

所以,这就是我所知道的:

在几乎所有语言中,函数都显式地将值(和控制)返回给它们的调用者。例如:

var sum = add(2, 3);

console.log(sum);

function add(x, y) {
    return x + y;
}

现在在具有一流函数的语言中,我们可以将控制权和返回值传递给回调,而不是显式返回给调用者:

add(2, 3, function (sum) {
    console.log(sum);
});

function add(x, y, cont) {
    cont(x + y);
}

因此,我们不是从一个函数返回一个值,而是继续另一个函数。因此这个函数被称为第一个函数的延续。

那么延续和回调有什么区别呢?

4

3 回答 3

179

我相信延续是回调的特例。一个函数可以回调任意数量的函数,任意次数。例如:

var array = [1, 2, 3];

forEach(array, function (element, array, index) {
    array[index] = 2 * element;
});

console.log(array);

function forEach(array, callback) {
    var length = array.length;
    for (var i = 0; i < length; i++)
        callback(array[i], array, i);
}

但是,如果一个函数回调另一个函数作为它所做的最后一件事,那么第二个函数称为第一个函数的延续。例如:

var array = [1, 2, 3];

forEach(array, function (element, array, index) {
    array[index] = 2 * element;
});

console.log(array);

function forEach(array, callback) {
    var length = array.length;

    // This is the last thing forEach does
    // cont is a continuation of forEach
    cont(0);

    function cont(index) {
        if (index < length) {
            callback(array[index], array, index);
            // This is the last thing cont does
            // cont is a continuation of itself
            cont(++index);
        }
    }
}

如果一个函数调用另一个函数作为它做的最后一件事,那么它被称为尾调用。像 Scheme 这样的一些语言会执行尾调用优化。这意味着尾调用不会产生函数调用的全部开销。相反,它被实现为一个简单的 goto(调用函数的堆栈帧被尾调用的堆栈帧替换)。

奖金:继续传球风格。考虑以下程序:

console.log(pythagoras(3, 4));

function pythagoras(x, y) {
    return x * x + y * y;
}

现在,如果每个操作(包括加法、乘法等)都以函数的形式编写,那么我们将有:

console.log(pythagoras(3, 4));

function pythagoras(x, y) {
    return add(square(x), square(y));
}

function square(x) {
    return multiply(x, x);
}

function multiply(x, y) {
    return x * y;
}

function add(x, y) {
    return x + y;
}

此外,如果我们不允许返回任何值,那么我们将不得不使用延续,如下所示:

pythagoras(3, 4, console.log);

function pythagoras(x, y, cont) {
    square(x, function (x_squared) {
        square(y, function (y_squared) {
            add(x_squared, y_squared, cont);
        });
    });
}

function square(x, cont) {
    multiply(x, x, cont);
}

function multiply(x, y, cont) {
    cont(x * y);
}

function add(x, y, cont) {
    cont(x + y);
}

这种不允许返回值(因此您必须求助于传递延续)的编程风格称为延续传递风格。

然而,延续传递风格存在两个问题:

  1. 传递延续会增加调用堆栈的大小。除非您使用像 Scheme 这样消除尾调用的语言,否则您将面临堆栈空间不足的风险。
  2. 编写嵌套函数很痛苦。

第一个问题可以通过异步调用延续在 JavaScript 中轻松解决。通过异步调用延续,函数在调用延续之前返回。因此调用堆栈大小不会增加:

Function.prototype.async = async;

pythagoras.async(3, 4, console.log);

function pythagoras(x, y, cont) {
    square.async(x, function (x_squared) {
        square.async(y, function (y_squared) {
            add.async(x_squared, y_squared, cont);
        });
    });
}

function square(x, cont) {
    multiply.async(x, x, cont);
}

function multiply(x, y, cont) {
    cont.async(x * y);
}

function add(x, y, cont) {
    cont.async(x + y);
}

function async() {
    setTimeout.bind(null, this, 0).apply(null, arguments);
}

第二个问题通常使用一个名为的函数来解决,该函数call-with-current-continuation通常缩写为callcc. 不幸的是callcc不能在 JavaScript 中完全实现,但我们可以为它的大多数用例编写一个替换函数:

pythagoras(3, 4, console.log);

function pythagoras(x, y, cont) {
    var x_squared = callcc(square.bind(null, x));
    var y_squared = callcc(square.bind(null, y));
    add(x_squared, y_squared, cont);
}

function square(x, cont) {
    multiply(x, x, cont);
}

function multiply(x, y, cont) {
    cont(x * y);
}

function add(x, y, cont) {
    cont(x + y);
}

function callcc(f) {
    var cc = function (x) {
        cc = x;
    };

    f(cc);

    return cc;
}

callcc函数接受一个函数f并将其应用于current-continuation(缩写为cc)。current-continuation是一个延续函数,它在调用callcc.

考虑函数的主体pythagoras

var x_squared = callcc(square.bind(null, x));
var y_squared = callcc(square.bind(null, y));
add(x_squared, y_squared, cont);

第二current-continuationcallcc是:

function cc(y_squared) {
    add(x_squared, y_squared, cont);
}

同样current-continuation,第一个callcc是:

function cc(x_squared) {
    var y_squared = callcc(square.bind(null, y));
    add(x_squared, y_squared, cont);
}

由于current-continuation第一个callcc包含另一个callcc,因此必须将其转换为继续传递样式:

function cc(x_squared) {
    square(y, function cc(y_squared) {
        add(x_squared, y_squared, cont);
    });
}

因此,从本质callcc上讲,将整个函数体从逻辑上转换回我们的起点(并将这些匿名函数命名为cc)。使用 callcc 实现的 pythagoras 函数变为:

function pythagoras(x, y, cont) {
    callcc(function(cc) {
        square(x, function (x_squared) {
            square(y, function (y_squared) {
                add(x_squared, y_squared, cont);
            });
        });
    });
}

同样,您不能callcc在 JavaScript 中实现,但您可以在 JavaScript 中实现延续传递样式,如下所示:

Function.prototype.async = async;

pythagoras.async(3, 4, console.log);

function pythagoras(x, y, cont) {
    callcc.async(square.bind(null, x), function cc(x_squared) {
        callcc.async(square.bind(null, y), function cc(y_squared) {
            add.async(x_squared, y_squared, cont);
        });
    });
}

function square(x, cont) {
    multiply.async(x, x, cont);
}

function multiply(x, y, cont) {
    cont.async(x * y);
}

function add(x, y, cont) {
    cont.async(x + y);
}

function async() {
    setTimeout.bind(null, this, 0).apply(null, arguments);
}

function callcc(f, cc) {
    f.async(cc);
}

该函数callcc可用于实现复杂的控制流结构,例如 try-catch 块、协程、生成器、fibers等。

于 2012-12-24T14:02:43.947 回答
31

尽管写得很精彩,但我认为您有点混淆了您的术语。例如,当调用是函数需要执行的最后一件事时发生尾调用是正确的,但就延续而言,尾调用意味着函数不会修改调用它的延续,只是它更新传递给延续的值(如果需要)。这就是为什么将尾递归函数转换为 CPS 如此简单(您只需将延续作为参数添加并在结果上调用延续)。

将延续称为回调的特殊情况也有点奇怪。我可以看到它们是如何轻松组合在一起的,但延续并不是因为需要与回调区分开来。延续实际上表示完成计算的剩余指令,或从时间点开始的剩余计算。您可以将延续视为需要填充的洞。如果我可以捕获程序的当前延续,那么我可以准确地回到我捕获延续时程序的状态。(这肯定会使调试器更容易编写。)

在这种情况下,您的问题的答案是,回调是一种通用的东西,它在由调用者 [回调的] 提供的某些合同指定的任何时间点被调用。回调可以有尽可能多的参数,并且可以以任何它想要的方式构造。那么,一个continuation必然是一个单参数过程,它解析传递给它的值。延续必须应用于单个值,并且应用程序必须在最后发生。当延续完成执行表达式时,表达式就完成了,并且根据语言的语义,可能会或可能不会产生副作用。

于 2013-09-19T10:42:26.530 回答
18

简短的回答是,延续和回调之间的区别在于,在调用(并完成)回调之后,执行会在调用它的点恢复,而调用延续会导致执行在创建延续的点恢复。换句话说:延续永远不会返回

考虑函数:

function add(x, y, c) {
    alert("before");
    c(x+y);
    alert("after");
}

(我使用 Javascript 语法,即使 Javascript 实际上不支持一流的延续,因为这是您提供示例的内容,对于不熟悉 Lisp 语法的人来说,它会更容易理解。)

现在,如果我们向它传递一个回调:

add(2, 3, function (sum) {
    alert(sum);
});

然后我们将看到三个警报:“之前”、“5”和“之后”。

另一方面,如果我们要向它传递一个与回调做同样事情的延续,就像这样:

alert(callcc(function(cc) {
    add(2, 3, cc);
}));

那么我们只会看到两个警报:“之前”和“5”。调用c()insideadd()结束执行add()并导致callcc()返回;返回的callcc()值是作为参数传递给c(即总和)的值。

从这个意义上说,即使调用延续看起来像一个函数调用,它在某些方面更类似于返回语句或抛出异常。

事实上, call/cc 可以用来给不支持的语言添加返回语句。例如,如果 JavaScript 没有 return 语句(相反,像许多 Lisp 语言一样,只返回函数体中最后一个表达式的值)但有 call/cc,我们可以像这样实现 return:

function find(myArray, target) {
    callcc(function(return) {
        var i;
        for (i = 0; i < myArray.length; i += 1) {
            if(myArray[i] === target) {
                return(i);
            }
        }
        return(undefined); // Not found.
    });
}

调用return(i)会调用一个延续,该延续终止匿名函数的执行并导致callcc()返回itarget中找到的索引myArray

(注意:在某些方面,“返回”类比有点简单化。例如,如果延续从创建它的函数中逃脱 - 通过保存在全局某处,例如 - 该函数可能即使它只被调用一次,它也可以返回多次。)

Call/cc 可以类似地用于实现异常处理(throw 和 try/catch)、循环和许多其他控制结构。

为了消除一些可能的误解:

  • 为了支持一流的延续,无论如何都不需要尾调用优化。考虑到即使是 C 语言也有一种(受限制的)形式的延续setjmp(),它创建一个延续,并且longjmp()调用一个延续!

    • 另一方面,如果你天真地尝试在没有尾调用优化的情况下以连续传递风格编写程序,那么你注定最终会溢出堆栈。
  • 没有特别的理由继续需要只接受一个参数。只是延续的参数成为 call/cc 的返回值,而 call/cc 通常被定义为具有单个返回值,因此延续自然必须恰好取一个。在支持多个返回值的语言中(如 Common Lisp、Go 或实际上是 Scheme),完全有可能拥有接受多个值的延续。

于 2016-10-24T22:22:47.320 回答