[Emacs] Emacs之魂（九）：读取器宏

1. 编译器宏

Lisp源代码文本，首先经过读取器，得到了一系列语法对象，
这些语法对象，在宏展开阶段进行变换，最终由编译器/解释器继续处理。

以下我们使用defmacro定义了一个宏inc，

(defmacro inc (var)
    `(setq ,var (1+ ,var)))

它可以将(inc x)展开为(setq x (1+ x))。

inc宏可以看做对编译器/解释器进行“编程”，它影响了最终被编译/解释的程序。
因此，类似inc这样的宏，称为编译器宏（compiler macro）。

此外，还有一种宏，称为读取器宏（reader macro），
它在源代码的读取阶段，以自定义的方式，将文本转换为语法对象。

引用（quote）“'”，就是一个读取器宏，
它将源代码文本'(1 2)转换成(quote (1 2))。

2. 用户定义的读取器宏

虽然，引用“'”是一个读取器宏，但它却不是由用户定义的，
支持用户自定义的读取器宏，是一个很强大的语言特性，
它可以让我们摆脱语法的束缚，创建自己的语言。

2.1 Common Lisp

（1）set-macro-character
在Common Lisp中，我们可以使用set-macro-character，来模拟引用“'”的定义，

(set-macro-character #\'
    #'(lambda (stream char) 
        (list (quote quote) (read stream t nil t))))

当读取器遇到'a的时候，会返回(quote a)。
其中read函数可以参考：read。

（2）set-dispatch-macro-character
我们还可以自定义捕获字符（dispatch macro character），
例如，我们定义#?来捕获后面的文本，

(set-dispatch-macro-character #\# #\?
    #'(lambda (stream char1 char2)
        (list 'quote
            (let ((lst nil))
                (dotimes (i (+ (read stream t nil t) 1))
                    (push i lst))
                (nreverse lst)))))

读取器会将#?7转换成(0 1 2 3 4 5 6 7)。

（3）get-macro-character
我们还可以自定义分隔符，例如，以下我们定义了#{ ... }分隔符，

(set-macro-character #\}
    (get-macro-character #\)))

(set-dispatch-macro-character #\# #\{
    #'(lambda (stream char1 char2)
        (let ((accum nil)
              (pair (read-delimited-list #\} stream t)))
            (do ((i (car pair) (+ i 1)))
                ((> i (cadr pair))
                (list 'quote (nreverse accum)))
              (push i accum)))))

读取器会将#{2 7}转换成(2 3 4 5 6 7)。
其中，get-macro-character可以参考：GET-MACRO-CHARACTER。

2.2 Racket

在Racket中，我们可以通过创建自定义的读取器，得到一门新语言，
例如，下面两个文件language.rkt和main.rkt，

（1）language.rkt模块创建了一个读取器，

#lang racket
(require syntax/strip-context)
 
(provide (rename-out [literal-read read]
                     [literal-read-syntax read-syntax]))
 
(define (literal-read in)
  (syntax->datum
   (literal-read-syntax #f in)))
 
(define (literal-read-syntax src in)
  (with-syntax ([str (port->string in)])
    (strip-context
     #'(module anything racket
         (provide data)
         (define data 'str)))))

（2）main.rkt模块，就可以用新语法进行编写了，

#lang reader "language.rkt"
Hello World!

然后，我们载入main.rkt，查看该模块导出的data变量，

> (require (file "~/Test/main.rkt"))
> data
"\nHello World!"

在main.rkt中，
我们通过#lang reader "language.rkt"，载入了一个自定义的读取器模块，
该模块必须导出read，read-syntax两个函数。

这里，read-syntax只是简单的获取源代码，导出到data变量中，
最终返回了一个用于模块定义的语法对象(module ...)。

在本例中，它把"Hello World!"转换成了一个模块定义表达式，

(module anything racket
    (provide data)
    (define data "Hello World!"))

其中，anything是模块名，racket是该模块的依赖。
所以，当载入main.rkt后，我们就可以获取data的值了。

在实际应用中，我们还可以对源代码进行任意解析，创建自己的语言。

2.3 Emacs Lisp

Emacs Lisp内置的读取器，并不支持自定义的读取器宏，
为了实现读取器宏，我们需要重写Emacs内置的read函数，
例如，elisp-reader。

Emacs在启动时，会自动载入~/.emacs.d/init.el文件，然后执行其中的配置脚本，
因此，我们可以在init.el中调用elisp-reader。

（1）创建~/.emacs.d/init.el文件，

(add-to-list 'load-path "~/.emacs.d/package/elisp-reader/")
(require 'elisp-reader)

（2）使用git克隆elisp-reader仓库到~/.emacas.d/package文件夹，

git clone https://github.com/mishoo/elisp-reader.el.git ~/.emacs.d/package/elisp-reader

（3）打开Emacs，自动执行init.el中的配置，

（4）在Emacs中定义一个读取器宏，然后求值整个Buffer，（M-x ev-b）

(require 'cl-macs)

(def-reader-syntax ?{
    (lambda (in ch)
      (let ((list (er-read-list in ?} t)))
        `(list ,@(cl-loop for (key val) on list by #'cddr
                          collect `(cons ,key ,val))))))

（5）测试read函数的执行结果，（C-x C-e）

(read "{ :foo 1 :bar \"string\" :baz (+ 2 3) }")
> (list (cons :foo 1) (cons :bar "string") (cons :baz (+ 2 3)))

(car { :foo 1 :bar "string" :baz (+ 2 3) })
> (:foo . 1)

源代码{ :foo 1 :bar "string" :baz (+ 2 3) }被直接读取成了一个列表对象，

((:foo . 1) (:bar "string") (:baz (+ 2 3)))

对car函数而言，它看到的是列表对象，并不知道具体的语法是什么。

3. 总结

本文介绍了读取器宏的概念，Lisp各方言中会对读取器宏有不同程度的支持，
我们分析了Common Lisp，Racket以及Emacs Lisp的做法。

读取器宏直接作用到源代码文本上，用户定义的读取器宏可以对读取器进行“编程”，
借此可以支持自由灵活的语法，它是设计和使用DSL的神兵利器。

参考

Common Lisp the Language, 2nd Edition: 8.4 Compiler Macros
ANSI Common Lisp: 14.3 Read-Macros
Let Over Lambda: 4. Read Macros
The Racket Reference: 17.3.2 Using #lang reader
Github: elisp-reader