Common Lisp 中的 reader 宏有哪些限制

Question

我有自己的 JavaScript Lisp 解释器，我已经工作了一段时间了，现在我想实现像 Common Lisp 中那样的阅读器宏。

我已经创建了 Streams（几乎可以工作，除了像

,@ , ` '

这样的特殊符号），但是当它加载包含脚本（具有 400 行代码的 Lisp 文件）的页面时，它会冻结浏览器几秒钟。这是因为我的 Streams 基于子字符串函数。如果我首先拆分令牌，然后使用 TokenStream 迭代令牌，则效果很好。

所以我的问题是，字符串流真的是 Common Lisp 中的东西吗？你可以添加阅读器宏来创建全新的语法，比如在 CL 中的 Python，这简化了问题：我可以实现

"""

宏（不确定是否可以有 3 个字符作为阅读器宏）或其他将在 lisp 中实现模板文字的字符实例：

(let ((foo 10) (bar 20))
  {lorem ipsum ${baz} and ${foo}})

或

(let ((foo 10) (bar 20))
  ""lorem ipsum ${baz} and ${foo}"")

或

(let ((foo 10) (bar 20))
  :"lorem ipsum ${baz} and ${foo}")

会产生字符串

"lorem ipsum 10 and 20"

在 Common Lisp 中可能存在类似的情况吗？实现

#\{

或

#\:

作为读取器宏有多难？

我能想到的在 Lisp 中使用模板文字的唯一方法是这样的：

  (let ((foo 10) (bar 20))
    (tag "lorem ipsum ${baz} and ${foo}")))

其中标签是宏，返回以 ${} 作为自由变量的字符串。 reader 宏也可以返回被评估的 lisp 代码吗？

还有一个问题，你可以像这样实现阅读器宏吗：

(list :foo:bar)


(list foo:bar)

其中 : 是读取器宏，如果它位于符号之前，则将符号转换为

foo.bar

如果它在里面就会抛出错误。我问这个是因为基于令牌的宏

:foo:bar

和

foo:bar

将是符号，不会被我的阅读器宏处理。

还有一个问题，reader宏可以放在一行中，第二行使用它吗？这肯定只能通过字符串流实现，并且根据我的测试，使用 JavaScript 编写的解释器是不可能的。

Answer 1

存在一些限制，例如，除了“从头开始实现您自己的令牌解释器”之外，很难以任何方式干预令牌的解释。 但是，好吧，如果你想这样做的话，你可以这样做：问题是你的代码需要像现有代码一样处理数字和事物，而像浮点解析这样的事情要正确处理是非常繁琐的。

但是与宏字符关联的宏函数获取正在读取的流，并且它们可以自由地读取尽可能多或尽可能少的流，并返回任何类型的对象（或不返回任何对象，这就是注释的方式）已实施）。

我强烈建议阅读超规范的第 2 和 23 章，然后尝试实现。 当您使用该实现时，请注意，通过与读者搞混，很容易完全楔入事物。 至少我会建议这样的代码：

(defparameter *my-readtable* (copy-readtable nil))

;;; Now muck around with *my-readtable*, *not* the default readtable
;;;

(defun experimentally-read ((&key (stream *standard-input*)
                                  (readtable *my-readtable*)))
  (let ((*readtable* readtable))
    (read stream)))

这至少给你一些从灾难中恢复的机会：如果你可以中止一次

experimentally-read

，那么你就回到了

*readtable*

是明智的位置。

这是一个相当无用的示例，它显示了使用宏字符可以在多大程度上颠覆语法：宏字符定义将导致

( ...)

被读取为字符串。 这可能没有完全调试，正如我所说，我看不出它有什么用处。

(defun mindless-parenthesized-string-reader (stream open-paren)
  ;; Cause parenthesized groups to be read as strings:
  ;; - (a b) -> "a b"
  ;; - (a (b c) d) -> "a (b c) d"
  ;; - (a \) b) -> "a ) b"
  ;; This serves no useful purpose that I can see.  Escapes (with #\))
  ;; and nested parens are dealt with.
  ;;
  ;; Real Programmers would write this with LOOP, but that was too
  ;; hard for me.  This may well not be completely right.
  (declare (ignore open-paren))
  (labels ((collect-it (escaping depth accum)
             (let ((char (read-char stream t nil t)))
               (if escaping
                   (collect-it nil depth (cons char accum))
                 (case char
                   ((#\\)
                    (collect-it t depth accum))
                   ((#\()
                    (collect-it nil (1+ depth) (cons char accum)))
                   ((#\))
                    (if (zerop depth)
                        (coerce (nreverse accum) 'string)
                      (collect-it nil (1- depth) (cons char accum))))
                   (otherwise
                      (collect-it nil depth (cons char accum))))))))
    (collect-it nil 0 '())))

(defvar *my-readtable* (copy-readtable nil))

(set-macro-character #\( #'mindless-parenthesized-string-reader
                     nil *my-readtable*)

(defun test-my-rt (&optional (stream *standard-input*))
  (let ((*readtable* *my-readtable*))
    (read stream)))

现在

> (test-my-rt)
12
12

> (test-my-rt)
x
x

> (test-my-rt)
(a string (with some parens) and \) and the end)
"a string (with some parens) and ) and the end"