我正在努力掌握延续的概念，我发现了一些像Wikipedia article这样的小教学例子：
(define the-continuation #f)
(define (test)
(let ((i 0))
; call/cc calls its first function argument, passing
; a continuation variable representing this point in
; the program as the argument to that function.
;
; In this case, the function argument assigns that
; continuation to the variable the-continuation.
;
(call/cc (lambda (k) (set! the-continuation k)))
;
; The next time the-continuation is called, we start here.
(set! i (+ i 1))
i))
我理解这个小功能的作用，但我看不出任何明显的应用。虽然我不希望很快在我的代码中使用延续，但我希望我知道一些它们可能适合的情况。
所以我正在寻找更多有用的代码示例，说明了作为程序员可以提供什么延续。
干杯！
答案 0 :(得分：16)
在Algo＆amp;数据II我们一直使用这些来从（长）函数“退出”或“返回”
例如，用于遍历树的BFS算法实现如下：
(define (BFS graph root-discovered node-discovered edge-discovered edge-bumped . nodes)
(define visited (make-vector (graph.order graph) #f))
(define q (queue.new))
(define exit ())
(define (BFS-tree node)
(if (node-discovered node)
(exit node))
(graph.map-edges
graph
node
(lambda (node2)
(cond ((not (vector-ref visited node2))
(when (edge-discovered node node2)
(vector-set! visited node2 #t)
(queue.enqueue! q node2)))
(else
(edge-bumped node node2)))))
(if (not (queue.empty? q))
(BFS-tree (queue.serve! q))))
(call-with-current-continuation
(lambda (my-future)
(set! exit my-future)
(cond ((null? nodes)
(graph.map-nodes
graph
(lambda (node)
(when (not (vector-ref visited node))
(vector-set! visited node #t)
(root-discovered node)
(BFS-tree node)))))
(else
(let loop-nodes
((node-list (car nodes)))
(vector-set! visited (car node-list) #t)
(root-discovered (car node-list))
(BFS-tree (car node-list))
(if (not (null? (cdr node-list)))
(loop-nodes (cdr node-list)))))))))
如您所见，当节点发现的函数返回true时，算法将退出：
(if (node-discovered node)
(exit node))
该函数还将给出“返回值”：'node'
函数退出的原因是因为这句话：
(call-with-current-continuation
(lambda (my-future)
(set! exit my-future)
当我们使用exit时，它将返回执行前的状态，清空调用堆栈并返回你给它的值。
所以基本上，call-cc用于（这里）跳出递归函数，而不是等待整个递归自行结束（在进行大量计算工作时这可能非常昂贵）
另一个与call-cc相同的小例子：
(define (connected? g node1 node2)
(define visited (make-vector (graph.order g) #f))
(define return ())
(define (connected-rec x y)
(if (eq? x y)
(return #t))
(vector-set! visited x #t)
(graph.map-edges g
x
(lambda (t)
(if (not (vector-ref visited t))
(connected-rec t y)))))
(call-with-current-continuation
(lambda (future)
(set! return future)
(connected-rec node1 node2)
(return #f))))
答案 1 :(得分：9)
答案 2 :(得分：7)
@Pat
海边
是的，Seaside就是一个很好的例子。我快速浏览了它的代码，发现这条消息说明了在网络上以一种看似有状态的方式在组件之间传递控制。
WAComponent >> call: aComponent
"Pass control from the receiver to aComponent. The receiver will be
temporarily replaced with aComponent. Code can return from here later
on by sending #answer: to aComponent."
^ AnswerContinuation currentDo: [ :cc |
self show: aComponent onAnswer: cc.
WARenderNotification raiseSignal ]
太好了！
答案 3 :(得分：6)
我构建了自己的单元测试软件。在执行测试之前，我在执行测试之前存储延续，然后在失败时，我（可选）告诉方案解释器进入调试模式，并重新调用延续。通过这种方式，我可以轻松地逐步完成有问题的代码。
如果您的continuation是可序列化的，那么您还可以存储应用程序失败，然后重新调用它们以获取有关变量值，堆栈跟踪等的详细信息。
答案 4 :(得分：5)
某些Web服务器和Web框架使用Continuations来存储会话信息。为每个会话创建一个continuation对象，然后由会话中的每个请求使用。
答案 5 :(得分：5)
我使用延续来自this post http://www.randomhacks.net中amb运算符的实现。
以下是amb操作符的作用：
# amb will (appear to) choose values
# for x and y that prevent future
# trouble.
x = amb 1, 2, 3
y = amb 4, 5, 6
# Ooops! If x*y isn't 8, amb would
# get angry. You wouldn't like
# amb when it's angry.
amb if x*y != 8
# Sure enough, x is 2 and y is 4.
puts x, y
这是帖子的实现：
# A list of places we can "rewind" to
# if we encounter amb with no
# arguments.
$backtrack_points = []
# Rewind to our most recent backtrack
# point.
def backtrack
if $backtrack_points.empty?
raise "Can't backtrack"
else
$backtrack_points.pop.call
end
end
# Recursive implementation of the
# amb operator.
def amb *choices
# Fail if we have no arguments.
backtrack if choices.empty?
callcc {|cc|
# cc contains the "current
# continuation". When called,
# it will make the program
# rewind to the end of this block.
$backtrack_points.push cc
# Return our first argument.
return choices[0]
}
# We only get here if we backtrack
# using the stored value of cc,
# above. We call amb recursively
# with the arguments we didn't use.
amb *choices[1...choices.length]
end
# Backtracking beyond a call to cut
# is strictly forbidden.
def cut
$backtrack_points = []
end
我喜欢amb！
答案 6 :(得分：3)
只要程序流程不是线性的，甚至不是预先确定的，就可以在“真实”示例中使用Continuations。熟悉的情况是web applications。
答案 7 :(得分：3)
Continuations是服务器编程中每个请求线程的一个很好的替代方案（包括Web应用程序前端。
在这个模型中，不是每次请求进入时都启动一个新的（重）线程，而是在函数中启动一些工作。然后，当您准备阻止I / O（即从数据库读取）时，您将继续传递到网络响应处理程序。当响应返回时，执行continuation。使用此方案，您只需几个线程即可处理大量请求。
这使得控制流程比使用阻塞线程更复杂，但在负载较重的情况下，它更有效率（至少在今天的硬件上）。
答案 8 :(得分：2)
amb运算符是一个很好的例子，允许类似prolog的声明性编程。
正如我们所说，我正在编写一个Scheme中的音乐作曲软件（我是一个音乐家，旁边不知道音乐背后的理论，我只是在分析我自己的作品，看看它背后的数学是怎样的工作的。）
使用amb运算符我可以填写旋律必须满足的约束，让Scheme算出结果。
由于语言哲学，可能会将Continuations放入Scheme中，Scheme是一个框架，通过在Scheme本身中定义库，您可以了解其他语言中的任何编程范例。 Continuations用于组成您自己的抽象控制结构，如'return'，'break'或启用声明性编程。 Scheme更加“泛化”，并且认为这样的结构也应该由程序员指定。
答案 9 :(得分：1)
Google Mapplets API怎么样？有许多函数（都以Async结尾）传递回调。 API函数执行异步请求，获取结果，然后将结果传递给回调（作为“接下来要做的事情”）。对我而言听起来很像continuation passing style。
这个example显示了一个非常简单的案例。
map.getZoomAsync(function(zoom) {
alert("Current zoom level is " + zoom); // this is the continuation
});
alert("This might happen before or after you see the zoom level message");
因为这是Javascript，所以没有tail call optimization，所以堆栈会随着每次调用而增长，并且最终会将控制线程返回给浏览器。尽管如此，我认为这是一个很好的抽象。
答案 10 :(得分：1)
如果必须调用异步操作，并在获得结果之前暂停执行，通常会轮询结果或将其余代码放入回调中，以便在完成时由异步操作执行。使用continuation，您不需要执行低效的轮询选项，并且您不需要将所有代码包装在回调中的asynch事件之后运行 - 您只需将代码的当前状态作为回调传递 - 一旦异步操作完成，代码就会被有效“唤醒”。
答案 11 :(得分：0)
Continuations可用于实现异常，一个调试器。