第 12 章 广义变量

2018-02-24 15:54 更新

第 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 中所有最常用的访问函数都有预定义的逆,包括 carcdrntharefgetgethash,以及那些由 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 和 pushnewconc1f 在列表结尾追加一个元素,而 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 308SETF-METHOD-VS-SETF-METHOD 取代它的是get-setf-expansion ,这个函数接受两个参数,place 以及可选的 environment 环境参数。本书后面对于所有采用 get-setf-method 的地方一律直接改用 get-setf-expansion ,不再另行说明。

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

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

以上内容是否对您有帮助:
在线笔记
App下载
App下载

扫描二维码

下载编程狮App

公众号
微信公众号

编程狮公众号