第 12 章 广义变量
最后更新于：2022-04-01 02:45:23
## 第 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 禁止重定义内置函数。