• 宏
    • defmacro
    • Quote
      • Simple Quoting
      • Syntax Quoting

    宏

    Macro是函数式编程里面很重要的一个概念，在之前，我们已经使用了Clojure里面的一些macro，譬如when，and等，我们可以通过macroexpand获知：

    1. user=> (macroexpand '(when true [1 2 3]))
    2. (if true (do [1 2 3]))
    1. user=> (doc when)
    2. -------------------------
    3. clojure.core/when
    4. ([test & body])
    5. Macro
    6.   Evaluates test. If logical true, evaluates body in an implicit do.
    7. nil

    可以看到，when其实就是if + do的封装，很类似C语言里面的macro。

    defmacro

    我们可以通过defmacro来定义macro：

    1. user=> (defmacro my-plus
    2.   #_=> "Another plus for a + b"
    3.   #_=> [args]
    4.   #_=> (list (second args) (first args) (last args)))
    5. #'user/my-plus
    6. user=> (my-plus (1 + 1))
    7. 2
    8. user=> (macroexpand '(my-plus (1 + 1)))
    9. (+ 1 1)

    macro的定义比较类似函数的定义，我们需要定义一个macro name，譬如上面的my-plus，一个可选择的macro document，一个参数列表以及macro body。body通常会返回一个list用于后续被Clojure进行执行。

    我们可以在macro body里面使用任何function，macro以及special form，然后使用macro的时候就跟函数调用一样。但是跟函数不一样的地方在于函数在调用的时候，参数都是先被evaluated，然后才被传入函数里面的，但是对于macro来说，参数是直接传入macro，而没有预先被evaluated。

    我们也能在macro里面使用argument destructuring技术，进行参数绑定：

    1. user=> (defmacro my-plus2
    2.   #_=> [[op1 op op2]]
    3.   #_=> (list op op1 op2))
    4. #'user/my-plus2
    5. user=> (my-plus2 (1 + 1))
    7. Symbol and Value

    编写macro的时候，我们其实就是构建list供Clojure去evaluate，所以在macro里面，我们需要quote expression，这样才能给Clojure返回一个没有evaluated的list，而不是在macro里面就自己evaluate了。也就是说，我们需要明确了解symbol和value的区别。

    譬如，现在我们要实现这样一个功能，一个macro，接受一个expression，打印并且输出它的值，可能看起来像这样:

    1. user=> (let [result 1] (println result) result)
    2. 1
    3. 1

    然后我们定义这个macro：

    1. user=> (defmacro my-print
    2.   #_=> [expression]
    3.   #_=> (list let [result expression]
    4.   #_=> (list println result)
    5.   #_=> result))

    我们会发现出错了，错误为"Can't take value of a macro: #'clojure.core/let"，为什么呢？在上面这个例子中，我们其实想得到的是let symbol，而不是得到let这个symbol引用的value，这里let并不能够被evaluate。

    所以为了解决这个问题，我们需要quote let，只是返回let这个symbol，然后让Clojure外面去负责evaluate，如下：

    1. user=> (defmacro my-print
    2.   #_=> [expression]
    3.   #_=> (list 'let ['result expression]
    4.   #_=> (list 'println 'result)
    5.   #_=> 'result))
    6. #'user/my-print
    7. user=> (my-print 1)
    8. 1
    9. 1

    Quote

    Simple Quoting

    如果我们仅仅想得到一个没有evaluated的symbol，我们可以使用quote:

    1. user=> (+ 1 2)
    2. 3
    3. user=> (quote (+ 1 2))
    4. (+ 1 2)
    5. user=> '(+ 1 2)
    6. (+ 1 2)
    7. user=> '123
    8. 123
    9. user=> 123
    10. 123
    11. user=> 'hello
    12. hello
    13. user=> hello
    15. CompilerException java.lang.RuntimeException: Unable to resolve symbol: hello in this context

    Syntax Quoting

    在前面，我们通过'以及quote了解了simple quoting，Clojure还提供了syntax quoting ```

    1. user=> `1
    2. 1
    3. user=> `+
    4. clojure.core/+
    5. user=> '+
    6. +

    可以看到，syntax quoting会返回fully qualified symbol，所以使用syntax quoting能够让我们避免命名冲突。

    另一个syntax quoting跟simple quoting不同的地方在于，我们可以在syntax quoting里面使用~来unquote一些form，这等于是说，我要quote这一个expression，但是这个expression里面某一个form先evaluate，譬如:

    1. user=> `(+ 1 ~(inc 1))
    2. (clojure.core/+ 1 2)
    3. user=> `(+ 1 (inc 1))
    4. (clojure.core/+ 1 (clojure.core/inc 1))

    这里还需要注意一下unquote splicing:

    1. user=> `(+ ~(list 1 2 3))
    2. (clojure.core/+ (1 2 3))
    3. user=> `(+ ~@(list 1 2 3))
    4. (clojure.core/+ 1 2 3)

    syntax quoting会让代码更加简洁，具体到前面print那个例子，我们let这些都加了quote，代码看起来挺丑陋的，如果用syntax quoting，如下:

    1. user=> (defmacro my-print2
    2.   #_=> [expression]
    3.   #_=> `(let [result# ~expression]
    4.   #_=> (println result#)
    5.   #_=> result#))
    6. #'user/my-print2
    7. user=> (my-print2 1)
    8. 1
    9. 1