Scheme 列表：pair、递归数据与代码即数据

0. 本讲导读

上一讲把 Scheme 这门语言的骨架搭起来了：原子（atom）、调用表达式（call expression）、define、if、cond、let、lambda。你已经能写出 (define (square x) (* x x)) 这样的过程，也能用递归算阶乘。但到目前为止，你的 Scheme 程序里只能出现一个一个孤立的数。

这就卡住了。Python 里你随手就写 [1, 2, 3]，可 Scheme 的语法里根本没有方括号这种东西。那 Scheme 怎么装一串数据？

答案会让你有点意外：Scheme 只提供了一种复合数据的构造方式——把两个值粘成一对（pair）。就这么一个只有两格的盒子，什么长度可变的数组、什么嵌套结构，全都要从它推出来。

如果你学过第 8 讲的 Link 类，这个套路你其实见过：Link 也只有 first 和 rest 两个字段，靠 rest 指向下一个 Link，把一串东西串起来。Scheme 的 pair 就是 Link，car 就是 first，cdr 就是 rest，nil 就是 Link.empty。区别只在于：在 Python 里 Link 是你自己写的一个类，在 Scheme 里 pair 是语言内置的、也是唯一的复合结构。

本讲分三块：

• 造和拆：cons 造 pair，car / cdr 拆 pair，list 一次造一串；length / null? / pair? / list? 问问题；append 把几个列表接起来。
• 批量处理：map / filter / reduce——这三个是第 3 讲高阶函数在 Scheme 里的正统形态，写起来比 Python 的 for 循环更贴近「你想要什么」而不是「怎么一步步拿到」。
• 代码即数据：quote 把一段本该被求值的表达式原封不动地变成一个列表，eval 再把列表变回可求值的表达式。这一对是下一讲写 Scheme 解释器的地基——解释器读进来的程序，在它自己眼里就是一个嵌套列表。

最后用两道真·课堂练习收尾：reverse（反转列表，练纯递归）和 mountain（判断是否「先严格递增后严格递减」，练带状态的辅助递归）。这两题的起始代码就是课程网站 Lecture 19 下的 19.scm。

1. 复习：/ 与 quotient 到底差在哪

正式进入列表之前，先把上一讲留下的一个坑填了。Scheme 里有两个「除法」，它们不是同义词。

/：真除法，而且参数个数可变

(/ <dividend> [divisor] ...) 收 一个或多个参数，规则分两种：

• 只给一个参数时，结果是 1 除以它（取倒数）。
• 给多个参数时，从左往右连续除。

scm> (/ 5)
0.2
scm> (/ 100 2 5)
10

(/ 100 2 5) 的过程是 100 ÷ 2 = 50，再 50 ÷ 5 = 10。它不是「100 除以 (2÷5)」，也不是「100 除以 2 再除以 5 的某种奇怪组合」——就是老老实实从左到右。

/ 做的是真除法（true division），也就是 Python 里 / 的那种除法，不砍小数。但有一个 Scheme 特有的、很容易踩的规则：结果只在「实在没办法」时才是浮点数。

scm> (/ 7 2)
3.5
scm> (/ 6 2)
3
scm> (/ 6.0 2.0)
3

注意第三行。在 Python 里 6.0 / 2.0 得到 3.0，是个浮点数；Scheme 却给你一个整数 3。Scheme 的数值塔（numerical tower）认为「精确的整数」比「浮点数」更好，只要结果能被整数精确表示，它就退回整数。(/ 7 2) 没法用整数表示，才不得不给 3.5。

quotient：整除，恰好两个参数

(quotient <dividend> <divisor>) 收 恰好两个参数，做的是整除（丢掉小数部分），对应 Python 的 //：

scm> (quotient 7 2)
3
scm> (quotient 7 2 1)
Error: incorrect number of arguments: #[quotient]

它的返回类型跟着参数走：两个参数都是整数时返回整数，否则返回浮点数。

scm> (quotient 7.0 2)
3.0

看清楚：3.0，末尾带小数点。这跟 / 的「能整就整」正好相反——quotient 不做类型退化。

return -(-val0 // val1) if (val0 < 0) ^ (val1 < 0) else val0 // val1

2. pair：Scheme 唯一的复合数据构造器

先说清楚问题在哪。到上一讲为止，Scheme 里能出现的值只有：数、布尔值、字符串、符号、过程。这些都是原子（atom）——不可再分的单个值。你没法表达「三个数放在一起」。

Python 给了你 list、tuple、dict 一堆内置容器。Scheme 走的是另一条路：只给一个最小的构造器，剩下的靠组合。

这个最小构造器叫 pair（对）：一个只有两格的盒子，两格分别叫 car 和 cdr。

三个基本操作

car 和 cdr 这两个名字毫无意义可言，纯属历史遗留。1958 年最早的 LISP 跑在 IBM 704 上，那台机器的指令字被切成四个子字段，其中「address」和「decrement」两个 15 位字段正好用来存一个 list cell 的两个指针。取这两个字段的机器指令分别叫 Contents of Address field to Register 和 Contents of Decrement field to Register——首字母缩写就是 CAR 和 CDR。一个硬件实现细节，就这么变成了半个世纪后你还得背的函数名。

cons 必须收恰好两个参数

scm> (cons 1)
Error: incorrect number of arguments: #[cons]
scm> (cons 1 nil)
(1)

第一行是真实的报错信息（在 61A 的 scheme.py 里实测）。为什么不能只给一个？因为 pair 有两格，你不给第二格的值，那一格里该放什么？语言不替你猜。想造一个只有一个元素的列表，必须显式写出 nil 作为 cdr：(cons 1 nil)。

注意输出：(cons 1 nil) 显示成 (1)，不显示成 (1 . ())。Scheme 的打印器发现「cdr 是 nil」时会把它省掉，这是一个显示上的约定，不是说 nil 消失了。

嵌套 cons 造出多元素列表

scm> (cons 1 (cons 2 (cons 3 nil)))
(1 2 3)

这行是理解整讲的关键，把它一层层拆开看：

画成盒指针图（box-and-pointer diagram）：

   P1                P2                P3
 ┌────┬────┐      ┌────┬────┐      ┌────┬────┐
 │ 1  │  ●─┼─────>│ 2  │  ●─┼─────>│ 3  │nil │
 └────┴────┘      └────┴────┘      └────┴────┘
  car  cdr         car  cdr         car  cdr

 打印为：( 1    2    3 )
          ↑    ↑    ↑
        P1.car P2.car P3.car

三个 pair 串成一条链，每个 pair 的 cdr 指向下一个，最后一个的 cdr 是 nil 收尾。打印时 Scheme 沿着这条链一路走，把每个 car 依次打出来，走到 nil 停——所以你看到的是扁平的 (1 2 3)，看不出里面有三个盒子。

list：一次造完

天天写 (cons 1 (cons 2 (cons 3 nil))) 太累了，Scheme 给了个便捷函数：

scm> (list 1 2 3)
(1 2 3)

(list 1 2 3) 和 (cons 1 (cons 2 (cons 3 nil))) 造出来的东西一模一样——同样的三个 pair，同样的链式结构。list 只是替你把 cons 嵌套写好了。

list 是普通过程，不是特殊形式，所以它的参数照常求值：

scm> (list (+ 1 1) (* 2 3))
(2 6)

记住这一点，第 7 节讲 quote 时会拿它做对比——'((+ 1 1) (* 2 3)) 的结果完全不同。

car 那一格可以放另一个 pair

规格里说「第一个值可以是任何数据类型」，那当然也包括 pair 本身。这就是嵌套列表的来源：

scm> (cons (cons 1 nil) (cons 2 nil))
((1) 2)

这个输出第一次见会懵。拆开：

 ┌────┬────┐      ┌────┬────┐
 │ ●  │  ●─┼─────>│ 2  │nil │
 └─┼──┴────┘      └────┴────┘
   │
   v
 ┌────┬────┐
 │ 1  │nil │
 └────┴────┘

 打印为：((1) 2)   ← 这个列表的长度是 2，不是 3

scm> (length '(1 (2 3)))
2

3. 从 pair 到 list：一个递归定义，和它带来的写法模板

上一节反复出现「列表」这个词，但还没给定义。现在给：

这是一个递归定义（recursive definition）：定义列表的时候用到了「列表」这个词本身。它没有循环论证，因为有一个不含「列表」的出口——nil。

用它来判断 (cons 1 (cons 2 (cons 3 nil))) 是不是列表：

违反约束会怎样：improper list

如果你把一个非列表塞进 cdr 呢？语言不会拦你：

scm> (cons 1 2)
(1 . 2)
scm> (pair? (cons 1 2))
#t
scm> (list? (cons 1 2))
#f

(cons 1 2) 是一个合法的 pair——两格都填了。但它不是列表，因为 cdr 是数字 2，2 既不是 nil 也不是 pair。

Scheme 打印这种东西时会用点号写法（dotted pair notation）：(1 . 2)。看到输出里有个孤零零的点，就说明这条链没有以 nil 收尾。 这是一个极有用的调试信号——你写列表递归时如果看到 (3 2 . 1) 这种输出，几乎可以断定某处 base case 返回了不是 nil 的东西，或者 cons 的两个参数写反了。

(cons 1 (cons 2 nil))        (cons 1 2)
 ┌────┬────┐  ┌────┬────┐     ┌────┬────┐
 │ 1  │  ●─┼─>│ 2  │nil │     │ 1  │ 2  │
 └────┴────┘  └────┴────┘     └────┴────┘
 打印 (1 2)      ← 是 list     打印 (1 . 2)  ← 不是 list
 (list? …) → #t                (list? …) → #f

为什么这个定义值钱：它就是写代码的模板

递归定义最实用的地方在于：数据长什么样，处理它的函数就长什么样。 定义分两种情况，你的函数就写两个分支：

(define (f lst)
  (if (null? lst)
      <lst 是 nil 时的答案>          ; base case
      <用 (car lst) 和 (f (cdr lst)) 拼出答案>))  ; recursive case

这不是「一个技巧」，而是唯一自然的写法。因为你手上只有两个操作：car 拿到第一个元素，cdr 拿到剩下的（而剩下的还是一个列表，所以可以递归处理）。第 10 节的 reverse 就是照这个模板填空填出来的。

访问深处的元素：car / cdr 串起来用

Scheme 没有 lst[2] 这种下标语法。想拿第 3 个元素，只能一格一格走过去。看幻灯片上的实录：

逐行解释这张图：

(define a (cons 1 (cons 2 (cons 3 nil))))
(define b (cons (cons 1 nil) (cons 2 nil)))

把 (car (cdr (cdr a))) 完整推一遍：

scm> (cadr (list 1 2 3))
Error: unknown identifier: cadr

scm> (car nil)
Error: argument 0 of car has wrong type (tuple)
scm> (cdr 5)
Error: argument 0 of cdr has wrong type (int)

4. 问问题：length、null?、pair?、list?

造完了、拆完了，还得能问：这东西多长？它空了吗？它到底是不是个列表？

length

scm> (length (list 1 2 3))
3
scm> (length nil)
0
scm> (length ())
0
scm> (length (cons (cons 1 nil) (cons 2 nil)))
2

前三行没有悬念。第四行再次强调上一节那个点：(cons (cons 1 nil) (cons 2 nil)) 打印出来是 ((1) 2)，长度是 2——length 只数最外层有几个元素，不管元素本身是不是列表、里面又有几个东西。

顺带一提：nil 和 () 在 61A Scheme 里是同一个东西的两种写法，都表示空列表。

scm> (length (cons 1 2))
Error: argument 0 of length has wrong type (Link)

三个谓词：list?、pair?、null?

这三个特别容易混。先看实录：

scm> (list? nil)
#t
scm> (list? (cons 1 nil))
#t
scm> (pair? nil)
#f
scm> (pair? (cons 1 nil))
#t
scm> (null? nil)
#t
scm> (null? (cons 1 nil))
#f

关键在第三行：(pair? nil) 是 #f，但 (list? nil) 是 #t。

这不是语言在为难你，而是第 3 节那个定义的直接推论。nil 是列表（定义的第一条），但它不是 pair——它没有两格，它什么都没有。

横着读这张表最能看出区别：(cons 1 2) 这一列上 pair? 是 #t 而 list? 是 #f；nil 这一列上正好反过来。 这两个谓词各自漏掉的那个格子，恰好说明了它们问的不是同一件事。

(if (null? lst) <空的情况> <非空的情况>)

5. append：接的是元素，不是列表

现在你能造列表、能拆列表，但还不能把两个列表接起来。用 cons 硬接是不行的——(cons (list 1 2) (list 3 4)) 只会把整个 (1 2) 塞进 car，得到 ((1 2) 3 4)，长度变成 3 而不是 4。

append 就是干这个的：

scm> (append)
()
scm> (append (list 1 2 3) (list 4 5))
(1 2 3 4 5)
scm> (append (list 1 2) (list 3 4) (list 5 6))
(1 2 3 4 5 6)

第一行值得注意：(append) 一个参数都不给，返回空列表。这在写递归时偶尔有用，但更重要的是它反映了 append 的心智模型——「把所有参数里的元素倒进一个新篮子」，没有参数就是空篮子。

为什么必须强调「像 extend 不像 append」

Python 的两个方法对比一下就清楚了：

还有一个区别没写在表上但同样重要：Python 的 append / extend 是就地修改（mutate），原来那个 a 被改了，返回值是 None；Scheme 的 append 不改任何东西，它返回一个新列表，原参数原封不动。本讲所有操作（cons / append / map / filter）都是这样——纯函数，无副作用。

想把一个列表当元素接进去怎么办

包一层：

scm> (append (list 1 2) (list (list 3 4)))
(1 2 (3 4))

外层的 (list …) 造了一个「只含一个元素、而这个元素是列表 (3 4)」的列表，append 把这唯一的元素接上去，于是 (3 4) 作为整体成了结果的第 3 个元素。这个技巧在下一节和 reverse 里都会用到。

scm> (append (list 1 2) 3)
(1 2 . 3)
scm> (append 3 (list 1 2))
Error: argument 0 of append has wrong type (int)

6. map / filter / reduce：三种批量处理

有了列表，最常做的三件事是：把每个元素都变一下、挑出满足条件的元素、把所有元素合成一个值。Scheme 分别给了 map、filter、reduce。

它们都是高阶函数（higher-order function）——第 3 讲讲过的那个概念，参数是函数。在 Scheme 里这套写法比在 Python 里更常见，因为 Scheme 根本没有 for 循环，也没有可变列表，你想「遍历」就只能靠递归或这三个函数。

map：每个元素都过一遍

(map <proc> <lst>)——把单参数过程 proc 作用到 lst 的每个元素上，返回结果组成的新列表。

scm> (map (lambda (x) (* x x)) (list 1 2 3))
(1 4 9)

输出列表的长度必然等于输入列表的长度。 map 不会多一个也不会少一个，它只做「逐位替换」。空列表进去就是空列表出来：

scm> (map (lambda (x) (* x 2)) nil)
()

传进去的过程也可以是内置的：

scm> (map car '((1 2) (3 4)))
(1 3)

这行是「取出每个子列表的第一个元素」。注意 car 在这里不带括号——写 car 是把这个过程当值传进去，写 (car …) 才是调用它。这个区别跟 Python 里 f 和 f() 的区别是同一回事。

filter：挑出合格的

(filter <pred> <lst>)——保留 lst 中让谓词（predicate） pred 返回真的元素，顺序不变。

scm> (filter even? (list 1 2 3 4 5))
(2 4)
scm> (filter (lambda (x) x) (list 1 "hi" nil 0 #t #f))
(1 "hi" #t)

第二行需要解释。(lambda (x) x) 是恒等函数，它把元素原样交回去当判断依据，所以这一行实际测的是「Scheme 认为哪些值是真的」。结果留下了 1、"hi"、#t，滤掉了 nil、0、#f。

filter 和 map 的根本区别：map 改元素、不改数量；filter 改数量、不改元素。 输出列表的长度在 0 到原长之间。

reduce：把一串合成一个

(reduce <combiner> <lst>)——用双参数过程 combiner 从左往右依次合并 lst 的元素。

scm> (reduce + (list 1 2 3 4))
10
scm> (reduce + (list 1))
1

「从左往右」这句话很关键，它决定了两个参数谁是谁：已经攒下来的结果作第一个参数，新元素作第二个参数。 展开 (reduce + (list 1 2 3 4))：

对 + 这种既满足交换律又满足结合律的运算，顺序无所谓。换个不对称的 combiner，顺序就一眼可见了：

scm> (reduce cons (list 1 2 3))
((1 . 2) . 3)

这是 (cons (cons 1 2) 3)——括号层层往左嵌，说明合并确实是从左边开始的。如果是从右往左，结果会是 (1 2 . 3)（即 (cons 1 (cons 2 3))）。

scm> (reduce + nil)
Error: argument 1 of reduce has wrong type (tuple)

7. quote：把代码变成数据

到这里为止，列表都是「装数据的容器」。这一节要讲的东西会让你重新看待整门语言。

先注意一个你可能一直没细想的事实：Scheme 的代码本身就长得像列表。 (+ 1 2) 是一对括号包着三个东西。(1 2 3) 也是一对括号包着三个东西。它们在字面上没有任何区别。

区别只在于解释器拿它干什么：看到 (+ 1 2)，它会求值算子 +、求值算子数 1 和 2、然后调用。如果你不想让它这么干，只想要「那三个东西本身」，就用 quote。

quote 是特殊形式

(quote <expression>)，或者简写 '<expression>——返回这个表达式本身，不求值。

scm> (quote (1 2 3))
(1 2 3)
scm> '(1 2 3)
(1 2 3)
scm> (list? '(1 2 3))
#t

为什么必须是特殊形式（special form）而不能是普通过程？因为普通过程的算子数一定会先被求值。如果 quote 是普通过程，写 (quote (1 2 3)) 时解释器会先去求值 (1 2 3)——把 1 当成算子去调用——直接报错。特殊形式的意义就在于它可以决定自己的子表达式要不要求值，跟 if 只求值一个分支是同一类机制。

scm> (list (+ 1 1) (* 2 3))
(2 6)
scm> '((+ 1 1) (* 2 3))
((+ 1 1) (* 2 3))
scm> (car '((+ 1 1)))
(+ 1 1)

符号（symbol）

quote 也能用在单个名字上，这时得到的是符号（symbol）：

scm> 'a
a
scm> (symbol? 'a)
#t

不加引号的 a 是「去环境里查名字 a 绑定的值」，查不到就报 Error: unknown identifier: a。加了引号的 'a 是「符号 a 这个值本身」，跟环境里有没有 a 完全无关。

符号在 Scheme 里的地位大致相当于 Python 里「不可变、可快速比较的字符串常量」。第 11 节的 mountain 就用 'start、'increase、'decrease 三个符号当状态标记——用符号而不是字符串，是因为 eq? 比较符号是可靠且高效的（见第 9 节）。

quasiquote 和 unquote：挖个洞

quote 是「全都不求值」，太绝对了。有时你想要一个基本固定、但某几个位置需要填入计算结果的模板。这就是准引用（quasiquote）：

(quasiquote <expression>)，简写反引号 `<expression>——整体不求值，除非某个子表达式写成 (unquote <expr2>) 或简写 ,<expr2>，那个子表达式会被正常求值，结果填回原位。

scm> (define a (list 4 5 6))
a
scm> (quasiquote (1 2 3 ,a))
(1 2 3 (4 5 6))
scm> `(1 2 3 ,a)
(1 2 3 (4 5 6))

（顺带一提：define 这个特殊形式本身会返回被定义的符号，所以第一行的输出是 a。）

逗号后面可以是任意表达式，不限于名字：

scm> `(1 2 ,(+ 1 2))
(1 2 3)

scm> (define a (list 4 5 6))
a
scm> '(1 2 ,a)
(1 2 (unquote a))

8. apply 与 eval：把列表当参数表、把列表当程序

quote 让代码变成数据。这一节的两个函数走反方向：让数据变回代码。

apply：列表里装的是参数

(apply <procedure> <args>)——用 args 这个列表里的元素作为参数去调用 procedure。

scm> (apply + (list 1 2 3))
6
scm> (apply + '(1 2 3))
6

关键在于对比：

如果你写过 Python，这就是 f(*args) 那个星号解包。为什么需要它？因为参数个数在写代码的时候可能还不知道——你手上有一个运行时才算出来的列表，想把它当参数表用，只能靠 apply。

幻灯片上写着「More on this when we talk about macros!」——apply 真正的用武之地在宏和元编程，本讲先建立概念。

eval：列表里装的是程序

(eval <expression>)——把 expression 在当前环境里求值。

scm> (eval '(cons 1 (cons 2 nil)))
(1 2)

这一行是本讲最值得琢磨的一行。慢慢拆：

光看这一行你可能觉得「那不是白折腾吗」。它的价值在于：中间那一步，程序是数据，你可以对它动手脚。

scm> (define expr '(+ 1 2))
expr
scm> expr
(+ 1 2)
scm> (car expr)
+
scm> (length expr)
3
scm> (eval expr)
3

expr 绑定的是一个普通列表，你可以对它 car、length、map，就像对 (1 2 3) 一样。想跑它的时候才 eval。

scm> (eval (cons 1 (cons 2 nil)))
Error: int is not callable: 1

9. 三种相等：=、eq?、equal?

Python 里判断相等有 == 和 is 两个；Scheme 有三个，而且分工跟 Python 不完全对应。

=：只管数

scm> (= 5 5)
#t
scm> (= "hi" "bye")
Error: operand 0 ("hi") is not a number

= 收恰好两个数。传非数进去不是返回 #f，是直接报错。这跟 Python 的 == 很不一样——Python 里 5 == "hi" 老老实实给你 False。

这个设计其实更诚实：「5 和 "hi" 谁大」是个没有意义的问题，与其编一个答案，不如告诉你问错了。

eq?：身份（大部分时候）

eq? 收任意两个值，规则分两层：

• 对数、布尔值、符号：比较它们是否等价（相同的值）。
• 对其他一切（列表、字符串、过程……）：比较它们是否指向内存中的同一个对象，也就是身份（identity）。

(define a (list 1 2 3))
(define b (list 1 2 3))
scm> (eq? a b)
#f
scm> (eq? "hi" "bye")
#f
scm> (eq? 5 5)
#t

(eq? a b) 为什么是 #f？因为 (list 1 2 3) 被调用了两次，每次都新造了三个 pair。a 和 b 指向两条不同的链，虽然链上装的数一模一样。

Global frame
  a ──┐
  b ──┼──┐
      │  │
      v  │   ┌────┬────┐   ┌────┬────┐   ┌────┬────┐
      └─>│ 1  │  ●─┼──>│ 2  │  ●─┼──>│ 3  │nil │   ← a 的链
         └────┴────┘   └────┴────┘   └────┴────┘

         ┌────┬────┐   ┌────┬────┐   ┌────┬────┐
      ──>│ 1  │  ●─┼──>│ 2  │  ●─┼──>│ 3  │nil │   ← b 的链（另外六格）
         └────┴────┘   └────┴────┘   └────┴────┘

(eq?    a b) → #f   两条链是不同的对象
(equal? a b) → #t   逐格比下去，处处相同

验证一下「同一个对象」的情形：

scm> (eq? a a)
#t
scm> (eq? 'x 'x)
#t

(eq? 'x 'x) 是 #t——这正是符号规则的用处，也是第 11 节的 mountain 敢用 (eq? state 'increase) 来判断状态的原因。要是符号也按身份比较，这段代码就不可靠了。

equal?：结构

equal? 递归地比较：两个列表相等，当且仅当它们的 car 相等且 cdr 相等。

(define a (list 1 2 3))
(define b (list 1 2 3))
scm> (equal? a b)
#t
scm> (equal? "hi" "bye")
#f
scm> (equal? 5 5)
#t
scm> (equal? '(1 (2 3)) (list 1 (list 2 3)))
#t

最后一行说明它是真的钻进去比的：第二个元素本身是列表，也被逐格比较了一遍。

10. 实战一：reverse

课堂练习的起始代码在 19.scm：

; Define a procedure reverse which takes in a Scheme list
; and returns a new list which is the reversed version of the original
(define (reverse lst)
    ; YOUR CODE HERE
)

(expect (reverse nil) ())
(expect (reverse (list 1)) (1))
(expect (reverse (list 1 2 3)) (3 2 1))
(expect (reverse (list 1 2 3 2 1)) (1 2 3 2 1))

（expect 是 code.cs61a.org 那个在线编辑器提供的测试形式，把代码贴进去点右上角红色试管按钮就能跑。它不是标准 Scheme，在本地 scheme.py 里跑会报 Error: unknown identifier: expect。）

题目到底要什么

四条测试把边界都框住了：

还有一个隐含要求：「returns a new list」——不能改原列表。在 Scheme 里这不是问题，你手上根本没有修改 pair 的工具。

怎么想到的

先套第 3 节那个模板。列表的定义分两种情况，函数就写两个分支：

(define (reverse lst)
  (if (null? lst)
      ???          ; lst 是空的
      ???))        ; lst 非空

空列表反转还是空列表，第一个洞填 nil。

第二个洞难一点。手上有两样东西：(car lst)——第一个元素；(cdr lst)——剩下的列表。递归的信念是：假设 (reverse (cdr lst)) 已经正确地返回了「剩下部分的反转」，我该怎么用它拼出整个的反转？

拿 (1 2 3) 具体想：

• (car lst) 是 1
• (cdr lst) 是 (2 3)，它的反转是 (3 2)
• 我要的答案是 (3 2 1)

看出来了：把 1 接到 (3 2) 的末尾。 原来的第一个元素，在反转后必须变成最后一个。

接下来是全题唯一的坑：怎么把一个元素接到列表末尾？

第一反应可能是 cons——但 cons 只能接到开头，(cons 1 '(3 2)) 给的是 (1 3 2)，方向反了。

那用 append？(append '(3 2) 1)？也不行，append 要求参数是列表，1 是个元素。

正确写法是先把这个元素包成一个单元素列表：(list (car lst))，再 append。这正是第 5 节结尾提到的那个技巧。

代码

(define (reverse lst)
    (if
        (null? lst)
        nil
        (append
            (reverse (cdr lst))
            (list (car lst))
        )
    )
)

逐行看为什么是这样：

• (null? lst) —— base case 判空用 null?（不是 pair?，也不是 list?，理由见第 4 节）。它必须先判，因为下面要 car，而对 nil 取 car 会报错。
• nil —— 空列表的反转。写 '() 也一样。不能写 0 或者什么都不写，那样上层的 append 会收到非列表参数。
• (reverse (cdr lst)) —— 递归调用，处理短一格的列表。参数必须比原来短，否则永远到不了 base case。
• (list (car lst)) —— 把首元素包成长度为 1 的列表，这样 append 才肯接它。
• 两者的顺序不能反：反转结果在前、首元素在后。写成 (append (list (car lst)) (reverse (cdr lst))) 会得到「首元素 + 剩下部分的反转」，比如 (1 3 2)——完全不是反转。

验证：把 (reverse '(1 2 3)) 真的展开

盯着第 5–7 步看：每一层都往右边贴一个元素，而下降时是从左往右剥元素的。「先剥的后贴」——这个「后进先出」正是反转的本质，也是递归天然带来的效果。

scm> (badrev (list 1 2 3))
(((() . 3) . 2) . 1)

scm> (badrev2 (list 1 2 3))
Error: argument 0 of append has wrong type (int)

另一种写法：用累积器

上面那个解法有个隐忧：append 本身是 Θ(n) 的（它要走完第一个列表），而它被调用了 n 次，所以整个 reverse 是 Θ(n²)。

换个思路：cons 只能往头上加——而「反复往头上加」得到的恰好就是逆序。用一个累积器（accumulator）从左往右扫：

(define (reverse lst)
  (define (helper lst acc)
    (if (null? lst)
        acc
        (helper (cdr lst) (cons (car lst) acc))))
  (helper lst nil))

这个版本每步只做 Θ(1) 的 cons，总共 Θ(n)。而且它是尾递归——递归调用是函数体里最后做的事，返回后不需要再算什么。Scheme 标准要求实现对尾递归做优化，不会撑爆栈。

课堂给的参考答案是第一个版本（更直观，也更贴合「用列表定义写递归」的训练目标）。两个都对，知道差别在哪更重要。

11. 实战二：mountain——用符号当状态

第二道课堂练习难度上了一个台阶。题面（19.scm 里的注释）：

Define a function mountain that returns true if the given list containing only positive integers and with length >= 3 is a mountain. A mountain is defined as a list that contains a strictly increasing sublist and then a strictly decreasing sublist after its "peak" number. (Otherwise, return false.)

题目到底要什么

「山」= 先严格递增，到达一个峰值，然后严格递减。逐条测试翻译成人话：

把这六条压成三句约束：

1. 必须有上升段（不能一开始就降）。
2. 必须有下降段（不能一路升到底）。
3. 严格单调，相等即失败；而且升→降只能切换一次，降完不能再升。

怎么想到的

先试试上一题那个纯递归模板：(if (null? lst) … (用 (car lst) 和 (mountain (cdr lst)) 拼))。

卡住了。为什么？因为「(2 1) 是不是山」这个问题的答案，帮不了「(1 2 3 2 1) 是不是山」。子问题的答案（#f，因为 (2 1) 没有上升段）跟原问题的答案（#t）没有可用的关系。这个函数不是「结构递归」能直接拿下的。

症结在于：判断当前这一步合不合法，需要知道两件递归本身不提供的信息——

• 前一个数是多少（不然没法比较大小）
• 现在是在上山还是在下山（同一个「变小了」，在上山阶段意味着「到峰了，开始下山」，在下山阶段意味着「继续下山」，含义完全不同）

所以需要一个带额外参数的辅助函数——起始代码已经把这个思路给你了：

(define (helper lst prev state) …)

state 取三个符号之一：'start（还没开始爬，一个数都没比过）、'increase（正在上山）、'decrease（正在下山）。这就是一台状态机（state machine）：每读一个数，根据「这个数和 prev 的大小关系」+「当前 state」决定下一个 state，或者当场判死。

状态转移表

三个 state 乘以三种大小关系（n > prev / n < prev / n = prev），一共九格。把每一格填掉，代码就写完了：

列表走完时（(null? lst)）怎么判？答案是 (eq? state 'decrease)：

• 停在 'decrease —— 上过山也下过山，是山 ✓
• 停在 'increase —— 只上没下，比如 (1 2 3)，不是山
• 停在 'start —— 一个数都没比过（列表太短），不是山

一句 (eq? state 'decrease) 就把「必须有下降段」这条约束优雅地表达了。

代码

(define (mountain lst)
    (define (helper lst prev state)
        (if
            (null? lst)
            ; Should only increase then decrease once
            (eq? state 'decrease)

            (begin
                (define n (car lst))
                (define rest (cdr lst))
                (cond
                    ; we just started and it's increasing, so keep going
                    ((and (> n prev) (eq? state 'start)) (helper rest n 'increase))

                    ; we just started but it's decreasing, so it's not a mountain
                    ((and (< n prev) (eq? state 'start)) #f)

                    ; it is currently increasing and we want it to increase
                    ((and (> n prev) (eq? state 'increase)) (helper rest n 'increase))

                    ; it is the start of the decrease (the peak of the mountain)
                    ((and (< n prev) (eq? state 'increase)) (helper rest n 'decrease))

                    ; it is currently increasing but we want it to decrease, so it's not a mountain
                    ((and (> n prev) (eq? state 'decrease)) #f)

                    ; it is currently decreasing and we want it to decrease
                    ((and (< n prev) (eq? state 'decrease)) (helper rest n 'decrease))

                    ; digits are equal, so it's not a mountain (we need strictly increasing/decreasing)
                    (else #f)
                )
            )
        )
    )

    (helper (cdr lst) (car lst) 'start)
)

几个值得停下来看的地方：

• 最后那行初始调用：(helper (cdr lst) (car lst) 'start)。第一个数没有「前一个数」可比，所以把它取出来当 prev，从第二个数开始扫。这是处理「需要相邻比较」类问题的标准起手式。
• begin：if 的每个分支只能是一个表达式。这里要先 define 两个局部名字再 cond，共三件事，必须用 begin 包成一个。begin 依次求值所有子表达式，返回最后一个的值——所以整个 begin 的值就是 cond 的值。
• (define n (car lst))：起个名字避免重复写 (car lst)。n 和 rest 绑定在 helper 这次调用的帧里，下次调用是另一帧、另一个 n，互不干扰。
• cond 从上往下试，第一个为真的子句生效，后面全跳过。九种情况里有六种被前六个子句显式列出，剩下三种「持平」情况全部落到 else，返回 #f。else 必须在最后，写在前面会把所有情况都吃掉。
• helper 是定义在 mountain 内部的。它能看到 mountain 帧里的东西，外面看不到它。这跟第 3 讲的嵌套函数、闭包是同一套作用域规则。

验证：(mountain '(1 2 3 2 1)) 逐帧追踪

再验两条反例

scm> (cond (#f 1))
              <-- 什么都没打印，返回的是一个「未定义值」
scm> (if (cond (#f 1)) 'truthy 'falsy)
truthy

scm> (mountain nil)
Error: argument 0 of cdr has wrong type (tuple)

本讲小结

函数速查表

四条最容易记混的规则

这一讲真正学到的思维方法

递归的数据定义，直接给出递归的代码结构。 「列表要么是 nil，要么是 cdr 还是列表的 pair」这句话有两个分句，你的函数就有两个分支：null? 那支处理 nil，else 那支用 (car lst) 和「(cdr lst) 的答案」拼出结果。reverse 是照这个模板填空填出来的。

纯结构递归搞不定时，往辅助函数里加参数。 mountain 卡住的原因是「子列表的答案帮不上原列表」。解法是造一个带 prev 和 state 的 helper——把递归本身不携带的上下文显式地作为参数传下去。这个模式（外层函数负责初始化，内层 helper 负责递归）在 61A 后半程会反复出现。

代码和数据的界限是人为的。 '(+ 1 2) 和 (1 2 3) 在 Scheme 眼里都是三元素列表，区别只在于你有没有把它交给 eval。下一讲要写的解释器，做的正是「接过一个嵌套列表，按规则把它变成一个值」——本讲的 car、cdr、quote、eval 就是那台机器的全部零件。

动手练习

练习 1：读盒指针

下面这个表达式求值成什么？它的 length 是多少？

(cons 1 (cons (cons 2 (cons (cons 3 nil) nil)) (cons 4 (cons 5 nil))))

练习 2：quote 的四种写法

设 (define x 10)。下面五行分别求值成什么？

(a) (list 'x x)
(b) '(list 'x x)
(c) `(a b ,x)
(d) (car ''x)
(e) (eval (list '+ 1 x))

练习 3：eq? 还是 equal?

下面每行输出什么？

(define a (list 1 2))
(define b (list 1 2))
(define c a)
scm> (eq? a b)
scm> (eq? a c)
scm> (equal? a b)
scm> (eq? (car a) (car b))
scm> (equal? (cdr a) (cdr b))

练习 4：写 my-append

不用内置的 append，用递归实现只收两个列表的 (my-append a b)。

(my-append '(1 2) '(3 4))   ; 应得 (1 2 3 4)
(my-append nil '(3 4))      ; 应得 (3 4)
(my-append '(1 2) nil)      ; 应得 (1 2)

(define (my-append a b)
  (if (null? a)
      b
      (cons (car a) (my-append (cdr a) b))))

练习 5：reduce 的顺序

不运行代码，说出这两行的结果，并解释为什么不同：

scm> (reduce (lambda (a b) (cons a b)) (list 1 2 3))
scm> (reduce (lambda (a b) (cons b a)) (list 1 2 3))

练习 6：状态机改造

把 mountain 改成 valley：判断列表是不是「先严格递减，再严格递增」。哪些地方要改？

(define (valley lst)
  (define (helper lst prev state)
    (if (null? lst)
        (eq? state 'increase)          ; 改点 3：结束时必须处在「正在上升」
        (begin
          (define n (car lst))
          (define rest (cdr lst))
          (cond
            ((and (< n prev) (eq? state 'start))    (helper rest n 'decrease))
            ((and (> n prev) (eq? state 'start))    #f)
            ((and (< n prev) (eq? state 'decrease)) (helper rest n 'decrease))
            ((and (> n prev) (eq? state 'decrease)) (helper rest n 'increase))
            ((and (< n prev) (eq? state 'increase)) #f)
            ((and (> n prev) (eq? state 'increase)) (helper rest n 'increase))
            (else #f)))))
  (helper (cdr lst) (car lst) 'start))