标签: callcc

我正在尝试return在Scheme R6RS中实现一个函数.我想要这样的东西:

(lambda ()
  (do-some-job-before)
  (return some-value)
  (do-some-job-after))

执行(do-some-job-before),不执行 (do-some-job-after)和lambda函数的最终值some-value.

我想我必须继续使用.我试过了:

(define return #f)
(call/cc (lambda (k)
           (set! return k)))

但它不起作用; 例如

(+ 2 (return 3)) ; -> 3 (and not 5 as I expected)

我怎样才能做到这一点？

是否可以在Google的新语言Go中进行Call-with-current-continuation？

在Scheme中执行从call/cc有效跳转到初始调用/ cc 获得的延续并恢复保存的调用堆栈.

我刚刚开始学习Haskell,我正在试图弄清楚如何理解callCC.这是试图callCC理解Scheme的理解call/cc.执行callCC是

callCC f = cont $ \h -> runCont (f (\a -> cont $ \_ -> h a)) h

据我所知,没有提到有关保存或恢复调用堆栈的内容.callCCHaskell的解释是如何熟悉Scheme的call/cc.

编辑:也许如果有人可以将以下内容翻译成Haskell,这将有助于我理解.

(define (f return)
  (return 2)
  3)

(display (f (lambda (x) x))) ; displays 3

(display (call-with-current-continuation f)) ; displays 2

如何在Squeak中获得BlockClosure(我想使用BlockClosure >> callCC)？

当我写[#foo]这是一个BlockContext时,这是什么交易？

更新:我已经知道BlockClosure主要是新编译器.

相反,我如何使用海边Continuations？我遇到了问题,任何例子都会受到赞赏.

进一步更新:这样做的目的不是使用海边(至少不是直接),而是以比滚动我自己的状态跟踪迭代器更容易的方式编写遍历和其他类似的东西.

以下两个代码块都应该(在我看来)是无限循环

这有效

(define call/cc call-with-current-continuation)

(define l 0)
(define i 0)

((lambda ()
   (call/cc
    (lambda (k)
      (set! l k)))
   (write i)
   (newline)
   (set! i (+ i 1))
   (l "ignore")))

这不起作用:

(define call/cc call-with-current-continuation)

(define l 0)
(define i 0)

(begin
   (call/cc
    (lambda (k)
      (set! l k)))
   (write i)
   (newline)
   (set! i (+ i 1))
   (l "ignore"))

唯一的区别是一个使用lambda,一个使用begin块.为什么第二块代码不起作用？

谢谢

来自 R5RS 标准：

Values might be defined as follows:
(define (values . things)
  (call-with-current-continuation
    (lambda (cont) (apply cont things))))

我对此的第一个解释是像这样的表达式(+ (values 1 2))等价于(apply + '(1 2))并且会产生结果3。但是，根据我的测试，这种解释是不正确的。这是我对上面代码的解释：values是一个带有任意数量参数的函数，捆绑到一个名为things. 然后，values使用things“未捆绑”列表调用当前的延续（使用的地方）。

我错过了什么？上面的示例(+ (values 1 2))根据我使用的解释器给出了错误或 1。

的参数call/cc是一个过程，其参数是一个延续。程序是用CPS 写的吗？

我试图理解用 python 代码编写的方案过程：

def callcc(proc):
    "Call proc with current continuation; escape only"
    ball = RuntimeWarning("Sorry, can't continue this continuation any longer.")
    def throw(retval): ball.retval = retval; raise ball
    try:
        return proc(throw)
    except RuntimeWarning as w:
        if w is ball: return ball.retval
        else: raise w

它来自本教程：http : //norvig.com/lispy2.html。

以上是如何工作的？是什么ball意思，为什么 a proc(edure?) 被称为 athrow作为其参数值？评论“仅转义”是什么意思？

顺便说一句，这是我目前（可能是被误导的）对适用于 python 的延续的理解，这类似于传递一个带产量的函数：

def c(func, *args, **kwargs):
    # func must be a coroutine
    return func(*args, **kwargs)

def inc(x=0):
    while True:
        yield …

例如,我有两个异步方法

(get-a 10 (lambda (a) (get-b a (lambda (b) (display b)))

但我想写一些类似的东西

(define (a (get-a 10)))
(define (b (get-b a)))
(display b)