尾调用与宏：让递归不吃内存，让程序改写程序

0. 本讲导读

前面三讲铺了一条很长的路：Lecture 18 教你写 Scheme，Lecture 19 让你用 Scheme 做递归和列表处理，Lecture 20 则把 Scheme 解释器本身拆开来看——eval 和 apply 怎么互相调用、环境怎么串起来、动态作用域和词法作用域差在哪。到这里为止，你已经知道一个表达式被求值时到底发生了什么，而且是从解释器实现的层面知道的。

本讲拿这份知识去做两件之前做不了的事。

第一件：尾调用（tail call）。Lecture 18 讲过 Scheme 里没有 while、没有 for，一切循环都得写成递归。这带来一个很实际的恐惧：Python 里递归 1000 层就 RecursionError 了，Scheme 全靠递归，那它怎么写一个跑一百万次的循环？答案是：Scheme 保证某一类递归调用不占新的空间。这不是编译器的小聪明，而是语言标准里写死的一条要求。要用上它，你得能一眼看出自己写的调用属不属于这一类——这就是「尾上下文（tail context）」这套规则要解决的问题。

第二件：宏（macro）。到目前为止，你写的每一个 Scheme 过程都遵守同一条铁律：调用之前，所有算子数先被求值。可 if 不是这样——它只求值该走的那个分支。define 也不是这样——它不会去求值那个还没绑定的名字。这些「不守规矩」的东西叫特殊形式（special form），一直以来它们都是解释器内置的、你没法自己加的。define-macro 打破了这个限制：它让你写出自己的特殊形式，办法是拿到没被求值的源代码，把它当成数据加工一番，再把加工出来的新代码交回去求值。

两个主题看似无关，但都是同一个问题的两面：求值这件事本身，是可以被你操控的。尾调用操控的是「求值完一层之后，那一帧还留不留」；宏操控的是「这段代码到底什么时候、以什么形态被求值」。

先回顾：eval-apply 的调用顺序

Lecture 20 的 scheme_eval 处理一个调用表达式时，顺序是固定的：先求值算子，再从左到右求值每一个算子数，最后 apply。而每个算子数如果本身是调用表达式，就要先把它整个递归求值完。拿 (* 2 (+ 1 9) 4) 走一遍：

这个顺序本讲会一直用到。「算子数在调用之前就已经全部算完」正是尾调用能成立的技术前提——等会你会看到，尾递归写法之所以省空间，靠的就是「该算的都在参数里算完了，调用返回后没活可干」。

1. 函数式编程：先说清代价，才谈得上收益

Scheme 被拿来当教学语言，不只是因为括号多。它逼你用一种叫函数式编程（functional programming）的方式写代码。所谓「严格的」函数式编程，是三条约束：

• 只有纯函数（pure function），没有副作用（side effect）。函数唯一做的事就是根据参数算出返回值。不打印、不改全局变量、不写文件。
• 不重新赋值，不变异（no reassignment or mutation）。没有 x = x + 1，没有 lst.append(...)。数据一旦造出来就不再改动。
• 名值绑定是永久的（permanent name-value bindings）。一个名字绑定到某个值之后，在它的作用域里永远是那个值。

这三条听起来像是在自我束缚，实际上也确实是。先把代价摆在明面上：

没有迭代。while 循环的运转完全依赖「重新赋值」——n, k = n - 1, n * k 就是把 n 和 k 重新绑定到新值。禁止重新赋值，while 就没法工作，于是只剩递归。而在朴素的实现里，每次递归调用都要新建一帧，帧不能扔，空间就会随递归深度线性增长——这就是幻灯片里说的「space complexity explosion」。这个代价是致命的：一个本来 $\Theta(1)$ 空间的循环，写成递归就变成 $\Theta(n)$ 空间。

那为什么还要接受这套约束？因为它买回来两样非常硬的东西。

把这两条对照 Lecture 17 的记忆化 fib 想一想：那时候我们靠「fib 是纯函数」这个事实才敢缓存结果。函数式编程不过是把这条隐含假设升级成了语言级别的保证。

2. 递归与迭代：Python 的帧是怎么堆起来的

要理解「尾调用省了什么」，先得看清「不省的时候花了什么」。用一个稍微改造过的阶乘做实验：factorial(n, k) 计算的是 $k \cdot n!$。多出来的参数 k 现在看着莫名其妙，但它是整节课的钥匙。

# 递归版
def factorial(n, k):
    if n == 0:
        return k
    return factorial(n - 1, n * k)

# 迭代版
def factorial(n, k):
    while n > 0:
        n, k = n - 1, n * k
    return k

两个版本都返回 $k \cdot n!$。先确认它们真的一样：factorial(3, 1) 应该得到 $1 \times 3! = 6$。

递归版：帧一层层堆上去

按 Lecture 04 的规则一步步来。调用 factorial(3, 1)：

关键在第 5 步：f3 拿到 6 之后什么也没做，原封不动地把 6 往上传。f2、f1 也一样。这四帧里除了最深那帧，其余三帧在「等」的期间，唯一的作用就是把结果原样转交。

Global frame
    factorial  ──→ func factorial(n, k)

f1: factorial [parent=Global]     n=3  k=1   ← 正在算 return factorial(2, 3)，等
f2: factorial [parent=Global]     n=2  k=3   ← 正在算 return factorial(1, 6)，等
f3: factorial [parent=Global]     n=1  k=6   ← 正在算 return factorial(0, 6)，等
f4: factorial [parent=Global]     n=0  k=6   ← return k = 6

此刻同时有 4 个 active（未返回）的调用。
n = 1000000 时，就是 1000000 帧同时活着。

这四帧同时存在，所以空间复杂度是 $\Theta(n)$。而且 Python 还给这件事加了一道硬闸：递归深度上限默认 1000。

>>> def factorial(n, k):
...     if n == 0:
...         return k
...     return factorial(n - 1, n * k)
...
>>> factorial(5000, 1)
Traceback (most recent call last):
  ...
RecursionError: maximum recursion depth exceeded in comparison

这条报错信息值得记住。「exceeded in comparison」说明是在执行 n == 0 这个比较的时候撞到的上限——不同的写法后半句会不一样（可能是 in comparison、while calling a Python object 等），但只要看到 RecursionError，含义就一个：你堆了太多帧。它未必意味着你写错了递归（虽然大多数时候是漏了 base case），也可能只是「这个问题的规模超出了 Python 递归能承受的范围」。

迭代版：一帧走到底

迭代版从头到尾只有一帧。while 循环不新建帧（这是 Lecture 02 讲过的），它改的 n 和 k 就是当前帧里的那两个名字：

Global frame
    factorial  ──→ func factorial(n, k)

f1: factorial [parent=Global]
    进入循环前      n=3   k=1
    第 1 轮之后     n=2   k=3      (n,k = 3-1, 3*1)
    第 2 轮之后     n=1   k=6      (n,k = 2-1, 2*3)
    第 3 轮之后     n=0   k=6      (n,k = 1-1, 1*6)
    n > 0 不成立，退出循环，return k = 6

自始至终只有 1 帧。n = 1000000 也只有 1 帧。

3. 尾调用：怎么判断「返回之后还有没有活要干」

把上一节的递归版 factorial 原样翻译成 Scheme：

(define (factorial n k)
    (if
        (zero? n)
        k
        (factorial (- n 1) (* n k))
    )
)

结构和 Python 版一模一样：(zero? n) 对应 n == 0，k 对应 return k，(factorial (- n 1) (* n k)) 对应那一句递归 return。但它在 Scheme 里只占 $\Theta(1)$ 空间。同样的代码结构，换个语言就从 $\Theta(n)$ 变成 $\Theta(1)$，因为 Scheme 的语言标准要求解释器消除掉那些没用的帧。

第一个必须澄清的问题：是不是 Scheme 里所有递归都自动省空间？不是。必须写成「尾递归」的形式才享受得到。所以我们需要一套能机械执行的判断规则。

三个定义

第三条是承诺，前两条是它的前提。剩下的问题只有一个：哪些调用算尾调用？定义是：尾调用 = 处在尾上下文（tail context）中的调用表达式。而「尾上下文」是递归定义的一张清单：

注意每一条都带着「in a tail context」这个前缀——尾上下文是从过程体最外层往里传染的。if 的两个分支只有在这个 if 自己处在尾上下文里的时候，才也是尾上下文。一层一层嵌进去，链条上任何一环断了，里面的全都不算。

对着这张图把 factorial 走一遍：

把定义翻译成一句人话

4. 尾调用优化到底优化了什么

「尾调用不占额外空间」这句话很容易被念成咒语。它的机制其实非常具体：当一个调用是尾调用时，调用方那一帧在发出调用的瞬间就已经没用了，可以直接丢掉，让新调用去顶替它的位置。

为什么没用了？因为「没活要干」意味着：新调用返回什么，当前这层就返回什么。当前这层的所有局部绑定（n、k）在参数求值完之后再也不会被读到。既然如此，留着它干嘛？

把 (factorial 3 1) 在 Scheme 里跑一遍，对照第 2 节 Python 版的那张图：

调用 (factorial 3 1)
  帧: n=3  k=1
  求值体 (if (zero? 3) k (factorial 2 3))
    → (zero? 3) 为 #f，走 alternative
    → 先算算子数: (- 3 1) = 2, (* 3 1) = 3
    → 这是尾调用，当前帧的 n、k 再也用不到 → 丢弃本帧

  帧: n=2  k=3        ← 顶替了上一帧的位置，不是新增
    → (- 2 1) = 1, (* 2 3) = 6  → 丢弃本帧

  帧: n=1  k=6
    → (- 1 1) = 0, (* 1 6) = 6  → 丢弃本帧

  帧: n=0  k=6
    → (zero? 0) 为 #t，返回 k = 6

任意时刻只有 1 帧是活跃的。结果 6，与 Python 版一致。

把这张图和第 2 节迭代版 Python 的那张图并排看——它们是同一张图。状态序列 (3,1) → (2,3) → (1,6) → (0,6) 一模一样，帧数也一样都是 1。这就是那句经典说法的含义：尾递归就是循环。你写的是递归的语法，解释器执行的是循环的行为。

5. 改写配方：把「返回后要做的事」提前到传参时做掉

一个自然的问题：我平时写的递归大多不是尾递归，怎么办？好消息是线性递归（linear recursion）通常都能改写成尾递归，而且有固定套路。先看幻灯片上的例子——求列表长度。

; 非尾递归版
(define (length lst)
    (if
        (null? lst)
        0
        (+ 1 (length (cdr lst)))
    )
)

; 尾递归版
(define (length lst)
    (define (helper lst n)
        (if
            (null? lst)
            n
            (helper (cdr lst) (+ 1 n))
        )
    )
    (helper lst 0)
)

展开非尾递归版：帧为什么扔不掉

对 (length '(a b c)) 手动展开。写代换的形式最能看清「欠了多少活」：

(length '(a b c))
= (+ 1 (length '(b c)))                    ← 欠一次 +1
= (+ 1 (+ 1 (length '(c))))                ← 欠两次 +1
= (+ 1 (+ 1 (+ 1 (length '()))))           ← 欠三次 +1
= (+ 1 (+ 1 (+ 1 0)))                      ← 到 base case，开始回代
= (+ 1 (+ 1 1))
= (+ 1 2)
= 3

展开尾递归版：什么都不欠

(length '(a b c))
= (helper '(a b c) 0)
= (helper '(b c)   1)      ← (+ 1 0) 在传参时就算完了
= (helper '(c)     2)      ← (+ 1 1) 在传参时就算完了
= (helper '()      3)      ← (+ 1 2) 在传参时就算完了
= 3                        ← null? 成立，直接返回 n，不需要回代

两次展开的对比揭示了改写的实质：非尾递归是「先把问题拆到最小，再从最小往回攒答案」；尾递归是「一边往下走一边把答案攒好，走到底时答案已经现成」。攒答案的那个额外参数就叫累加器（accumulator）。

第 3 步里「零元挪到初值」这个对应关系很值得记：非尾递归版的 base case 返回值，和尾递归版的累加器初值，通常是同一个东西。length 是 0（加法单位元），求积就是 1（乘法单位元），造列表就是 nil。回头看第 3 节的 factorial(n, k)——那个「莫名其妙」的参数 k 就是累加器，而调用时传的 1 就是乘法的单位元。整节课第一个例子其实早就用上了这个配方，只是没告诉你。

; 错误示范
(define (length lst)
    (define (helper lst n)
        (if (null? lst)
            n
            (+ 1 (helper (cdr lst) n))    ; ← 加了累加器却没用它
        )
    )
    (helper lst 0)
)

6. 判断实战：四段代码，谁是尾递归

规则背下来没用，得能在陌生代码上用。下面四段是课上的随堂测验，每段都问同一个问题：这个过程是尾递归的吗？建议先自己判断再往下看。

(A) 求列表长度

(define (length s)
    (+
        1
        (if (null? s)
            -1
            (length (cdr s))
        )
    )
)

这段代码写得很怪：它把 + 1 提到了最外面，用 -1 抵消空列表那次多加的 1。先确认它是对的：(length '()) → (+ 1 -1) = 0；(length '(a)) → (+ 1 (length '())) = (+ 1 0) = 1。对。

但它不是尾递归。过程体最后（也是唯一）一个表达式是 (+ ...)，所以处在尾上下文的是这个对 + 的调用。那个 if 是 + 的算子数，不是尾上下文；if 里的 (length (cdr s)) 自然更不是。递归调用返回之后，还欠一次加法。

(B) 判断列表是否包含某个值

(define (contains s v)
    (if (null? s)
        #f
        (if (= v (car s))
            #t
            (contains (cdr s) v)
        )
    )
)

是尾递归。顺着链条走：

用人话验证：(contains (cdr s) v) 返回 #t 或 #f 之后，当前这层拿它干什么？什么也不干，直接当作自己的返回值交出去。没活干，所以是尾调用。注意谓词 (= v (car s)) 不在尾上下文，但它不含递归调用，无关紧要。

(C) 第 n 个斐波那契数

(define (fib n)
    (define (helper current k)
        (if (= n k)
            current
            (helper
                (+ current (fib (- n 1)))
                (+ k 1)
            )
        )
    )
    (if (= n 1) 0 (helper 1 2))
)

这段代码有个陷阱：它看起来用了第 5 节的配方——内部 helper、累加器 current、计数器 k，最后一行 (helper 1 2) 也确实是尾调用。但它不是尾递归。

问题出在 (+ current (fib (- n 1)))。它是 helper 调用的算子数，必须在调用 helper 之前算完。而算它的过程中要调用 fib，fib 里又要调用 helper……这条链上的调用没有一个是尾调用：(fib (- n 1)) 返回后还得做一次加法，加完才能传给 helper。

(D) 列表里有没有重复元素

; 假设 contains 就是 (B) 里那个
(define (has-repeat s)
    (if (null? s)
        #f
        (if (contains (cdr s) (car s))
            #t
            (has-repeat (cdr s))
        )
    )
)

是尾递归。结构和 (B) 完全一样：外层 if 在尾上下文 → 内层 if 在尾上下文 → 它的 alternative (has-repeat (cdr s)) 是尾调用。

唯一值得多想一句的是内层 if 的谓词 (contains (cdr s) (car s))。它不是尾调用（谓词位置从来不是尾上下文），那会不会毁掉空间保证？不会，理由是：

7. 动手：尾递归版 reverse 与 map

课上的随堂代码 21.scm 有三道题，前两道练尾递归。这里连思路带坑一起走一遍。

reverse：把列表倒过来

; reverse tests
(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))

Lecture 19 写过一个非尾递归版本，长这样：

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

它的问题不止「不是尾递归」：(reverse (cdr lst)) 返回之后还要做一次 append，而 append 本身要遍历整个左参数，所以这版还是 $\Theta(n^2)$ 时间。两个毛病同源——都是因为「真正的工作放在了递归返回之后」。

怎么想到尾递归写法？套第 5 节的配方：加一个累加器，把「返回后要干的活」提前干掉。这里返回后要干的活是「把 (car lst) 接到结果末尾」。可如果我们换个方向想——每次把当前元素 cons 到累加器的最前面，会发生什么？

累加器 reversed 从 nil 开始，逐个把 (car remaining) cons 上去：

remaining = (1 2 3)   reversed = ()
remaining = (2 3)     reversed = (1)          ← (cons 1 ())
remaining = (3)       reversed = (2 1)        ← (cons 2 (1))
remaining = ()        reversed = (3 2 1)      ← (cons 3 (2 1))
                      ↑ remaining 空了，直接返回 reversed

(define (reverse lst)
    (define (helper remaining reversed)
        (if (null? remaining)
            reversed
            (helper (cdr remaining) (cons (car remaining) reversed))
        )
    )

    (helper lst nil)
)

逐行确认它符合定义：

• helper 体只有一个 if → 那个 if 在尾上下文。
• if 的 alternative (helper (cdr remaining) (cons ...)) → 尾调用。cons 是在算子数位置执行的，调用发出之前就做完了。
• reverse 体的最后一个表达式是 (helper lst nil) → 也是尾调用。
• base case 返回累加器 reversed；累加器初值 nil 正好是「造列表」的零元。

验一遍边界：(reverse nil) → (helper nil nil) → (null? nil) 成立 → 返回 nil，打印为 ()。✓

map：把函数作用到每个元素上

非尾递归版（21.scm 里给出来作参考）：

(define (map f lst)
    (if (null? lst)
        nil
        (cons
            (f (car lst))
            (map f (cdr lst))
        )
    )
)

(map f (cdr lst)) 是 cons 的算子数，返回后还要 cons 一下 → 不是尾调用。

照 reverse 的思路加累加器：每次把 (f (car remaining)) cons 到累加器前面。但立刻撞上一个问题——结果会是反的：

(map-reverse '(1 2 3) nil)，f = (lambda (x) (* x x))

remaining = (1 2 3)   mapped = ()
remaining = (2 3)     mapped = (1)
remaining = (3)       mapped = (4 1)
remaining = ()        mapped = (9 4 1)      ← 返回 (9 4 1)，但我们要 (1 4 9)

这就是提示里那句「怎么用 reverse 来实现 map」的意思：先反着攒，最后再翻回来。

(define (map-tail f lst)
    (define (map-reverse remaining mapped)
        (if (null? remaining)
            mapped
            (map-reverse
                (cdr remaining)
                (cons
                    (f (car remaining))
                    mapped
                )
            )
        )
    )

    (reverse (map-reverse lst nil))
)

验证 (map-tail (lambda (x) (* x x)) '(1 2 3))：(map-reverse '(1 2 3) nil) 得 (9 4 1)，再 (reverse '(9 4 1)) 得 (1 4 9)。✓ 与 (expect (map-tail (lambda (x) (* x x)) (list 1 2 3)) (1 4 9)) 一致。

; 能过测试，但很差
(map-reverse (cdr remaining) (append mapped (list (f (car remaining)))))

8. 程序即数据：用 list 拼出一段程序，再 eval 它

下半场换主题。先问一个看起来很哲学、其实很实际的问题：程序是不是一种数据？

在很多语言里答案是「是」，而且你早就用过了：

• 高阶函数（higher-order function）——函数可以被当成参数传、当成返回值返回。这就是把「一段可执行的东西」当值使用。
• Python 的 eval 接受任意字符串，把它当作 Python 代码执行。
• Scheme 的 eval 接受任意 Scheme 列表，把它当作 Scheme 表达式求值。

Scheme 这一条比 Python 那一条强得多，原因在 Lecture 18 就埋下了：Scheme 的源代码本身就是列表。(+ 1 2) 既是一个「调用表达式」也是一个「三元素的列表」，取决于你怎么看它。Python 里代码是字符串，你得靠拼字符串来生成程序，稍不小心引号就串了；Scheme 里代码是结构化的数据，你用 cons、list、car、cdr 就能读写它。这个性质叫 homoiconicity（同像性），是 Lisp 系语言的看家本领。

quote 的作用：拦住求值

把这四行放在一起看，差别全在引号上：

scm> (+ 1 2)
3
scm> (list + 1 2)
(#[+] 1 2)
scm> (list '+ 1 2)
(+ 1 2)
scm> (list '+ 1 (+ 2 3))
(+ 1 5)

第 3 行是关键。(list '+ 1 2) 造出来的东西，既是「一个列表」也是「一段能跑的程序」。把它喂给 eval 就能跑：(eval (list '+ 1 2)) 得到 3。于是「写一个生成程序的程序」就退化成了「写一个生成列表的程序」——而生成列表你早就会了。

fact-exp：不算阶乘，只造出算阶乘的表达式

对照着看两个过程。左边是熟悉的阶乘，右边只改了一处：

; 返回 n 的阶乘
(define (fact n)
    (if (= n 0)
        1
        (* n (fact (- n 1)))
    )
)

; 返回一个「求值后等于 n 的阶乘」的 Scheme 表达式
(define (fact-exp n)
    (if (= n 0)
        1
        (list '* n (fact-exp (- n 1)))
    )
)

scm> (fact 5)
120
scm> (fact-exp 5)
(* 5 (* 4 (* 3 (* 2 (* 1 1)))))

改动只有一处：(* n (fact (- n 1))) 变成了 (list '* n (fact-exp (- n 1)))。原来是做乘法，现在是造一个写着乘法的列表。递归结构原封不动。

(fact-exp 3)
  n=3 ≠ 0 → (list '* 3 (fact-exp 2))      ← 要先算出 (fact-exp 2)
  (fact-exp 2)
    n=2 ≠ 0 → (list '* 2 (fact-exp 1))
    (fact-exp 1)
      n=1 ≠ 0 → (list '* 1 (fact-exp 0))
      (fact-exp 0)
        n=0 → 返回 1                       ← base case

回代：
  (fact-exp 1) = (list '* 1 1)          = (* 1 1)
  (fact-exp 2) = (list '* 2 '(* 1 1))   = (* 2 (* 1 1))
  (fact-exp 3) = (list '* 3 ...)        = (* 3 (* 2 (* 1 1)))

注意 base case 返回的是数字 1，它在最内层充当被乘数；
而每一层的 (list '* n ...) 把上一层的结果整个塞进第三个位置。

这里有个容易糊涂的地方：(fact-exp 3) 的返回值是数据，不是被执行的代码。它就是一个嵌套列表，静静地躺在那儿。要让它变回代码，得显式调用 eval。

fib-exp：树形递归也一样

; 返回第 n 个斐波那契数
(define (fib n)
    (if (<= n 1)
        n
        (+
            (fib (- n 2))
            (fib (- n 1))
        )
    )
)

; 返回一个「求值后等于第 n 个斐波那契数」的表达式
(define (fib-exp n)
    (if (<= n 1)
        n
        (list '+
            (fib-exp (- n 2))
            (fib-exp (- n 1))
        )
    )
)

scm> (fib 6)
8
scm> (fib-exp 6)
(+ (+ (+ 0 1) (+ 1 (+ 0 1))) (+ (+ 1 (+ 0 1)) (+ (+ 0 1) (+ 1 (+ 0 1)))))
scm> (eval (fib-exp 6))
8

最后一行是整节的落点：(eval (fib-exp 6)) 和 (fib 6) 给出同一个答案，但走的路完全不同——前者先把整棵递归树物化成一个表达式，再把这个表达式交给解释器求值。(fib-exp 6) 的输出其实就是 Lecture 06 讲树形递归时画的那棵调用树，只不过写成了一行文本：每个叶子是 base case 返回的 0 或 1，每个内部节点是一个 +。

9. 宏：定义你自己的特殊形式

先看一个用上一节技术就能写出来的小工具：twice，它把一个表达式执行两遍。

scm> (define (twice expr) (list 'begin expr expr))
twice
scm> (eval (twice '(print 2)))
2
2
scm> (eval (twice '(print "yeet")))
"yeet"
"yeet"
scm> (twice '(+ 1 2))
(begin (+ 1 2) (+ 1 2))

twice 是一个普通过程：给它一个表达式（作为数据），它返回 (begin <expr> <expr>) 这个列表。最后一行清楚地显示了它的返回值就是一段代码的形状；要真的跑起来，得套上 eval。

用起来很别扭的地方是那对括号外的引号和 eval：调用者必须记得写 '，还得记得写 eval。忘了引号会怎样？(twice (print 2)) 会先求值 (print 2)——打印一次 2，然后把它的返回值（undefined）传进去，结果完全不是你要的。

所以自然的愿望是：能不能不写引号、不写 eval，就得到同样的效果？能，这就是宏。

scm> (define-macro (twice expr) (list 'begin expr expr))
twice
scm> (twice (print 2))
2
2

代码体一个字都没改，只把 define 换成了 define-macro；调用处的 ' 和 eval 都消失了，行为一模一样。

宏是什么

回想一下特殊形式为什么特殊：(if p c a) 之所以不能写成普通过程，就是因为普通过程先把所有算子数求值完，而 if 必须只求值该走的那一支。在 define-macro 出现之前，特殊形式的名单是解释器写死的（if、define、lambda、and、or、cond、let、begin、quote……），你加不进去。宏把这扇门打开了。

宏调用表达式的求值规则（三步）

对照普通过程调用：普通调用是「求值算子 → 求值算子数 → apply → 结束」；宏调用是「求值算子 → 不求值算子数 → apply → 再求值一次结果」。差别就两处，但足以改变一切。

完整走一遍：check 宏

(define-macro (check expr)
    (list 'if expr ''passed ''failed)
)
(define x -2)
scm> (check (> x 0))
failed

先解释那两个刺眼的双引号。''passed 就是 (quote (quote passed))：外层 quote 挡住求值，于是它求值成 (quote passed)，也就是 'passed 这段代码。我们要往结果表达式里塞的不是符号 passed 本身，而是「一段写着 'passed 的代码」——因为宏返回的东西还要再被求值一次，如果只写 'passed，它求值成符号 passed，塞进结果表达式后第 3 步会把它当成一个变量名去查找，报 unknown identifier。

scm> (list 'if '(> x 0) ''passed ''failed)
(if (> x 0) (quote passed) (quote failed))

让 check 报告失败的表达式

宏能拿到源代码，这个能力现在派上用场：失败时不光说 failed，还把没通过的那个表达式一起显示出来。

(define-macro (check expr)
    (list 'if expr ''passed
        (list 'quote (list 'failed: expr))
    )
)

拆开看第三个算子数 (list 'quote (list 'failed: expr))：内层 (list 'failed: expr) 造出 (failed: (> x 0))；外层再套一个 (list 'quote ...)，把它变成 (quote (failed: (> x 0)))，也就是 '(failed: (> x 0))。套 quote 的理由和刚才一样——不套的话，第三步求值时解释器会把 (failed: (> x 0)) 当成「调用名为 failed: 的过程」。于是：

宏返回的表达式：
(if (> x 0) 'passed '(failed: (> x 0)))

x 为 -2 时求值结果：
(failed: (> x 0))

这就是一个极简的单元测试框架的雏形——而它之所以可能，只是因为宏收到的是代码而不是值。21.scm 里那些 (expect (reverse nil) ()) 之所以能在失败时打印出你写的原表达式，用的是同一个原理。

10. quasiquote 与 unquote：让宏体看起来像它要生成的代码

上一节的 check 已经能用，但读起来很痛苦：

(define-macro (check expr)
    (list 'if expr ''passed
        (list 'quote (list 'failed: expr))
    )
)

问题在于宏体的形状和它生成的代码的形状完全不像。它生成的是 (if ... 'passed '(failed: ...))，可你得在满屏的 list 和引号里把这个形状拼出来。写的时候容易漏引号，读的时候更是得在脑子里跑一遍 list 才知道结果长什么样。

Scheme 给了一对专门的工具：

用它们重写 check：

(define-macro (check expr)
    `(if ,expr 'passed
        '(failed: ,expr)
    )
)

现在宏体长得和生成的代码一模一样，只是在两个需要填空的位置点了逗号。这就是准引用的全部价值：模板。反引号说「下面这一整块照抄」，逗号说「这个洞除外，把 expr 的值填进来」。

手上有解释器的话可以直接看到 quasiquote 的行为，不用先写宏：

scm> (define x 5)
x
scm> `(if ,x 1 2)
(if 5 1 2)
scm> `(a b ,(+ 1 2))
(a b 3)

第二行里 if、1、2 全都没被求值（否则 if 会当特殊形式执行），只有 ,x 那一处被求值成了 5。

练习：for 宏

21.scm 的第三题：定义一个 for 宏，对序列里的每个值求值一次给定的表达式。

(expect (for x nil x) ())
(expect (for x '(1 2 3) x) (1 2 3))
(expect (for x '(2 3 4 5) (* x x)) (4 9 16 25))
(expect (for y '(2 4 6) (* y 3)) (6 12 18))

先看清它必须是宏而不能是过程。看第三条测试 (for x '(2 3 4 5) (* x x))：

• 第一个算子数是 x。如果这是普通过程调用，解释器会去环境里查 x——但 x 根本没被定义过，直接 Error: unknown identifier: x。我们要的是符号 x 本身，不是它的值。
• 第三个算子数是 (* x x)。同理，这时候求值它必然出错，因为 x 还没有值。它必须被推迟到「循环变量已经有值」之后才求值。

「拿到未求值的表达式」+「控制求值时机」——正是宏的两项本领。

怎么想到实现？提示是「怎么用 map 来实现 for」。反过来问：(for x '(2 3 4 5) (* x x)) 用现成的东西该写成什么？答案很自然：

(map (lambda (x) (* x x)) '(2 3 4 5))

三个部分正好对应三个参数：sym 成为 lambda 的形参，expr 成为 lambda 的体，vals 成为 map 的第二个参数。所以 for 宏要干的事，就是把这三块按模板拼成上面那行代码。

(define-macro (for sym vals expr)
    `(map (lambda (,sym) ,expr) ,vals)
)

不用准引用的等价写法（挑战版）：

(define-macro (for sym vals expr)
    (list 'map (list 'lambda (list sym) expr) vals)
)

对照着读一遍，就能理解准引用为什么值得学：上面那版一眼看得出生成的是 (map (lambda (…) …) …)；下面那版得从最内层的 (list sym) 开始往外拼才知道。两版生成的是完全相同的列表。

本讲小结

动手练习

五道自测题。建议先在纸上写出答案，再展开对照。

练习 1：这个过程是尾递归的吗

(define (count-evens s)
    (cond
        ((null? s) 0)
        ((even? (car s)) (+ 1 (count-evens (cdr s))))
        (else (count-evens (cdr s)))
    )
)

练习 2：and / or 里的尾上下文

(define (all-positive? s)
    (or
        (null? s)
        (and
            (> (car s) 0)
            (all-positive? (cdr s))
        )
    )
)

练习 3：把求和改成尾递归，并手动展开

把下面这个过程改写成尾递归，然后对 (sum '(1 2 3)) 展开每一步的参数。

(define (sum lst)
    (if (null? lst)
        0
        (+ (car lst) (sum (cdr lst)))
    )
)

(define (sum lst)
    (define (helper remaining total)
        (if (null? remaining)
            total
            (helper (cdr remaining) (+ total (car remaining)))
        )
    )
    (helper lst 0)
)

(sum '(1 2 3))
= (helper '(1 2 3) 0)
= (helper '(2 3)   1)      ← (+ 0 1)
= (helper '(3)     3)      ← (+ 1 2)
= (helper '()      6)      ← (+ 3 3)
= 6

练习 4：定义 unless 宏

定义一个 unless 特殊形式，(unless 条件 A B) 在条件为假时求值 A、为真时求值 B——正好和 if 相反。要求：只有该走的那一支被求值。请分别用「list 拼」和「准引用」两种写法。

; 准引用版
(define-macro (unless condition consequent alternative)
    `(if ,condition ,alternative ,consequent)
)

; list 拼接版
(define-macro (unless condition consequent alternative)
    (list 'if condition alternative consequent)
)

练习 5：为什么 twice 用 begin

(define-macro (twice expr) (list 'begin expr expr)) 生成的是 (begin <expr> <expr>)。为什么要套一层 begin，直接返回 (list expr expr) 行不行？