第 12 章 广义变量

第 8 章曾提到，宏的长处之一是其变换参数的能力。setf 就是这类宏中的一员。本章将着重分析 setf 的内涵，然后以几个宏为例，它们将建立在 setf 的基础之上。

要在 setf 上编写正确无误的宏并非易事，其难度让人咋舌。为了介绍这个主题，第一节会先给出一个有点小问题的简单例子。接下来的小节将解释该宏的错误之处，然后展示如何改正它。第三和第四节会介绍一些基于 setf 的实用工具的例子，而最后一节则会说明如何定义你自己的 setf 逆变换。

12.1 概念

内置宏 setf 是 setq 的推广形式。setf 的第一个参数可以是个函数调用而非简单的变量：

> (setq lst '(a b c))
(A B C)
> (setf (car lst) 480)
480
> lst
(480 B C)

一般而言，(setf x y) 可以理解成 "务必让 x 的求值结果为 y"。作为一个宏，setf 得以深入到参数内部，弄清需要做哪些工作，才能满足这个要求。如果第一个参数(在宏展开以后) 是个符号，那么 setf 就只会展开成 setq。但如果第一个参数是个查询语句，那么 setf 则会展开到对应的断言上。由于第二个参数是常量，所以前面的例子可以展开成：

(progn (rplaca lst 480) 480)

这种从查询到断言的变换被称为逆变换。Common Lisp 中所有最常用的访问函数都有预定义的逆，包括 car、cdr、nth、aref、get、gethash，以及那些由 defstruct 创建的访问函数。( 完整的名单见 CLTL2 的第 125 页。)

能充当 setf 第一个参数的表达式被称为广义变量。广义变量已经成为了一种强有力的抽象机制。宏调用和广义变量的相似之处在于：一个宏调用，只要能展开成可逆引用，那么其本身就一定是可逆的。

当我们也加入这个行列，基于 setf 编写自己的宏时，这种组合可以产生显而易见更清爽的程序。我们可以在 setf 上面定义的宏有很多，其中一个是 toggle：【注1】

(defmacro toggle (obj)
  '(setf ,obj (not ,obj)))

它可以反转一个广义变量的值：

> (let ((lst '(a b c)))
  (toggle (car lst))
  lst)
(NIL B C)

现在考虑下面的应用。假设有个人，他可能是个肥皂剧作者、精力充沛的好事者，或是居委会大妈，想要维护一个数据库。其中记录着小镇上所有居民之间的种种恩怨情仇。在数据库里的表里，其中有一张便是用来保存朋友关系的：

(defvar *friends* (make-hash-table))

这个哈希表的表项本身也是哈希表，其中，潜在的朋友被映射到 t 或者 nil ：

(setf (gethash 'mary *friends*) (make-hash-table))

为了使 John 成为 Mary 的朋友，我们可以说：

(setf (gethash 'john (gethash 'mary *friends*)) t)

这个镇被分为两派。正如帮派的传统，每个人都声称 "凡人非友即敌"，所以镇上所有人都被迫加入一方或者另一方。这样当某人转变立场时，他所有的朋友都变成敌人，而所有的敌人则变成朋友。

如果只用内置的操作符来切换 x 和 y 的敌友关系，我们必须这样说：

(setf (gethash x (gethash y *friends*))
  (not (gethash x (gethash y *friends*))))

尽管去掉 setf 后要简单许多，这个表达式还是相当复杂。倘若我们为数据库定义了一个访问宏，如下：

(defmacro friend-of (p q)
  '(gethash ,p (gethash ,q *friends*)))

那么在这个宏和 toggle 的协助下，我们就得以更方便地修改数据库的数据。前面那个更新数据库的语句可以简化成：

(toggle (friend-of x y))

广义变量就像是美味的健康食品。它们能让你的程序良好地模块化，同时变得更为优雅。如果你给出宏或者可逆函数，用来访问你的数据结构，那么其他模块就可以使用 setf 来修改你的数据结构而无需了解其内部细节。

12.2 多重求值问题

上一节曾警告说，我们最初的 toggle 定义是不正确的：

(defmacro toggle (obj) ; wrong
  '(setf ,obj (not ,obj)))

它会碰到第 10.1 节里提到的多重求值问题。如果它的参数有副作用，那麻烦就来了。比如说，若 lst 是一个对象列表，我们这样写：

(toggle (nth (incf i) lst))

并期待它能反转第 (i+1) 个元素。事与愿违，如果使用 toggle 现在的定义，这个调用将展开成：

(setf (nth (incf i) lst)
  (not (nth (incf i) lst)))

这会使 i 递增两次，并且将第 (i+1) 个元素设置成第 (i+2) 个元素的反。所以在本例中:

> (let ((lst '(t nil t))
    (i -1))
  (toggle (nth (incf i) lst))
  lst)
(T NIL T)

调用 toggle 毫无效果。

仅仅把作为 toggle 参数给出的表达式插入到 setf 的第一个参数的位置上还不够。我们必须深入到表达式内部，看看它到底做了什么：如果它含有 subform ，而且这些 subform 有副作用的话，我们就需要把它们分开，并单独求值。一般而言，这件事情并不那么简单。

为了让问题容易些，Common Lisp 提供了一个宏，它可以帮助我们自动定义一些基于 setf 的宏，不过适用范围有限。宏的名字叫 define-modify-macro ，它接受三个参数：被定义宏的宏名，它的附加参数（出现在广义变量之后），以及一个函数名，这个函数将为广义变量产生新值。【注2】【注3】

使用 define-modify-macro ，我们可以像下面这样定义 toggle ：

(define-modify-macro toggle () not)

具体说，就是 "若要求值形如 (toggle place) 的表达式，应该先找到 place 指定的位置，并且，如果保存在那里的值是 val，将其替换成 (not val) 的值"。下面把这个新宏用在原来的例子里：

> (let ((lst '(t nil t))
    (i -1))
  (toggle (nth (incf i) lst))
  lst)
(NIL NIL T)

虽然这个版本正确无误地给出了结果，但它本可以写得更通用些。由于 setf 和 setq 两者对其参数数量都没有限制，toggle 也应如此。我们可以通过在修改宏 (modify-macro) 的基础上定义另一个宏，来赋予它这种能力，如 [示例代码 12.1]所示。

[示例代码 12.1]：操作在广义变量上的宏

(defmacro allf (val &rest args)
  (with-gensyms (gval)
    '(let ((,gval ,val))
      (setf ,@(mapcan #'(lambda (a) (list a gval))
          args)))))

(defmacro nilf (&rest args) '(allf nil ,@args))

(defmacro tf (&rest args) '(allf t ,@args))

(defmacro toggle (&rest args)
  '(progn
    ,@(mapcar #'(lambda (a) '(toggle2 ,a))
      args)))

(define-modify-macro toggle2 () not)

12.3 新的实用工具

本节将给出一些新的实用工具为例，我们用它们对广义变量进行操作。这些实用工具必须是宏，以便将参数原封不动地传给 setf。

[示例代码 12.1] 中有四个基于 setf 的新宏。第一个是 allf ，它被用来将同一值赋给多个广义变量。nilf 和 tf 就是基于它实现的，它们分别将参数设置 为 nil 和 t 。虽然这些宏很简单，但是方便实用。

和 setq 一样，setf 也可以接受多个参数 -- 即交替出现的变量和对应的值：

(setf x 1 y 2)

这些新的实用工具同样有这个能力，而且只用传原来一半的参数就可以了。如果你想要把多个变量初始化为 nil ，那么可以不再使用：

(setf x nil y nil z nil)

而改成说：

(nilf x y z)

就行了。最后一个宏是前一节曾介绍过的 toggle ：它和 nilf 差不多，但给每个参数设置的是真值的反。

这四个宏说明了关于赋值操作符的一个要点。就算我们只需要对普通变量使用一个操作符，而把这个操作符号展开成 setf 而非 setq ，这样做，有百利而无一害。如果第一个参数是符号，setf 将直接展开到 setq。由于不费吹灰之力，就能拥有 setf 的一般性，所以很少有必要在展开式里使用 setq。

[示例代码 12.2] 广义变量上的列表操作

(define-modify-macro concf (obj) nconc)

(defun conc1f/function (place obj)
  (nconc place (list obj)))

(define-modify-macro conc1f (obj) conc1f/function)

(defun concnew/function (place obj &rest args)
  (unless (apply #'member obj place args)
    (nconc place (list obj))))

(define-modify-macro concnew (obj &rest args)
  concnew/function)

[示例代码 12.2] 【注4】包含三个破坏性修改列表结尾的宏。第 3.1 节提到依赖

(nconc x y)

的副作用是不可靠的，并且必须改成：【注5】

(setq x (nconc x y))

这一习惯用法被嵌入在 concf 中了。更特殊的 conc1f 和 concnew 就像是用于列表另一端的 push 和 pushnew，conc1f 在列表结尾追加一个元素，而 concnew 的功能相同，但只有当这个元素不在列表中时才会动作。

第 2.2 节曾提到，函数的名字既可以是符号，也可以是–表达式。因此，把整个λ表达式作为第三个参数传给 define-modify-macro 也是可行的，正如 conc1f 的定义。【注6】 如果用第 4.3 节上的 conc1 的话，这个宏也可以写成：

(define-modify-macro conc1f (obj) conc1)

在一种情况下，[示例代码 12.2] 中的宏应该限制使用。如果你正准备通过在结尾处追加元素的方式来构造列表，那么最好用 push ，最后再 nreverse 这个列表。在列表的开头处理数据比在结尾要方便些，因为在结尾处处理数据的话，你首先得到那里。Common Lisp 有许多用于前者的操作符，而适用于后者的操作符则屈指可数，这很可能是为了鼓励程序员设计更高效率的程序。

12.4 更复杂的实用工具

并非所有基于 setf 的宏都可以用 define-modify-macro 定义。比如说，假设我们想要定义一个宏 _f ，让它破坏性把函数应用于一个广义变量。内置宏 incf 就相当于使用了 + 的 setf 的缩写。把：

(setf x (+ x y))

取而代之，我们只需说：

(incf x y)

新的宏 _f 就是上述思路的推广：incf 能展开成对 + 的调用，而 _f 则会展开成对由第一个参数给出操作符的调用。例如，在第 8.3 节 scale-objs 的定义里，我们必须这样写：

(setf (obj-dx o) (* (obj-dx o) factor))

改用 _f 的话，将变成：

(_f * (obj-dx o) factor)

_f 可能会被错写成：

(defmacro _f (op place &rest args) ; wrong
  '(setf ,place (,op ,place ,@args)))

不幸的是，我们无法用 define-modify-macro 正确无误地定义 _f ，因为应用到广义变量上的操作符是由参数给定的。

这类更复杂的宏必须由手工编写。为了让这种宏的编写方便些，Common Lisp 提供了函数 get-setf-expansion 【注7】，它接受一个广义变量并返回所有用于获取和设置其值的必要信息。通过为下面表达式手工生成展开式，我们将了解如何使用这些信息：

(incf (aref a (incf i)))

当我们对广义变量调用 get-setf-expansion 时，可以得到五个值用作宏展开式的原材料：

> (get-setf-expansion '(aref a (incf i)))
(#:G4 #:G5)
(A (INCF I))
(#:G6)
(SYSTEM:SET-AREF #:G6 #:G4 #:G5)
(AREF #:G4 #:G5)

最开始的两个值分别是临时变量列表，以及应该给它们赋的值。因此，我们可以这样开始展开式：

(let* ((#:g4 a)
    (#:g5 (incf i)))
  ...)

这些绑定应该在 let* 里创建。因为一般来说，这些值 form 可能会引用到前面的变量。第三【注8】和第五个值是另一个临时变量和将返回广义变量初值的 form。由于我们想要在这个值上加 1，所以把后者包在对 1+ 的调用里：

(let* ((#:g4 a)
    (#:g5 (incf i))
    (#:g6 (1+ (aref #:g4 #:g5))))
  ...)

最后，get-setf-expansion 返回的第四个值是一个赋值的表达式，该赋值必须在新绑定环境下进行：

(let* ((#:g4 a)
    (#:g5 (incf i))
    (#:g6 (1+ (aref #:g4 #:g5))))
  (system:set-aref #:g6 #:g4 #:g5))

不过，这个 form 多半会引用一些内部函数，而这些内部函数不属于 Common Lisp 标准。通常 setf 掩盖了这些函数的存在，但它们必须存在于某处。因为关于它们的所有东西都依赖于具体的实现，所以注重可移植性的代码应该使用由 get-setf-expansion 返回的这些 form，而不是直接引用诸如 system:set-aref 这样的函数。

现在为实现 _f 而编写的宏，所要完成的工作，几乎和我们刚才手工展开 incf 时做的事情完全一样。唯一的区别就是，不再把 let* 里的最后一个 form 包装在 1+ 调用里，而是将它包装在来自 _f 参数的一个表达式里。[示例代码 12.3] 给出了 _f 的定义。

[示例代码 12.3] setf 上更复杂的宏

(defmacro _f (op place &rest args)
  (multiple-value-bind (vars forms var set access)
    (get-setf-expansion place)
    '(let* (,@(mapcar #'list vars forms)
        (,(car var) (,op ,access ,@args)))
      ,set)))

(defmethod pull (obj place &rest args)
  (multiple-value-bind (vars forms var set access)
    (get-setf-expansion place)
    (let ((g (gensym)))
      '(let* ((,g ,obj)
          ,@(mapcar #'list vars forms)
          (,(car var) (delete ,g ,access ,@args)))
        ,set))))

(defmacro pull-if (test place &rest args)
  (multiple-value-bind (vars forms var set access)
    (get-setf-expansion place)
    (let ((g (gensym)))
      '(let* ((,g ,test)
          ,@(mapcar #'list vars forms)
          (,(car var) (delete-if ,g ,access ,@args)))
        ,set))))

(defmacro popn (n place)
  (multiple-value-bind (vars forms var set access)
    (get-setf-expansion place)
    (with-gensyms (gn glst)
      '(let* ((,gn ,n)
          ,@(mapcar #'list vars forms)
          (,glst ,access)
          (,(car var) (nthcdr ,gn ,glst)))
        (prog1 (subseq ,glst 0 ,gn)
          ,set)))))

这是个很有用的实用工具。举个例子，现在在它的帮助下，我们就可以轻易地将任意有名函数替换成其记忆化（第5.3 节）的等价函数。【注9】要对 foo 进行记忆化的处理，可以用：

(_f memoize (symbol-function 'foo))

使用 _f ，也有助于简化其他基于 setf 的宏的定义。例如，我们现在可以把 conc1f （[示例代码 12.2]）定义成：

(defmacro conc1f (lst obj)
  '(_f nconc ,lst (list ,obj)))

[示例代码 12.3] 中还有其他一些有用的宏，它们同样基于 setf。下一个是 pull ，它是内置的 pushnew 的逆操作。

这对操作符，就像是给 push 和 pop 赋予了一定的鉴别能力。如果给定的新元素不是列表的成员，pushnew 就把它加入到这个列表里面，而 pull 则是破坏性地从列表里删除给定的元素。pull 定义中的 &rest 参数使 pull 可以接受和 delete 相同的关键字参数：

> (setq x '(1 2 (a b) 3))
(1 2 (A B) 3)
> (pull 2 x)
(1 (A B) 3)
> (pull '(a b) x :test #'equal)
(1 3)
> x
(1 3)

你几乎可以把这个宏当成这样定义的：

(defmacro pull (obj seq &rest args) ; wrong
  '(setf ,seq (delete ,obj ,seq ,@args)))

不过，如果它真的这样定义，它将同时碰到求值顺序和求值次数方面的问题。我们也可以把 pull 定义成简单的修改宏：

(define-modify-macro pull (obj &rest args)
  (lambda (seq obj &rest args)
    (apply #'delete obj seq args)))

但由于修改宏必须将广义变量作为第一个参数，所以我们只得以相反的次序给出前两个参数，这样显得有些不自然。

更通用的 pull-if 接受一个初始的函数参数，并且会展开成 delete-if 而非 delete ：

> (let ((lst '(1 2 3 4 5 6)))
  (pull-if #'oddp lst)
  lst)
(2 4 6)

这两个宏说明了另一个有普遍意义的要点。如果下层函数接受可选参数，建立在其上的宏也应该这样做。

pull 和 pull-if 都把可选参数传给了它们的 delete 。

[示例代码 12.3] 中最后一个宏是 popn ，它是 pop 的推广形式。其功能不再是仅仅从列表里弹出一个元素，而是能弹出并返回任意长度的子序列：

> (setq x '(a b c d e f))
(A B C D E F)
> (popn 3 x)
(A B C)
> x
(D E F)

[示例代码 12.4] 中的宏能对它的参数排序。如果 x 和 y 是变量，而且我们想要确保x 的值不是两个值中较小的那个，那么我们可以写：

(if (> y x) (rotatef x y))

但如果我们想对三个或者数量更多的变量做这个操作，所需的代码量就会迅速膨胀。与其手工编写这样的代码，不妨让 sortf 来为我们代劳。这个宏接受一个比较操作符，还有任意数量的广义变量，然后不断交换它们的值，直到这些广义变量的顺序符合操作符的要求。在最简单的情形，参数可以是普通变量：

[示例代码 12.4] 一个排序其参数的宏

(defmacro sortf (op &rest places)
  (let* ((meths (mapcar #'(lambda (p)
            (multiple-value-list
              (get-setf-expansion p)))
          places))
      (temps (apply #'append (mapcar #'third meths))))
    '(let* ,(mapcar #'list
        (mapcan #'(lambda (m)
            (append (first m)
              (third m)))
          meths)
        (mapcan #'(lambda (m)
            (append (second m)
              (list (fifth m))))
          meths))
      ,@(mapcon #'(lambda (rest)
          (mapcar
            #'(lambda (arg)
              '(unless (,op ,(car rest) ,arg)
                (rotated ,(car rest) ,arg)))
            (cdr rest)))
        temps)
      ,@(mapcar #'fourth meths))))

> (setq x 1 y 2 z 3)
3
> (sortf > x y z)
3
> (list x y z)
(3 2 1)

一般情况下，它们可以是任何可逆的表达式。假设 cake 是一个可逆函数，它能返回某人的蛋糕，而 bigger 是个针对蛋糕的比较函数。如果我们想要推行一个规定，要求 moe 的 cake 不得小于 larry 的 cake ，而后者的 cake 也不得小于 curly 的，我们写成：

(sortf bigger (cake 'moe) (cake 'larry) (cake 'curly))

sortf 的定义的大致结构和 _f 差不多。它以一个 let* 开始，在这个 let* 表达式中，由 get-setf-expansion 返回的临时变量被绑定到广义变量的初始值上。sortf 的核心是中间的 mapcon 表达式，该表达式生成的代码将被用来对这些临时变量进行排序。宏的这部分生成的代码量会随着参数个数以指数速度增长。在排序之后，广义变量会被用那些由 get-setf-expansion 返回的 form 重新赋值。这里使用的算法是 的冒泡排序，但如果调用的时候参数非常多的话，这个宏就不适用了。

[示例代码 12.5] 给出的是对 sortf 调用的展开式。在最前面的 let* 中，参数和它们的 subform 按照从左到右的顺序小心地求值。之后出现的三个表达式分别比较几个临时变量的值，有可能还会交换它们：先是比较第一个和第二个，接着是第一个和第三个，然后第二个和第三个。最后广义变量从左到右被重新赋值。尽管很少需要注意这个问题，但还是提一下：通常，宏参数应该按从左到右的顺序进行赋值，这和它们求值的顺序是一致的。

有些操作符，如 _f 和 sortf ，它们与接受函数型参数的函数之间确实有相似之处。不过也应该认识到它们是完全不同的东西。类似 find-if 的函数接受一个函数并调用它；而类似 _f 的宏接受的则是一个名字，这些宏会让它成为一个表达式的 car。让 _f 和 sortf 都接受函数型参数也不无可能。例如，_f 可以这样实现：

(sortf > x (aref ar (incf i)) (car lst))

展开(在某个可能的实现里) 成：

[示例代码 12.5] 一个 sortf 调用的展开式

(let* ((#:g1 x)
    (#:g4 ar)
    (#:g3 (incf i))
    (#:g2 (aref #:g4 #:g3))
    (#:g6 lst)
    (#:g5 (car #:g6)))
  (unless (> #:g1 #:g2)
    (rotatef #:g1 #:g2))
  (unless (> #:g1 #:g5)
    (rotatef #:g1 #:g5))
  (unless (> #:g2 #:g5)
    (rotatef #:g2 #:g5))
  (setq x #:g1)
  (system:set-aref #:g2 #:g4 #:g3)
  (system:set-car #:g6 #:g5))

(defmacro _f (op place &rest args)
  (let ((g (gensym)))
    (multiple-value-bind (vars forms var set access)
      (get-setf-expansion place)
      '(let* ((,g ,op)
          ,@(mapcar #'list vars forms)
          (,(car var) (funcall ,g ,access ,@args)))
        ,set))))

然后调用 (_f #'+ x 1)。但是 _f 原来的版本不但拥有这个版本的所有功能，而且由于它处理的是名字，所以它还可以接受宏或者 special form 的名字。就像 + 那样，比如说，你还可以调用 nif （102页）：

> (let ((x 2))
  (_f nif x 'p 'z 'n)
  x)
P

12.5 定义逆

12.1 节说明了一个道理：如果一个宏调用能展开成可逆引用，那么它本身应该也是可逆的。不过，你也用不着只是为了可逆，就把操作符定义成宏。通过使用 defsetf ，你可以告诉 Lisp 如何对任意的函数或宏调用求逆。

使用这个宏的方法有两种。在最简单的情况下，它的参数是两个符号：

(defsetf symbol-value set)

如果用更复杂的方法，那么 defsetf 的调用和 defmacro 调用会有几分相似，它另外带有一个参数用于更新值 form。例如，下式可以为 car 定义一种可能的逆：

(defsetf car (lst) (new-car)
  '(progn (rplaca ,lst ,new-car)
    ,new-car))

defmacro 和 defsetf 之间有一个重要的区别：后者会自动为其参数创建生成符号(gensym)。通过上面给出的定义，(setf (car x) y) 将展开成：

(let* ((#:g2 x)
    (#:g1 y))
  (progn (rplaca #:g2 #:g1)
    #:g1))

这样，我们写 defsetf 展开器时就没有后顾之忧，不用担心诸如变量捕捉，或者求值的次数和顺序之类的问题了。

在 CLTL2 的 Common Lisp 中，也可以直接用 defun 定义 setf 的逆。因而前面的示例也可以写成：

(defun (setf car) (new-car lst)
  (rplaca lst new-car)
  new-car)

新的值应该作为这个函数的第一个参数。同样按照习惯，也应该把这个值作为函数的返回值。

目前为止的示例都认为，广义变量应该指向数据结构中的某个位置。不法之徒把人质带进地牢，而见义勇为之士则让她重见天日；他们移动的路径相同，但方向相反。所以，如果人们觉得 setf 的工作方式也只能是这样，那不足为奇，因为所有预定义的逆看上去都是如此；确实，习惯上，将被求逆的参数也常会使用 place 作为其参数名。

从理论上说，setf 可以更一般化：accessform 和它的逆的操作对象甚至可以不是同种数据结构。假设在某个应用里，我们想要把数据库的更新缓存起来。这可能是迫不得已的，举例来说，倘若每次修改数据，都即时完成真正的更新操作，就有可能会降低效率，或者，如果要求所有的更新都必须在提交之前验证一致性，那就必须引入缓存的机制。

[示例代码 12.6] 一个非对称的逆转换

(defvar *cache* (make-hash-table))

(defun retrieve (key)
  (multiple-value-bind (x y) (gethash key *cache*)
    (if y
      (values x y)
      (cdr (assoc key *world*)))))

(defsetf retrieve (key) (val)
  '(setf (gethash ,key *cache*) ,val))

假设 \*world\* 是实际的数据库。为简单起见，我们将它做成一个元素为 (key . val) 形式的关联表（assoc-list）。[示例代码 12.6] 显示了一个称为 retrieve 的查询函数。如果 \*world\* 是:

((a . 2) (b . 16) (c . 50) (d . 20) (f . 12))

那么:

> (retrieve 'c)
50

和 car 的调用不同，retrieve 调用并不指向一个数据结构中的特定位置。返回值可能来自两个位置里的

一个。而 retrieve 的逆，同样定义在 [示例代码 12.6] 中，仅指向它们中的一个：

> (setf (retrieve 'n) 77)
77
> (retrieve 'n)
77
T

该查询返回第二个值 t ，以表明在缓存中找到了答案。

就像宏一样，广义变量是一种威力非凡的抽象机制。这里肯定还有更多的东西有待发掘。当然，有的用户很可能已经发现了一些使用广义变量的方法，使用这些方法能得到更优雅和强大的程序。但也不排除以全新的方式使用 setf 逆的可能性，或者发现其它类似的有用的变换技术。

备注：

【注1】这个定义是错误的，下一节将给出解释。

【注2】一般意义上的函数名：1+ 或者 (lambda (x) (+ x 1)) 都可以。

【注3】译者注：现行 Common Lisp 标准 (CLHS) 事实上要求 define-modify-macro 和 define-compiler-macro 的第三个参数的类型必须是符号。

【注4】译者注：这里根据现行 Common Lisp 标准对源代码加以修改，我们额外定义了两个辅助函数以确保 define-modify-macro 的第三个参数只能是符号。

【注5】译者注：当作为 nconc 第一个参数的变量为空列表，也就是 nil 时，该变量在 nconc 执行之后将仍是 nil ，而不是整个 nconc 表达式的那个相当于其第二个参数的值。

【注6】译者注：正如前面两个脚注里提到的那样，Common Lisp 标准并没有定义 define-modify-macro 的第三个参数可以是符号之外的其他东西，尽管λ表达式出现在一个函数调用形式的函数位置上确实是合法的。原书作者试图通过类比来说明 λ表达式用在 define-modify-macro 中的合法性，这是不恰当的，请读者注意。

【注7】译者注：原书中给出的函数实际上是 get-setf-method ，但这个函数已经不在现行 Common Lisp 标准中了，参见 X3J13 Issue 308：SETF-METHOD-VS-SETF-METHOD 取代它的是 get-setf-expansion ，这个函数接受两个参数，place 以及可选的 environment 环境参数。本书后面对于所有采用 get-setf-method 的地方一律直接改用 get-setf-expansion ，不再另行说明。

【注8】第三个值当前总是一个单元素列表。它被返回成一个列表来提供（目前为止还不可能）在广义变量中保存多值的可能性。

【注9】然而，内置函数是个例外，它们不应该以这种方式被记忆化。Common Lisp 禁止重定义内置函数。