方案延续-需要解释

Question

以下示例涉及跳转到继续并退出。有人可以解释一下函数的流程吗？我正在围绕 Continuation 转一圈，并且不知道函数的入口点和导出点。

(define (prod-iterator lst)
  (letrec ((return-result empty)
        (resume-visit (lambda (dummy) (process-list lst 1)))
        (process-list
         (lambda (lst p)
           (if (empty? lst)
               (begin
                 (set! resume-visit (lambda (dummy) 0))
                 (return-result p))
               (if (= 0 (first lst))
                   (begin
                     (call/cc ; Want to continue here after delivering result     
                      (lambda (k)
                        (set! resume-visit k)
                        (return-result p)))
                     (process-list (rest lst) 1))
                   (process-list (rest lst) (* p (first lst))))))))
    (lambda ()
      (call/cc
       (lambda (k)
         (set! return-result k)
         (resume-visit 'dummy))))))

(define iter (prod-iterator '(1 2 3 0 4 5 6 0 7 0 0 8 9)))
(iter) ; 6                                                                        
(iter) ; 120                                                                      
(iter) ; 7                                                                        
(iter) ; 1                                                                        
(iter) ; 72                                                                       
(iter) ; 0                                                                        
(iter) ; 0

谢谢。

Answer 1

该过程迭代列表，将非零成员相乘，并在每次找到零时返回结果。 Resume-visit 存储处理列表其余部分的延续，return-result 存储迭代器调用站点的延续。一开始，定义了 resume-visit 来处理整个列表。每次找到零时，都会捕获一个延续，在调用该延续时，会针对当时 lst 的任何值执行 (process-list (rest lst) 1) 。当列表耗尽时，resume-visit 被设置为一个虚拟过程。此外，程序每次调用 iter 时，都会执行以下操作:

(call/cc
   (lambda (k)
     (set! return-result k)
     (resume-visit 'dummy)))

也就是说，它捕获调用者的延续，调用它向调用者返回一个值。延续部分被存储，程序跳转到处理列表的其余部分。当过程调用resume-visit时，进入循环，当调用return-result时，退出循环。

如果我们想更详细地检查process-list，我们假设该列表非空。该过程采用基本递归，累积结果直到找到零。此时，p 是累加值，lst 是包含零的列表。当我们有像 (begin (call/cc (lambda (k) first)) rest) 这样的结构时，我们首先执行带有 k 的 first 表达式> 绑定(bind)到延续。它是一个在调用时执行 rest 表达式的过程。在这种情况下，该延续被存储并调用另一个延续，该延续将累积结果p返回给iter的调用者。该延续将在下次调用 iter 时调用，然后循环继续处理列表的其余部分。这就是延续的重点，其他一切都是基本递归。