[Little Schemer Ch3 pp.34 & 37]：为什么 (rember a (cdr lat)) 作为 cons 的第二个参数在 p.37 示例中解释为未知

Question

我使用 DrRacket 调试模式逐步在 p.34 和 p.37 上运行这两个示例。以下是两个示例第一次处理(cdr lat) 时的堆栈窗口结果。

p.34，没有cons的失败示例

(define rember
  (lambda (a lat)
    (cond
      ((null? lat) '())
      (else (cond
              ((eq? a (car lat)) (cdr lat))
              (else (rember a (cdr lat)))
              )))))

(rember 'c '(a b c d))

调试器中的堆栈区域：

(cdr ...)
（记住……）

p.37 最后一行带有cons：

(define rember
  (lambda (a lat)
    (cond
      ((null? lat) '())
      (else (cond
              ((eq? a (car lat)) (cdr lat))
              (else (cons (car lat)
                          (rember a (cdr lat)))))))))

(rember 'c '(a b c d))

调试器中的堆栈区域：

(cdr ...)
（记住……）
（记住……）

带有p.37代码的Stack区域表示rember的第二次调用在处理(cdr lat)之前已经被归类为unknown。

2 个示例的唯一区别是第 37 页添加了“cons”。 Cons 接受 2 个参数，一个 s 表达式和一个列表。

没有(cdr lat)，rember 本身不会返回列表。并且本书前 40 页中所有包含(cdr lat) 的示例都具有相同的(function (cdr variable) 格式。

我不明白为什么 p.37 示例 rember 本身被标识为 unknown 并有理由等待减少，而包含的 (cdr lat) 可以被处理。

或者为什么 rember 在 cons 的第二个参数的位置被这样解释。

谢谢！

Answer 1

TL;DR：您看到（和误解）的是函数调用堆栈，以及尾递归的效果。

---

回答您关于调试器的具体问题：您的解释是错误的。您所看到的是函数调用的运行时堆栈，这些调用将您带到执行时间线中您现在所处的特定点。

它不是“未知”，不是“以后会减少”的东西。您已经通过它，到达您当前的执行点。它是什么，正在等待嵌套调用的结果，以继续处理 结果。

如果您再点击 Step 几次（使用 p.37 代码），您将进入更深的点，您会看到更多 @ 987654329@s 出现在堆栈区域。您当前的执行点出现在 堆栈 的最顶端；最早的——最底层的。

请注意，变量区域显示了该特定调用框架的变量值。

如果您移动鼠标光标并将鼠标悬停在较低的 (rember) 上并单击它，您将看到 其 变量的值：

Racket 的调试器有点习惯了。

还要注意左上角中以非常小的字母显示的“最后评估值”字段（在上图中）。这是调试时非常重要且有用的信息。它可以在屏幕上显示得一点。

您没有看到(rember)s 的堆栈随着第一个代码（p.34）而增长的原因，

是tail recursive。对rember 的深层嵌套调用的结果没有什么可做的，只是将其返回更远；所以没有必要为此保存任何状态。这意味着rember 的调用框架会被重用、替换，这就是为什么您只能在堆栈的底部看到其中一个。

但是对于 p.37 的代码，需要对返回值进行更多处理 - 前面的列表元素必须 consed 到结果中。这意味着必须保留列表元素，并在某处记住它。某处是rember 的调用框架，其中列表元素作为(car lat) 访问，对于that 值lat，在执行时间线中的that 点。

同样，对于具有(else (function (cdr ... 模式的所有其他函数，这意味着它们也是尾递归。但是，如果您看到类似(else (cons ... (function (cdr ... 的内容，那么它们不是。 cons 在路上。

---

为了更好地了解发生了什么，我们将其重写为等式模式匹配伪代码：

(rember34 a lat) =
    { (null? lat)        ->  '() 
    ; (eq? a (car lat))  ->  (cdr lat)
    ; else               ->  (rember a (cdr lat))
    }

这进一步简化为三个子句，

rember34 a []          =  []
rember34 a [a, ...as]  =  as
rember34 a [b, ...as]  =  rember a as

在没有明确解释的情况下，这个伪代码在视觉上是否足够容易理解？我希望是的。另一个定义是

rember37 a []          =  [] 
rember37 a [a, ...as]  =  as
rember37 a [b, ...as]  =  [b, ...rember a as]

现在只需查看这些定义，我们就可以看出区别以及每个定义的作用。

第一个 rember34 沿着列表（这是它的第二个参数）^{(3rd clause)} 直到在其中找到 a（它的第一个参数），如果它执行 ^{(2nd clause)}，它会返回列表的其余部分此时。如果没有找到a (3rd clause) 并且我们已经到达列表的末尾^{(1st clause) sup> 以使要继续的列表现在为空 ([])，将返回空列表 [](1st clause)。}

有道理。例如，

rember34 3 [1,2,3,4,5]              %   Tail-Recursive Call:
 = rember34 3 [2,3,4,5]             %    Just Returning The Result...
 = rember34 3 [3,4,5]               %     Call Frame Is Reused.
 = [4,5]

rember34 3 [1,2] 
 = rember34 3 [2]
 = rember34 3 []
 = []

第二个，rember37，做同样的事情，但有一个关键的区别：它将每个不匹配的元素保留在它找到并删除的元素之前（和以前一样）。这意味着如果没有找到这样的元素，将重新创建相同的列表。例如，

rember37 3 [1,2,3,4,5] 
 = [1, ...rember37 3 [2,3,4,5]]              % the->
       => [2, ...rember37 3 [3,4,5]]         %     stack->
              <= [4,5]                       %           grows
       <= [2,4,5]                            %      <-and
 = [1,2,4,5]                                 %  <-contracts

rember37 3 [1,2] 
 = [1, ...rember37 3 [2]]                    % must remember 1,
       => [2, ...rember37 3 []]              %     and 2, to be used
              <= []                          %          after the recursive call
       <= [2]                                %      has returned its result
 = [1,2]                                     %  to its caller

希望这可以澄清事情。

---

旁注：在尾递归modulo cons 优化下，它会是

rember37 3 [1,2,3,4,5] 
 = [1, ...rember37 3 [2,3,4,5]]
 = [1, ...[2, ...rember37 3 [3,4,5]]]
 = [1,2, ...rember37 3 [3,4,5]]
 = [1,2, ...[4,5]]
 = [1,2,4,5]

rember37 3 [1,2] 
 = [1, ...rember37 3 [2]]
 = [1, ...[2, ...rember37 3 []]]
 = [1,2, ...rember37 3 []]
 = [1,2, ...[]]
 = [1,2]

这很像它也会处于惰性评估之下！

Answer 2

让我强烈建议您在这里使用步进器，而不是调试器。我想你会看到一套更一致的缩减规则。具体来说，我认为您不会看到任何“被确定为未知”的内容。

要使用步进器：打开一个新缓冲区，确保语言级别设置为带有列表缩写的初学者，然后将定义和调用粘贴到定义窗口中。点击“步骤”。我想你会很快看到这两种评估之间的差异。

如果有什么不明白的地方请追问！