scheme - Scheme 中的收集器函数是如何工作的？

Question

我无法理解 Scheme 中收集器函数的使用。我正在使用“The Little Schemer”一书(Daniel P. Friedman 和 Matthias Felleisen 着)。一个带有一些解释的综合示例将对我有很大帮助。以下代码段是使用收集器函数的函数示例:

(define identity
  (lambda (l col)
    (cond
      ((null? l) (col '()))
      (else (identity
              (cdr l)
              (lambda (newl)
                (col (cons (car l) newl))))))))

... 示例调用是 (identity '(a b c) self) 和 self-function 是 (define self (lambda (x) x))。 identity 函数返回给定列表 l，因此给定调用的输出将是 (a b c)。使用的确切语言是 R5RS 旧版语言。

Answer 1

鉴于这些“收集器”函数是如何在 identity 定义中定义的，调用

(identity xs col)

对于任何列表xs和一些“收集器”函数col，等同于调用

(col xs)

所以 same 列表将被“返回”，即传递给它的参数“collector”/延续函数 col。这就解释了它的名字，identity，然后。

为了比较，反向可以编码为

(define reverse     ; to be called as e.g. (reverse l display)
  (lambda (l col)
    (cond
      ((null? l) (col '()))        ; a reversed empty list is empty
      (else (reverse (cdr l)       ; a reversed (cdr l) is newl --
                     (lambda (newl)    ; what shall I do with it when it's ready?
                       (col            ; append (car l) at its end and let col
                          (append newl                           ; deal with it!
                                  (list (car l))))))))))

这种编程风格被称为 continuation-passing style :每个函数都传递了一个“延续”，假设它将传递其余计算的结果，以便最终将最终结果传递给原始延续/收集器函数。每个收集器的参数代表它将收到的 future “结果”，然后收集器函数本身指定然后如何处理它。

不要被术语混淆:这些函数不是 call/cc 函数捕获的“延续”，它们是普通的 Scheme 函数，代表“下一步要做什么”。

定义可以理解为

identity :
  to transform a list xs 
        with a collector function col,
    is 
    | to call (col xs)                              , if xs is empty, or
    | to transform (cdr xs)  
        with a new collector function col2  
        such that
              (col2 r)  =  (col (cons (car xs) r))  , otherwise.

(或者我们可以将其写成伪代码，如)

(identity list col)  =
  | empty? list           ->  (col list)
  | match? list (x . xs)  ->  (identity xs col2)
                                where 
                                (col2 r)  =  (col (cons x r))

col2 通过将 (cons x r) 传递给前一个处理程序 col 来处理其参数 r。这意味着 r 被转换为 (cons x r)，但不是作为值返回，而是被送入 col 以进行进一步处理。因此，我们通过将新值 (cons x r) 传递给之前的“收集器”来“返回”它。

示例调用，作为说明:

(identity (list 1 2 3) display)     

= (identity (list 2 3) k1)
      ; k1 =  (lambda (r1) (display (cons 1 r1)))           =  display ° {cons 1}

= (identity (list 3)  k2)
      ; k2 =  (lambda (r2) (k1 (cons 2 r2)))                     =  k1 ° {cons 2} 

= (identity (list )  k3)
      ; k3 =  (lambda (r3) (k2 (cons 3 r3)))                     =  k2 ° {cons 3} 

= (k3 '())                        ; (((display ° {cons 1}) ° {cons 2}) ° {cons 3}) []

= (k2 (cons 3 '()))                    ; ((display ° {cons 1}) ° {cons 2}) [3]

= (k1 (cons 2 (list 3)))                    ; (display ° {cons 1}) [2,3]

= (display (cons 1 (list 2 3)))                  ; display [1,2,3]

= (display (list 1 2 3))

---

更新:在我最近喜欢使用的模式匹配伪代码中，我们可以编写

identity []        col  =  col []
identity [a, ...d] col  =  identity d ( newl =>  col [a, ...newl] )

和

reverse  []        col  =  col []
reverse  [a, ...d] col  =  reverse  d ( newl =>  col [...newl, a] )

希望它在视觉上非常明显，几乎不需要解释!