当我编译以下代码时，SBCL抱怨g-单位值和g-单位未定义。我不知道如何调试它。据我所知，压扁是失败的。
当扁平化到达去单位的未标记部分时，整个部分似乎被视为一个原子。听起来正确吗？
下面使用的代码从书让Lambda：
Paul Graham Utilities
(defun symb (&rest args)
(values (intern (apply #'mkstr args))))
(defun mkstr (&rest args)
(with-output-to-string (s)
(dolist (a args) (princ a s))))
(defun group (source n)
(if (zerop n) (error "zero length"))
(labels ((rec (source acc)
(let ((rest (nthcdr n source)))
(if (consp rest)
(rec rest (cons (subseq source 0 n) acc))
(nreverse (cons source acc))))))
(if source (rec source nil) nil)))
(defun flatten (x)
(labels ((rec (x acc)
(cond ((null x) acc)
((atom x) (cons x acc))
(t (rec (car x) (rec (cdr x) acc))))))
(rec x nil)))
出租Lambda实用程序-第3章
(defmacro defmacro/g! (name args &rest body)
(let ((g!-symbols (remove-duplicates
(remove-if-not #'g!-symbol-p
(flatten body)))))
`(defmacro ,name ,args
(let ,(mapcar
(lambda (g!-symbol)
`(,g!-symbol (gensym ,(subseq
(symbol-name g!-symbol)
2))))
g!-symbols)
,@body))))
(defun g!-symbol-p (symbol-to-test)
(and (symbolp symbol-to-test)
(> (length (symbol-name symbol-to-test)) 2)
(string= (symbol-name symbol-to-test)
"G!"
:start1 0
:end1 2)))
(defmacro defmacro! (name args &rest body)
(let* ((o!-symbols (remove-if-not #'o!-symbol-p args))
(g!-symbols (mapcar #'o!-symbol-to-g!-symbol o!-symbols)))
`(defmacro/g! ,name ,args
`(let ,(mapcar #'list (list ,@g!-symbols) (list ,@o!-symbols))
,(progn ,@body)))))
(defun o!-symbol-p (symbol-to-test)
(and (symbolp symbol-to-test)
(> (length (symbol-name symbol-to-test)) 2)
(string= (symbol-name symbol-to-test)
"O!"
:start1 0
:end1 2)))
(defun o!-symbol-to-g!-symbol (o!-symbol)
(symb "G!" (subseq (symbol-name o!-symbol) 2)))
放行Lambda-第5章
(defun defunits-chaining (u units prev)
(if (member u prev)
(error "~{ ~a~^ depends on~}"
(cons u prev)))
(let ((spec (find u units :key #'car)))
(if (null spec)
(error "Unknown unit ~a" u)
(let ((chain (second spec)))
(if (listp chain)
(* (car chain)
(defunits-chaining
(second chain)
units
(cons u prev)))
chain)))))
(defmacro! defunits (quantity base-unit &rest units)
`(defmacro ,(symb 'unit-of- quantity)
(,g!-unit-value ,g!-unit)
`(* ,,g!-unit-value
,(case ,g!-unit
((,base-unit) 1)
,@(mapcar (lambda (x)
`((,(car x))
,(defunits-chaining
(car x)
(cons
`(,base-unit 1)
(group units 2))
nil)))
(group units 2))))))
这有点棘手：
问题：您假设反引号/逗号表达式是纯列表
你需要问自己这个问题：
反引号/逗号表达式的表示形式是什么
这是一份清单吗？
实际上，完整的表述没有具体说明。参见此处：CLHS：第2.4.6.1节关于反报价的说明
我们正在使用SBCL。请参阅：
* (setf *print-pretty* nil)
NIL
* '`(a ,b)
(SB-INT:QUASIQUOTE (A #S(SB-IMPL::COMMA :EXPR B :KIND 0)))
因此，逗号表达式由类型为SB-IMPL::COMMA的结构表示。SBCL开发人员认为，当需要用漂亮的打印机打印这样的后报价列表时，这种表示方式会有所帮助。
由于flatten将结构视为原子，所以它不会向内看。。。
但这是SBCL的具体表现。Clozure CL做了其他的事情，LispWorks又做了其他事情。
Clozure CL:
? '`(a ,b)
(LIST* 'A (LIST B))
LispWorks:
CL-USER 87 > '`(a ,b)
(SYSTEM::BQ-LIST (QUOTE A) B)
调试
由于您发现flatten以某种方式参与其中，接下来的调试步骤是：
首先：跟踪函数flatten，看看它被调用的数据和返回的数据。
由于我们不确定实际数据是什么，我们可以INSPECT它。
使用SBCL:的调试示例
* (defun flatten (x)
(inspect x)
(labels ((rec (x acc)
(cond ((null x) acc)
((atom x) (cons x acc))
(t (rec (car x) (rec (cdr x) acc))))))
(rec x nil)))
STYLE-WARNING: redefining COMMON-LISP-USER::FLATTEN in DEFUN
FLATTEN
上面对参数数据调用INSPECT。在Common Lisp中，Inspector通常是一种可以交互式地检查数据结构的东西。
例如，我们用一个后引号表达式调用flatten：
* (flatten '`(a ,b))
The object is a proper list of length 2.
0. 0: SB-INT:QUASIQUOTE
1. 1: (A ,B)
我们在交互式检查员中。现在可用的命令：
> help
help for INSPECT:
Q, E - Quit the inspector.
<integer> - Inspect the numbered slot.
R - Redisplay current inspected object.
U - Move upward/backward to previous inspected object.
?, H, Help - Show this help.
<other> - Evaluate the input as an expression.
Within the inspector, the special variable SB-EXT:*INSPECTED* is bound
to the current inspected object, so that it can be referred to in
evaluated expressions.
因此命令1进入数据结构，这里是一个列表。
> 1
The object is a proper list of length 2.
0. 0: A
1. 1: ,B
进一步走进：
> 1
The object is a STRUCTURE-OBJECT of type SB-IMPL::COMMA.
0. EXPR: B
1. KIND: 0
这里的检查器告诉我们对象是一个特定类型的结构。这就是我们想要知道的。
现在，我们使用命令q离开Inspector，flatten函数继续并返回一个值：
> q
(SB-INT:QUASIQUOTE A ,B)
对于其他试图获取defmacro的人！为了研究SBCL，这个问题的一个临时解决方案是在压平过程中在未引用的结构中摸索，递归地压平其内容：
(defun flatten (x)
(labels ((flatten-recursively (x flattening-list)
(cond ((null x) flattening-list)
((eq (type-of x) 'SB-IMPL::COMMA) (flatten-recursively (sb-impl::comma-expr x) flattening-list))
((atom x) (cons x flattening-list))
(t (flatten-recursively (car x) (flatten-recursively (cdr x) flattening-list))))))
(flatten-recursively x nil)))
但这严重依赖于平台。如果我找到更好的方法，我会发布它。
如果有人还对这个感兴趣，这是我的三美分。我反对flatten的上述修改，因为它可能更自然地像最初一样有用，而未引用的表示问题在defmacro/g!中相当普遍。我对defmacro/g!进行了一个不太漂亮的修改，使用特性来决定该做什么。也就是说，当处理非SBCL实现（#-sbcl）时，我们像以前一样进行，而在SBCL（#+sbcl）的情况下，我们深入研究sb-impl::comma结构，在必要时使用其expr属性，并在remove-duplicates中使用equalp，因为我们现在处理的是结构，而不是符号。这是代码：
(defmacro defmacro/g! (name args &rest body)
(let ((syms (remove-duplicates
(remove-if-not #-sbcl #'g!-symbol-p
#+sbcl #'(lambda (s)
(and (sb-impl::comma-p s)
(g!-symbol-p (sb-impl::comma-expr s))))
(flatten body))
:test #-sbcl #'eql #+sbcl #'equalp)))
`(defmacro ,name ,args
(let ,(mapcar
(lambda (s)
`(#-sbcl ,s #+sbcl ,(sb-impl::comma-expr s)
(gensym ,(subseq
#-sbcl
(symbol-name s)
#+sbcl
(symbol-name (sb-impl::comma-expr s))
2))))
syms)
,@body))))
它与SBCL配合使用。我还没有在其他实现上对它进行彻底的测试。