专栏名称: SegmentFault思否

SegmentFault （www.sf.gg）开发者社区，是中国年轻开发者喜爱的极客社区，我们为开发者提供最纯粹的技术交流和分享平台。

由浅入深学习 Lisp 宏之实战篇

SegmentFault思否 · 公众号 · 程序员 · 2017-10-18 08:00

正文

文章作者： http://liujiacai.net/ 原文链接： http://liujiacai.net/blog/2017/10/01/macro-in-action/

在上一篇文章中，介绍了宏（macro）的本质：在编译时期运行的函数。宏相对于普通函数，还有如下两条特点：

宏的参数不会求值（eval），是 symbol 字面量
宏的返回值是 code（在运行期执行），不是一般的数据。

这两条特性蕴含着一非常重要的思想： code as data ，也被称为同像性（homoiconicity，来自希腊语单词 homo，意为与符号含义表示相同）。同像性使得在 Lisp 中去操作语法树（AST）显得十分自然，而这在非 Lisp 语言只能由编译器（Compiler）去操作。

本文是宏系列的第二篇文章，侧重于实战，对于新手建议先阅读宏系列的理论篇，之后再来看本文。当然如果你有一定基础，也可以直接阅读本文。其次，希望读者能把本文的 Clojure 代码手动敲到 REPL 里面去运行、调试，直到完全理解。

Code as data

首先看一简单的程序片段

(defn hello-world []
  (println "hello world"))

上面的代码首先是一个大的 list，里面依次包含了2 个 symbol，1 个 vector，1 个 list，这个嵌套的 list 又包含了 1 个 symbol，1 个 string。可以看到，这些都是 Clojure 里面的基本数据类型，这就给我们提供了一个很好的写宏基础：可以像操作数据一样操作 code ，达到自动生成新 code 的目的。

宏的一主要使用场景是流程控制，比如 Clojure 里面的 when ：

(defmacro when [test & body]
  (list 'if test (cons 'do body)))

' 代表 quote，作用是阻止后面的表达式求值，如果不使用'的话，在进行 (list'if test ...) 求值时会报错，因为没发对 special form 单独进行求值，这里需要的仅仅是 if 字面量，list 函数执行后的结果（是一个 list）作为 code 插入到调用 when 的地方去执行。

(when (even? (rand-int 100))
  (println "good luck!")
  (println "lisp rocks!"))
;; when 展开后的形式 
(if (even? (rand-int 100))
  (do (println "good luck!") (println "lisp rocks!")))

syntax-quote & unquote

对于一些简单的宏，可以采用像 when 那样的方式，使用 list 函数来形成要返回的 code，但对于复杂的宏，使用 list 函数来表示，会显得十分麻烦，看下 when-let 的实现：

(defmacro 




    
when-let [bindings & body]
  (let [form (bindings 0) tst (bindings 1)]
    `(let [temp# ~tst]
       (when temp#
         (let [~form temp#]
           ~@body)))))

这里返回的 list 使用 （backtick） 进行了修饰，这称为 syntax-quote，它与 quote ' 类似，只不过在阻止表达式求值的同时，支持以下两个额外功能：

表达式里的所有 symbol 会在当前 namespace 中进行 resolve，返回 fully-qualified symbol
允许通过 ~(unquote) 或 ~@(slicing-unquote) 阻止部分表达式的 quote，以达到对它们求值的效果

可以通过下面一个例子来了解它们之间的区别：

(let [x '(* 2 3) y x]
  (println `y)
  (println ``y)
  (println ``~y)
  (println ``~~y)
  (println (eval ``~~y))
  (println `[~@y]))
;; 依次输出
user/y
(quote user/y)
user/y
(* 2 3)
6
[* 2 3]

这里尤其要注意理解嵌套 syntax-quote 的情况，为了得到正确的值，需要 unquote 相应的次数（上例中的第四个println），这在 macro-writing macro 中十分有用，后面会介绍的。

最后需要注意一点，在整个 Clojure 程序生命周期中，(syntax-)quote, (slicing-)unquote 是 Reader 来解析的，详见编译器工作流程。可以通过read-string来验证：

user> (read-




    
string "`y")
(quote user/y)
user> (read-string "``y")
(clojure.core/seq (clojure.core/concat (clojure.core/list (quote quote)) 
                                       (clojure.core/list (quote user/y))))
user> (read-string "``~y")
(quote user/y)
user> (read-string "``~~y")
y

Macro Rules of Thumb

在正式实战前，这里摘抄 JoyOfClojure 一书中关于写宏的一般准则：

如果函数能完成相应功能，不要写宏。在需要构造语法抽象（比如when）或新的binding 时再去用宏
写一个宏使用的 demo，并手动展开
使用macroexpand, macroexpand-1 与 clojure.walk/macroexpand-all 去验证宏是如何工作的
在 REPL 中测试
如果一个宏比较复杂，尽可能拆分成多个函数

希望读者在写/读宏遇到困难时，思考是否对应了上述准则。

In Action

前面介绍过，宏的一大应用场景是流程控制，比如上面介绍的 when、when-let，以及各种 do 的衍生品 dotimes、doseq，所以实战也从这里入手，构造一系列 do-primes，通过对它不断的完善修改，介绍写宏的技巧与注意事项。

(do-primes [n start end]
  body)

上面是 do-primes 的使用方式，它会遍历 [start, end) 范围内的素数，对于具体素数 n，执行 body 里面的内容。

do-primes

(defn prime? [n]
  (let [guard (int (Math/ceil (Math/sqrt n)))]
    (loop [i 2]
      (if (zero? (mod n i))
        false
        (




    
if (= i guard)
          true
          (recur (inc i)))))))
(defn next-prime [n]
  (if (prime? n)
    n
    (recur (inc n))))
(defmacro do-primes [[variable start end] & body]
  `(loop [~variable ~start]
     (when (< ~variable ~end)
       (when (prime? ~variable)
         ~@body)
       (recur (next-prime (inc ~variable))))))

上面的实现比较直接，首先定义了两个辅助函数，然后通过返回由 loop 构成的 code 来达到遍历的效果。简单测试下：

(do-primes [n 2 13]
  (println n))
;; 展开为
(loop [n 2]
  (when (< n 13)
    (when (prime? n) (println n))
    (recur (next-prime (inc n)))))
;; 最终输出 3 5 7 11

达到预期。但上述实现有些问题：end 在循环中进行比较时多次进行了求值，如果传入的 end 不是固定的数字，而是一个函数，而我们又无法确定这个函数有无副作用，这就可能产生问题。也许你会说，这个解决也很简单，在进行 loop 之前，用一个 let 先把 end 的值先算出来就可以了。这个确实能解决多次执行的问题，但是又引入另一个隐患：end 先于 start 执行。这会不会产生不良后果，我们同样无法预知，我们能做到的就是尽量不用暴露宏的实现细节，具体表现就是保证宏参数的求值顺序。所以有了下面的修改：

(defmacro do-primes2 [[variable start end] & body]
  `(let [start# ~start
         end# ~end]
     (loop [~variable start#]
       (when (< ~variable end#)
         (when (prime? ~variable)
           ~@body)
         (recur (next-prime (inc ~variable)))))))

上面使用 gensym 机制来生成全局位置的 symbol，保证宏的“卫生”（hygiene）。如果这里不使用 gensym，而是随便选取变量名，那么很有可能会产生冲突。

(do-primes2 [n 2 (+ 10 (rand-int 30))]
  (println n))
;; 展开为
(let [start__17380__auto__ 2 end__17381__auto__ (+ 10 (rand-int 30))]
  (loop [n start__17380__auto__]
    (when (< n end__17381__auto__)
      (when (prime? n) (println n))
      (recur (next-prime (inc n))))))

only-once

通过上面的例子，我们知道，gensym 是一种非常实用的技巧，所以我们完全有可能再进行一次抽象，构造 only-once 宏，来保证传入的参数按照顺序只求值一次：

(defmacro only-once [names & body]
  (let [gensyms (repeatedly (count names) gensym)]
    `(let [~@(interleave gensyms (repeat '(gensym)))]
       `(let [~~@(mapcat #(list %1 %2) gensyms names)]
          ~(let [~@(mapcat #(list %1 %2) names gensyms)]
             ~@body)))))
(defmacro do-primes3 [[variable start end] & body]
  (only-once [start end]
             `(loop [~variable ~start]
                (when (< ~variable ~end)
                  (when (prime? ~variable)
                    ~@body)
                  (recur (next-prime (inc ~variable)))))))
(do-primes3 [n 2 (+ 10 (rand-int 30))]
  (println n))
;; 展开为

only-once 的核心思想是用 gensym 来替换掉传入的 symbol（即 names），为了达到这种效果，它首先定义出一组与参数数目相同的 gensyms（分别记为#s1 #s2），然后在第二层 let 为这些 gensyms 做 binding，value 也是用 gensym 生成的（分别记为#s3 #s4），这一层的 let 的返回值将内嵌到 do-primes3 内：

(let [#s1 #s3 #s2 #s4]
  '(let [#s3 start #s3 end]
    (let [start #s1 end #s2]
      ~@body))

第三层 let 的结果作为 code 内嵌到调用 do-primes3 处，即最终的展开式：