延续通过式程序

问题描述

我很难理解连续过程如何传递先前函数调用中的样式“记住”值。

作为示例，我有以下过程将从列表中过滤偶数值：

(define (get-pairs alist proc)
  (if (null? alist)
      (proc '())
      (get-pairs
       (cdr alist)
       (lambda (l)
         (let ((num (car alist)))
           (if (zero? (remainder num 2))
               (proc (cons num l))
               (proc l)))))))

然后我用：

(get-pairs '(1 2)
           (lambda (n) (display n)))

要获得预期的结果(2)。

get-pairs将递归调用自身，直到其参数alist为空。那么最后一个函数调用将是：(get-pairs '() proc)。 proc将是以下过程：

(lambda (l)
         (let ((num (car alist)))
           (if (zero? (remainder num 2))
               (proc (cons num l))
               (proc l))))

在此lambda主体中，alist和proc是之前的函数调用的参数：(get-pairs '(2) proc)。我的问题是，如果proc仅在最后评估，每个lambda过程如何“记住”过去函数调用的参数？

或者是在每次调用get-pairs时，都会“分析”作为参数传递给下一个调用的lambda主体，并带有alist和proc的对应值已经取代了它的身体？

解决方法

由优化尾调用的函数创建的

TL; DR： 闭包必须捕获其定义环境（相关部分）的副本 。或者，只需忽略TCO部分，并像对待常规递归函数一样对待它，在递归函数执行期间创建的任何lambda函数都是闭包，捕获其引用的变量的值。

---

这可以在方案评估的环境模型框架中理解。

每次调用(lambda (...) ...)都会创建一个新的lambda函数对象，该对象与它的定义环境隐式地配对在一起，称为 closure 。

每次调用get-pairs都会创建自己的新调用框架，并且从创建的所有lambda都将保留在指向（副本）的隐藏指针上>该框架。

使用以下变体可以更容易地看到这些变体，这些变体的功能与问题中的变体完全相同：

(define (get-pairs1 alist proc)
  (if (null? alist)
      (proc '())
      (get-pairs1
       (cdr alist)
       (let ((alist alist))   ; creates fresh new environment frame
         (lambda (l)
           (let ((num (car alist)))
             (if (zero? (remainder num 2))
                 (proc (cons num l))
                 (proc l))))))))

(define (get-pairs2 alist proc)
  (if (null? alist)
      (proc '())
      (get-pairs2
       (cdr alist)
       (let* ((alist  alist)
              (num  (car alist))
              (newproc 
               (if (zero? (remainder num 2))
                   (lambda (l) (proc (cons num l)))
                   (lambda (l) (proc l)))))
         newproc))))

proc不是 “在最后求值”，过程是变量proc的值是在最后被调用，但是在每次调用时都发现了变量proc的值。并且在每次调用时值都不同，即在get-pairs的每次单独调用中重新创建 new lambda函数对象。每次调用proc时，变量get-pairs的值是不同的。

因此，对于示例调用(get-pairs2 '(1 2 3 4) display)，最终的proc调用与

相同

((lambda (l4)             ;                  |
    ((lambda (l3)          ;             |   |
        ((lambda (l2)       ;        |   |   |
            ((lambda (l1)    ;   |   |   |   |
                (display      ;  1   2   3   4
                 l1))         ;  |   |   |   |
             (cons 2 l2)))   ;       |   |   |
         l3))               ;            |   |
     (cons 4 l4)))         ;                 |
 '())

;; i.e.
;;  l1 = cons 2 l2
;;              l2 = l3
;;                   l3 = cons 4 l4
;;                               l4 = '()

也可以用伪代码编写为

(((((display ∘ identity) ∘ {cons 2}) ∘ identity) ∘ {cons 4}) '())
;   └───────1──────────┘
;  └───────────────2───────────────┘
; └─────────────────────────3──────────────────┘
;└───────────────────────────────────4─────────────────────┘

;; 1: created on 1st invocation of `get-pairs2`
;; 2: created on 2nd invocation of `get-pairs2`
;; 3: created on 3rd invocation of `get-pairs2`
;; 4: created on the final 4th invocation of `get-pairs2`,;;    and then called with `'()` as the argument

其中{cons n}表示部分应用的cons，即(lambda (l) (cons n l))，而identity是(lambda (l) l)。

哦，∘代表函数组成(f ∘ g) = (lambda (x) (f (g x)))。

另请参阅我的其他一些相关答案，here和here。

---

通过逐步调用(get-pairs2 '(1 2 3 4))，并通过基于let的重写来模拟函数调用，我们得到了（简化了一点）

(get-pairs2 '(1 2 3 4) display)
=
(let ((alist '(1 2 3 4))                       ; '(1 2 3 4)
      (proc  display))                         
  (let* ((num (car alist))                       ; 1       
         (newproc (lambda (l) (proc l))))            
    (let ((alist (cdr alist))                    ; '(2 3 4)  
          (proc newproc))                          
      (let* ((num (car alist))                     ; 2   
             (newproc (lambda (l) (proc (cons num l))))) 
        (let ((alist (cdr alist))                  ; '(3 4)
              (proc newproc))         
          (let* ((num (car alist))                   ; 3  
                 (newproc (lambda (l) (proc l))))  
            (let ((alist (cdr alist))                ; '(4)
                  (proc newproc))
              (let* ((num (car alist))                 ; 4
                     (newproc (lambda (l) (proc (cons num l)))))
                (let ((alist (cdr alist))              ; '()
                      (proc newproc))
                  (proc '()))))))))))

将其加载到DrRacket的代码编辑窗口中，然后将鼠标悬停在各个标识符上，这是一个有趣的游戏，可让您查看每个标识符所指的含义。使用Ctrl-R运行此代码还会产生与原始函数调用相同的结果。

另一个“有趣”的练习是遍历上面嵌套的let表达式，并通过向其添加唯一索引来手动重命名每个标识符（将proc更改为proc1，{{1 }}等），因此每个名称都变得唯一。

好的，我会为您做的，尤其是DrRacket具有一个不错的“重命名标识符”功能，这使它变得更加容易且不易出错。但是也请尝试自己做。

proc2

所以您看到，它与(let ((alist '(1 2 3 4)) ; '(1 2 3 4) (proc display)) (let* ((num (car alist)) ; 1 (newproc (lambda (l) (proc l)))) (let ((alist2 (cdr alist)) ; '(2 3 4) (proc2 newproc)) (let* ((num2 (car alist2)) ; 2 (newproc2 (lambda (l) (proc2 (cons num2 l))))) (let ((alist3 (cdr alist2)) ; '(3 4) (proc3 newproc2)) (let* ((num3 (car alist3)) ; 3 (newproc3 (lambda (l) (proc3 l)))) (let ((alist4 (cdr alist3)) ; '(4) (proc4 newproc3)) (let* ((num4 (car alist4)) ; 4 (newproc4 (lambda (l) (proc4 (cons num4 l))))) (let ((alist5 (cdr alist4)) ; '() (proc5 newproc4)) (proc5 '())))))))))) 不同。其中有五个，每个都有可能不同，每个都位于不同的嵌套环境框架中。

---

您可能会问，为什么嵌套环境？毕竟proc是尾递归的，因此它不能这样做，可以将其调用框架重新用于下一次调用。

是的，但这仍然是与代码的操作效率相关的实现细节，不会改变其含义（语义）。 从语义上来说，通过嵌套的get-pairs2重写，更容易看到代码的含义。

尽管如此，这仍是您困惑的正确点和潜在根源。这一次我也很困惑。

这就是为什么我在这篇文章的开头在那里写“ （环境的副本）”的原因。即使尾递归调用可以（甚至必须在Scheme的TCO保证下）必须重新使用其自身的调用框架进行下一次调用，新创建的闭包也必须保留其自己的副本 ，以免引入语义上不同的标识符的错误合并。

---

实际上，可以通过以下及时的计算来描述环境的扁平化和帧重用：

let

或者作为实际上可能被编译为的定义

;; re-use the tail-recursive call frame {alist proc}
(let ((alist '(1 2 3 4))
      (proc  display)
      (num #f))
  (set! num  (car alist))                        ; 1
  (set! proc (let ((num num) (proc proc))        ; closure!
               (lambda (l) (proc l))))
  (set! alist (cdr alist))                       ; (2 3 4)
  (set! num  (car alist))                        ;  2
  (set! proc (let ((num num) (proc proc))        ; closure!
               (lambda (l) (proc (cons num l)))))
  (set! alist (cdr alist))                       ;   (3 4)
  (set! num  (car alist))                        ;    3
  (set! proc (let ((num num) (proc proc))        ; closure!
               (lambda (l) (proc l))))
  (set! alist (cdr alist))                       ;     (4)
  (set! num (car alist))                         ;      4
  (set! proc (let ((num num) (proc proc))        ; closure!
               (lambda (l) (proc (cons num l)))))
  (set! alist (cdr alist))                       ;      ()
  (proc '()))

那么现在有多少(let ((alist '(1 2 3 4)) (proc display) (num #f)) (let loop () (set! num (car alist)) (set! proc (let ((num num) (proc proc)) (if (zero? (remainder num 2)) (lambda (l) (proc (cons num l))) (lambda (l) (proc l))))) (set! alist (cdr alist)) (if (null? alist) (proc '()) (loop)))) 个？ ：）

_{（仍为五个，否则将无法正常工作...即有一个绑定，但在循环运行期间创建了五个值，每个将前一个封装在其中（或者实际上是持有对其的引用）；最后一个proc值（是一个函数）最终运行时，它将在其中“调用”一个，一个会调用一个“内部” it ，依此类推，直到第一个proc，即我们开始的proc。）}