第三章 Lisp编程
上一章我们使用了一些内建的Lisp函数和Lisp-Stat函数来运行一些有趣的运算。我们构建的表达式中的一些还是相当复杂的。当你发觉自己多次键入相同的表达式的时候（当然你使用的数据可能略微有些不同），你自然就想为这个表达式引入一些速记符，也就是说你想要定义自己的函数了。函数定义是Lisp编程的基础操作。第2.7节已经对这个主题给出了一个简单的介绍，现在是深入探索的时候了。在对如何定义一个Lisp函数进行一个简略的复习之后，我们将检验一些需要的技术以开发功能更强大的函数：状态求值、递归和迭代、局部变量、函数式数据、映射和赋值。
除了介绍定义函数的工具，本章也展示了一些Lisp编程常用编程技术和原则。尤其地，对于本章的大多数情况我都会使用函数式风格直至本章结束，目的是避免使用赋值方式改变变量的值（注：这里提到的原则也是函数式的目的之一，即函数可以使用外部变量，但在函数的整个执行过程中不对变量进行写操作，不破坏外部变量，这样的函数要非破坏性函数，反之叫破坏性函数，在《Practical Common Lisp》和《On Lisp》里你将接触大量的非破坏性函数和他们的破坏性版本，都有其各自的书写约定）。本章的开发严重依赖Abelson和Sussman的《Scheme:计算机程序结构与解释》的前两章。为了允许我们集中精力到编程过程本身，本章只使用我们见过的基本类型数据：数值型、字符串型和列表型。Lisp和Lisp-Stat提供了若干额外的数据类型和用来操作这些数据类型的函数，这些可以在自定义函数里当做组件。下一章我将介绍一些这样的函数。
3.1 编写简单的函数
Lisp函数需要使用特殊形式defun来定义。defun的基础语法是(defun <name> <parameters> <body>)，这里的<name>是用来引用该函数的符号（即函数名），<parameters>是用来命名函数形参的符号列表，<body>即由一个或多个表达式组成。当调用函数的时候，<body>里的表达式将按次序求值，最后一个表达式的求值结果将作为函数的返回值。当前我们不会使用函数体里超过一个表达式的函数。defun的参数都不需要使用引号，因为defun不对参数求值。
举个例子，这里有个函数，功能是计算一个数据集的平方和，我们可以对一个数值列表使用这个函数，就像第二章里使用的那些函数一样：
> (defun sum-of-squares (x)
(sum (* x x)))
SUM-OF-SQUARES
> (sum-of-squares (list 1 2 3))
14也可以定义一个带多个参数的函数，例如，计算内积的函数可以定义成这样：
> (defun my-inner-product (x y) (sum (* x y)))
MY-INNER-PRODUCT使用defun定义的函数也可以用来定义其它函数，例如，使用sum-of-squares函数，我们可以定义一个计算两个数据列表欧几里德距离的函数：
> (defun distance (x y)
(sqrt (sum-of-squres (- x y))))
DISTANCE 
为了编写这个函数，我们需要一些谓词来比较数字和0，还需要一个条件求值结构来对不同的表达式求值，这些表达式是根据谓词范围的结果得到的。
3.2 谓词和逻辑表达式
谓词就是函数用来确定一个条件是真是假的词项，谓词对假条件返回nil，有时也返回non-nil，对于真条件，一般返回t。为了比较数值，我们可以使用谓词'＜'、'＞'、'＝'和其它比较谓词。这些谓词都要带两个货更多参数。谓词'＜'的参数以升序排列，则返回真：
> (< 1 2)
T
> (< 2 1)
NIL
> (< 1 2 3)
T
> (< 1 3 2)
NIL> (= 1 2)
NIL
> (= 1 1)
T
> (= 1 1 1)
T使用特殊形式and和or，还有函数not，可以在这些简单的谓词基础上构建更复杂的谓词。例如，我们可以定义一个函数来测试一个数字是否在区间(3, 5]内：
> (defun in-range (x)
(and (< 3 x) (<= x 5)))
IN-RANGE为了测试一个参数是否不再区间(3, 5]内，我们可以使用特殊形式or：
> (defun not-in-range (x) (or (>= 3 x) (> x 5)))
NOT-IN-RANGE定义not-in-range的另一种方式是使用in-range函数与not函数的联合：
> (defun not-in-range (x) (or (>= 3 x) (> x 5)))
NOT-IN-RANGE略。
3.3 条件求值
最基本的Lisp条件求值结构是cond。使用cond和比较谓词刚才已经介绍过了，我们可以定义一个函数来计算一个数值的绝对值：
> (defun my-abs (x)
(cond ((> x 0) x)
((= x 0) 0)
((< x 0) (- x))))
MY-ABS(cond (<p 1> <e 1>)
(<p 2> <e 2>)
...
(<p n> <e n>))
类似列表(<p 1> <e 1>)的形式叫做条件语句。每个条件语句的第一个表达式，比如<p 1>,... ,<p n>是谓词表达式，当真的时候求值为非nil，当假的时候求值为nil。cond一次只运行一条语句，它求值表达式直到一个表达式为真。如果其中的一个谓词为真，比如说就是<p i>，那么它对应的序列表达式<e i>将被求值，它的结果作为cond表达式的结果。如果没有一个谓词为真，则返回nil。
在my-abs函数的定义里，我为3个条件语句使用了完整的谓词表达式。因为最后一个条件语句是一个默认值，我可以使用符号t作为谓词表达式。my-abs函数应该看起来是这样的：
> (defun my-abs (x)
(cond ((> x 0) x)
((= x 0) 0)
(t (-x)))) MY-ABS条件语句可能有好几条结果表达式，这些表达式按顺序执行，最终的求值结果将被返回。最终的那个表达式之前的表达式只对它们产生的副作用是有用的。例如，我们可以使用print函数和terpri函数来修改my-abs函数的定义，这样可以打印一条消息以指示哪条条件语句被使用了。print函数发送一个西航给解释器，该消息后紧跟一个它自身参数表达式的打印体和一个空格；terpri函数向解释器发送一个新行。新的定义如下：
> (defun my-abs (x)
(cond ((> x 0) (print 'first-clause) (terpri) x)
((= x 0) (print 'second-clause) (terpri) 0)
((< x 0) (print 'third-clause) (terpri) (-x))))
MY-ABS> (my-abs 3)
FIRST-CLAUSE
3
> (my-abs -3)
THIRD-CLAUSE
3print函数的使用在这个特殊的例子里当然是愚蠢的，但是在一些复杂的函数里它可能会成为一个很有用的调试工具。
除了cond，Lisp还提供了一些其它的条件计算结构。它们中最重要的就是if。特殊形式if带3个表达式，一个谓词表达式，一个结果项，一个替代项。首先计算谓词表达式，如果为真，那么对结果项求值，结果项返回值作为if的返回值；否则，对替代表达式求值，并返回它的结果，如果没有提供这个可选的替代表达式，默认返回nil。使用if我们可以这么定义my-abs函数：
> (defun my-abs (x)
(if (> x 0)
x
(- x)))
MY-ABS练习 3.2
略。
3.4 迭代和递归
Lisp是一种递归语言，其结果，在这一点上我们已经有足够的工具编写函数来践行数值计算，这些数值计算在其它语言里是需要特殊的迭代结构的。Lisp确实已经提供了一些迭代工具，下面我们就会看到一些，但是首先检测在仅仅使用递归的情况下能在多大程度上完成任务这点上是很有用的。
举个例子，让我们看一个计算数字x的平方根的算法。这个算法以对√x的起始猜测值y开始，然后像下式一样计算一个持续改进的猜测值：
这个过程将重复进行，直到当前参测值的平方与x足够接近为止。例如，对于√3，其起始猜测值为1，我们将进行以下步骤：
该算法可以追溯到公元一世界，是牛顿法解方程根的一个特例。我们可以使用Lisp来表示这个算法，通过定义一个函数sqrt-iter，它带一个初始猜测值和数值x，然后计算近似平方根值：
> (defun sqrt-iter (guess x)
(if (good-enough-p guess x)
guess
(sqrt-iter (improve guess x) x)))
SQRT-ITER这个函数需要两个额外的函数，计算新猜测值的improve函数，还有测试当前值是否足够接近的good-enough-p函数。改进的函数可以简单地对上边给出的步骤编码，并定义为下边的样子：
> (defun improve (guess x)
(mean (list guess (/ x guess))))
IMPROVE> (defun good-enough-p (guess x)
(< (abs (- (* guess guess) x)) 0.001))
GOOD-ENOUGH-P使用sqrt-iter，我们可以定义一个平方根函数：
> (defun my-sqrt (x)
(sqrt-iter 1 x))
MY-SQRT> (my-sqrt 9)
3.00009155413138> (defun factorial (n)
(if (= n 1)
1
(* n (factorial (- n 1)))))
FACTORIAL与之相反，sqrt-iter函数产生的计算过程不需要持续追踪任何递延计算。所有的过程的状态信息都包含在一个单独的状态变量里，即当前的猜测值这一变量。可以用确定数目的状态变量来描述的计算过程叫做可迭代过程。
定义factorial函数的一个可迭代版本也是可能的。为了达到这一目的，我们能使用一个counter变量和一个product变量作为状态变量。每一步骤product变量都会与counter变量相乘，counter变量递增，直到counter变量大于n为止：
> (defun fact-iter (product counter n)
(if (> counter n)
product
(fact-iter (* counter product) (+ counter 1) n)))
FACT-ITER> (defun factorial (n)
(fact-iter 1 1 n))
FACTORIAL(do ((<name 1> <initial 1> <update 1>)
...
(<name n> <initial n> <update n>))
(<test> <result>))
有两个参数：一个三元列表，后边还跟着一个列表，这个列表由一个终止测试表达式和一个结果表达式组成。三元表达式的每一项都由三部分组成，一个状态变量名，一个初始化表达式和一个更新表达式。do从对一个初始表达式求值开始，然后将表达式的值与状态变量绑定；接下来使用迭代变量对终止表达式求值，如果终止表达式的结果为真，结果对表达式求值并作为结果返回，否则，计算更新表达式，变量将与其新值绑定，计算终止测试，等等。
使用do我们可以如此编写my-sqrt函数：
> (defun my-sqrt (x)
(do ((guess 1 (improve guess x)))
((good-enough-p guess x) guess)))
MY-SQRT> (defun factorial (n)
(do ((counter 1 (+ 1 counter))
(product 1 (* counter product)))
((> counter n) product)))
FACTORIALdo结构是非常强大的，但是它也是有一点恐怖的。对于使用sqrt-iter或者fact-iter函数的辅助函数来说，do可以很容易地想出一个简单的替代函数。重要的一点是，这里的初始化表达式和更新表达式是并行计算的，不是串行的。结果，三元结构元素的顺序如何指定是没有关系的。这与给一个没有调用的辅助函数传递参数的方式是类似的，函数调用之前，它的参数顺序是无所谓的。
练习 3.3
略。
练习 3.4
略。
3.5 环境
使用def和defun定义的变量和函数是全局变量和全局函数，一旦有变量或函数被定义，它们将持续存在直到它们被重新定义、取消定义，或者你结束了与解释器的会话。我们已经见过变量其它类型了：一个函数的参数在函数体里被用作局部变量。Lisp提供了一些其它的方法来构造局部变量，也允许你构造自己的局部函数。为了能够有效地使用这些方法，我们需要介绍一些新的想法和术语。
3.5.1 一些术语
让我们从一个很简单的例子开始。假设我们有一个全局变量是这么定义的：
> (def x 1)
X> (defun f (x)
(+ x 1))
F> (f 2)
3下载，让我们做一点儿改变。定义另一个全局变量a：
> (def a 10)> (defun f (x) (+ x a))> (f 2)
12但是假设函数f从函数内部调用，例如，定义函数g：
> (defun g (a) (f 2))Common Lisp使用静态作用域规则，所以：
> (g 20)
12练习 3.5
略。
3.5.2 局部变量
定义函数是设置局部环境的一个方法，该环境用来计算一个表达式集合，也就是函数体。另一个方法就是使用特殊形式let，这在上边的第2.7节简单介绍过。let表达式的一般语法是：
(let ((<var 1> <e 1>)
...
(<var n> <e n>))
<body>)
当let表达式求值的时候，值表达式<e 1>, ..., <e n>首先求值。然后一个let环境被设置成功，该环境包围了let表达式的环境组成，变量<var 1>, ..., <var n>与表达式的结果<e 1>, ..., <e n>是绑定的。最后，<body>里的表达式在这个新环境里被求值，旧的环境被保存起来。let表达式返回的结果就是<body>里最后一个表达式的求值结果。
特殊形式let在设置局部变量来简化表达式方面是非常重要的。举个简单的例子，假设我们想要定义一个函数，它带两个参数，呈现为实向量形式，然后返回其中一个向量在另一个向量上的投影。如果<x, y>表示代表x和y的内积，那么y在x上的投影可以如此给定：<x, y>/<x, x> *x。为了计算这个投影，我们可以这样定义投影函数：
> (defun project (y x)
(* (/ (sum (* x y)) (sum (* x x))) x))
PROJECT
> (project '(1 3) '(1 1))
(2 2)
> (defun project (y x)
(let ((ip-xy (sum (* x y)))
(ip-xx (sum (* x x))))
(* (/ ip-xy ip-xx) x))) PROJECT 关于let的一个重点是，它构造的绑定是并行的。新的局部变量的值相对的表达式在包围他们的环境中被计算，然后再设置绑定，为了说明这一点，让我们看一个简单的，人造的例子：
> (defun f (x)
(let ((x (/ x 2))
(y (+ x 1)))
(* x y)))
F> (f 4)
10在序列化地设置局部变量的时候有时是有用的，即首先定义一个变量，然后在第一个变量后定义第二个变量。在project函数的定义里，我们可能想要定义一个变量来表示x的系数，比如以内积变量的论。由于let绑定的并行分配，这些可以使用一个单独的let表达式完成，但是这可能需要使用连个小括号：
> (defun project (y x)
(let ((ip-xy (sum (* x y)))
(ip-xx (sum (* x x))))
(let ((coef (/ ip-xy ip-xx)))
(* coef x))))> (defun project (y x)
(let* ((ip-xy (sum (* x y)))
(ip-xx (sum (* x x)))
(coef (/ ip-xy ip-xx)))
(* coef x)))
PROJECT> (defun f (x)
(let* ((x (/ x 2))
(y (+ x 1)))
(* x y)))
F> (f 4)
63.5.3 局部函数
除了变量绑定之外，环境也包含函数绑定。目前为止，我们已经通过使用defun来定义全局函数绑定。特殊形式flet可以用来建立局部函数定义，该定义仅在flet表达式内部是可见的。它允许你以辅助函数的形式定义一个函数，而不需要担心与其它全局函数的命名冲突。
flet表达式的一般形式如下：
(flet ((<name 1> <parameters 1> <body 1>)
...
(<name n> <parameters n> <body n>))
<body>)
符号<name 1>, ..., <name n>是局部函数的名字，列表<parameters 1>, ..., <parameters n>是参数列表，<body 1>, ..., <body n>是组成函数体的表达式或表达式序列。
举个例子，我们可以使用另一种方式编写我们的project函数。不使用局部变量表示内积，而使用一个叫ip的局部内积函数来表示：
> (defun project (y x)
(flet ((ip (x y) (sum (* x y))))
(* (/ (ip x y) (ip x x)) x)))
PROJECT> (defun project (y x)
(flet ((ip (x y) (sum (* x y))))
(flet ((coef (x y) (/ (ip x y) (ip x x))))
(* (coef x y) x))))
PROJECT> (defun project (y x)
(labels ((ip (x y) (sum (* x y)))
(coef (x y) (/ (ip x y) (ip x x))))
(* (coef x y) x)))
PROJECT3.6 作为数据的函数和表达式
Lisp最强大的能力就是能将函数作为数据，来构建新的自定义函数。本节介绍一些利用这项能力的函数和技术。
3.6.1 匿名函数
在第2.7节，我们绘制了函数f(x)=2x+x²在区间[-2, 3]上的图形，我们首先定义了函数f：
> (defun f (x) (+ (* 2 x) (^ x 2)))
F一旦我们绘制出图形，我们就不再使用函数f了。如果我们能避免正式地定义函数和必须为它想个名字的话，似乎是件极好的事儿。相同的问题在数学里也存在：为了描述我要绘制的函数曲线，我引入了"函数f(x)=2x+x²"。为了解决这个问题，逻辑学家开发了lambda演算，允许你使用如下表达式： λ(x)(2x+x²)来引用“对于参数x的返回值为2x+x²的函数”这一表述。Lisp也采用了这一方法，允许函数描述成lambda表达式，一个由符号lambda组成的列表，一个参数列表，和组成函数体的一个或多个表达式。我们这个函数的lambda表达式形式如下：
> (lambda (x) (+ (* 2 x) (^ x 2)))
#<Closure: #142d008>lambda表达式可以用来替换符号，作为传给解释器的表达式的第一个元素：
> ((lambda (x) (+ (* 2 x) (^ x 2))) 1)
3> (plot-function #'(lambda (x) (+ (* 2 x) (^ x 2))) -2 3)
#<Object: 1429688, prototype = SCATTERPLOT-PROTO>3.6.2 使用函数参数
假设我们想要近似一个积分值：
一个方法就是使用第3.4节介绍的do结构，来定义一个积分函数：
> (defun integral (a b h)
(do ((itegral 0 (+ integral (* h (f x))))
(x (+ a (/ h 2)) (+ x h)))
((> x b) integral)))
INTEGRAL> (defun f (x) (^ x 2))
F> (integral 0 1 .01)
0.333325> (defun integral (f a b h)
(do ((integral 0 (+ integral (* h (f x))))
(x (+ a (/ h 2)) (+ x h)))
((> x b) integral)))
INTEGRAL> (integral #'(lambda (x) (^ x 2)) 0 1 .01)
0.3333250000000004相反地，我们可以使用funcall函数，这个函数带一个函数参数，还有很多该函数参数需要的参数，并将该函数参数作用到这些参数上。这里有个例子:
> (funcall #'(lambda (x) (^ x 2)) 2)
4
> (funcall #'+ 1 2)
3> (defun integral (f a b h)
(do ((integral 0 (+ integral (* h (funcall f x))))
(x (+ a (/ h 2)) (+ x h)))
((> x b) integral)))
INTEGRAL> (integral #'(lambda (x) (^ x 2)) 0 1 0.01)
0.3333250000000004> (apply #'+ (list 1 2))
3
> (apply #'+ (list 1 2 3))
6> (apply #'+ 1 2 (list 3 4 5))
15使用函数funcall和apply有一些限制。它们仅能通过传递函数参数来使用，而不能通过特殊形式和宏。此外，大多数Lisp系统设置了可以传递给函数的参数的数量上限。尽管在一些系统里这个限值可能很大，Common Lisp规范要求这个限值至少是50。这意味着这不是一个好主意，比如说，定义一个计算列表里元素的和的函数：
> (defun my-sum (x) (apply #'+ x))练习 3.6
略。
3.6.3 作为结果的返回函数
现在我们已经见过如何使用函数参数，我们返回到函数闭包的使用上。在3.5节我们定义了一个函数project来计算y在x上的投影。思考数学投影问题的另一个方法是以投影操作符的形式思考，该操作符接受任意矢量y并将其放到关于x的投影上去。我们将用Px表示这个操作符，或者简写为P，并将y在x上的投影表示为Py。该操作符被视为一个单参数函数。被投影到的那个空间，被x跨越的空间，以某种方式“内建”到P里。在Lisp里我们可以使用函数闭包构建这个投影操作符的模型。首先，我么构建一个函数make-projection，它带一个表示数学矢量的列表x，并返回一个函数闭包，该闭包计算参数在x上的投影：
> (defun make-projection (x)
(flet ((ip (x y) (sum (* x y))))
#'(lambda (y) (* x (/ (ip x y) (ip x x))))))
MAKE-PROJECTION> (def p (make-projection '(1 1 1 1)))
P> (funcall p '(1 2 3 4))
(2.5 2.5 2.5 2.5)
> (funcall p '(-1 1 1 -1))
(0 0 0 0)> (defun make-projection (x)
(labels ((ip (x y) (sum (* x y)))
(proj (y) (* x (/ (ip x y) (ip x x)))))
#'proj))
MAKE-PROJECTION略。
练习 3.8
略。
3.6.4 作为数据的表达式
代替使用函数参数，有时使用表达式更加方便。一个作何的Lisp表达式只不过是一个Lisp列表。它的元素可以使用select函数或者函数first、second, ..., tenth来提取：
> (def expr '(+ 2 3))
EXPR
> (first expr)
+
> (second expr)
2> (rest expr)
(2 3)> (eval expr)
5> (def x 3)
X
> (let ((x 5)) (eval 'x))
3> (def expr2 '(+ x 3))
EXPR2
> (eval (subst 2 'x expr2))
5> (subst 2 'x '(let ((x 3)) x))
(LET ((2 3)) 2)> (list 'let '((x 2)) expr2)
(LET ((X 2)) (+ X 3))
> (eval (list 'let '((x 2)) expr2))
5> `(let ((x 2)) ,expr2)
(LET ((X 2)) (+ X 3))
> (eval `(let ((x 2)) ,expr2))
5> `(let ((x ,(- 3 1))) ,expr2)
(LET ((X 2)) (+ X 3))> (defun plot-expr (expr var low high)
(flet ((f (x) (eval `(let ((,var ,x)) ,expr))))
(plot-function #'f low high)))
PLOT-EXPR3.7 映射
能够一个函数对一个列表按元素进行操作经常是非常有用的。这个处理过程叫做映射，mapcar函数可以带一个函数和一个参数列表，并且返回结果列表，该结果是函数作用到每个元素时产生的：
> (def x (mapcar #'normal-rand '(2 3 2)))
X
> x
((0.374662664815698 2.2129702160457247) (-0.6790406077067712 -1.5090307911933598 -0.7422588556111767) (0.2212920384039958 0.5462770527223718))
> (mapcar #'mean x)
(1.2938164404307113 -0.9767767515037692 0.3837845455631838)> (mapcar #'+ '(1 2 3) '(4 5 6))
(5 7 9)另一个在Lisp-Stat里可用的映射函数是map-elements。这个函数将使用组合数据和简单数据的Lisp-Stat区别。组合数据是列表、矢量、数组和组合数据对象（这个一会儿介绍）。不是组合数据的数据项将被看做是简单数据。预测函数compound-data-p可以测试一个数据是否是组合数据。
函数map-elements允许你在参数上映射一个函数，该参数可能是简单数据和组合数据的组合。如果任何一个参数是组合数据，那么任何简单数据都将被作为合适大小的常量看待。例如：
> (map-elements #'+ 1 '(1 2 3) '(4 5 6))
(6 8 10)> (defun vec+ (x y)
(if (or (compound-data-p x) (compound-data-p y))
(map-elements #'vec+ x y)
(+ x y)))
VEC+> (vec+ 1 2)
3
> (vec+ 1 '(2 3))
(3 4)
> (vec+ '(1 2) '(3 4))
(4 6)
> (vec+ '(1 2) '(3 (4 5)))
(4 (6 7))> (vec+ '(1 2) '(3 4 5))
Error: arguments not all the same length
Happened in: #<Subr-MAP-ELEMENTS: #13ef154>你不需要经常使用map-elements函数来定义你自己的矢量化函数，除非你需要条件计算。例如，假设你想要定义一个这样的矢量化版本：
Lisp-Stat提供了一个if-else函数，这样调用它：(if-else <x> <y> <z>)，如果<x>, <y>和<z>是相同长度的列表，if-else函数返回一个同长度的列表。结果的第i个元素，或者是<y>的第i个元素，或者是<z>的第i个元素，这取决于<x>的第i个原始是non-nil还是nil。编写我们函数的简单的方法就是使用if-else：
> (defun f (x) (if-else (> x 0) (log x) 0))
F> (defun f ()
(if (compound-data-p x)
(map-elements #'f x)
(if (> x 0) (log x)0)))
F略。
3.8 赋值和破坏性修改
在像FORTRAN和C这类编程语言里，赋值语句是编程的最基本元素。例如，在下边的factorial函数的C定义里，赋值语句用来更新局部变量prod，它是累计结果的关键一步：
int factorial（n）
{
int count；
int prod = 1；
for （count=0; count<n; count=count +1）
prod=prod * (coung + 1);
return prod;
}这里我们不能对这段程序翻译成Lisp。我们可以设置局部变量，像prod，来给它赋一个新值，但是我们没有办法改变它们的值。也许更重要的是，我们没有赋值机制的需要。
目前为止，本章中我所完成的每一件事都是用函数式的或者可用的编程风格来完成的。更复杂的函数已经
以简单函数组合的形式构建出来了的。局部变量仅仅被定义用来简化表达式。当我们替换了在let表达式里创建的局部变量的时候，我们的函数的意思不应该改变，例如，即使函数定义因此变模糊了，其意义也不应改变。相对地，针对factorial的C程序使用了局部变量prod作为存储位置。使用它的初始值1代替每一个位置的prod变量都会产生废话。
使用局部变量来定义，而不通过赋值的方式改变它的值，这种编程风格叫做引用透明。事实上，无论什么时候可能，使用这种风格都有很好的理由。简而言之，一个程序使用赋值符是正确的，不使用就是不正确的，这句话很难通过构建一个数学证明来验证。Abelson和Sussman详尽地讨论了这个问题。
然而，赋值操作确实有一些重要的应用。例如，我们可能想在计算机屏幕上构建一个窗体的软件表示。窗体可能又各种各样的属性，像它的尺寸和位置，这些可以记录成本地状态变量。作为一个带窗体的用户接口，它可以移动和调整尺寸，为了保持一直是最新的表示法，我们需要能够改变这些状态变量，给他们赋新值。
在Lisp里，基本的赋值工具是特殊形式setf。setf可以改变全局变量和局部变量的值。例如，
> (setf x 3)
3
> x
3> (let ((x 1))
(setf x 2)
x)
2 一个问题的例子是随机数字生成器，在这个问题里我们需要能够修改一个状态变量。一个线性同余生成器需要由一个种子X0，一个乘法器A和一个系数M来制定，这些都是正整数。它根据规则：
来计算伪随机整数序列X1, X2,...。一个近似正态的伪随机序列U1, U2, ...,这样产生：Ui=Xi/M。
通过使用包含乘法器、系数和当前X值的函数闭包，我们能够实现这样一个生成器。X的当前值是状态变量，每次它都会更新成获得的新的数字。函数make-generator构建了这样一个闭包：
> (defun make-generator (a m x0)
(let ((x x0))
#'(lambda ()
(setf x (rem (* a x) m))
(/ x m))))
MAKE-GENERATOR函数rem计算第一个参数被第二个参数除后的余数。该定义中lambda表达式体包含两个表达式，第一个是个赋值表达式，用来产生局部变量x的变化的值得副作用（注：这里的副作用是针对函数式风格说的！！！）。第二个表达式在生成器被使用时返回结果。这个lambda表达式没有带参数。
通过使用A=7的五次方，系数M=2的31次方-1，种子为12345，我们能够构造和尝试一个特定的生成器：
(def g (make-generator (^ 7.0 5) (- (^ 2.0 31) 1) 12345))> (funcall g)
0.09661652850760917
> (funcall g)
0.8339946273872604
> (funcall g)
0.9477024976851895因为由make-generator返回的函数不需要任何参数，funcall函数除了生成器g之外不需要其它参数。环境里的局部状态变量x，闭包g就是在那个环境里创建的，每当g被调用的时候x更新。结果，每次对g的调用都会返回不同的值。赋值操作可以用来以程序的风格编写程序。例如，现在我们可以将本节开头的C版本的factorial函数，翻译成Lisp版本：
> (defun factorial (n)
(let ((prod 1))
(dotimes (count n)
(setf prod (* prod (+ count 1))))
prod))
FACTORIAL像我们在2.4.5节看到的，setf可以通过改变列表里元素的值来破坏性地修改一个列表。例如，如果x被构建成这样：
> (setf x (list 1 2 3))(setf (select x 1) 'a)值得我们再次关注的是，Lisp变量仅仅为数据项的名字，破坏性的修改可能带来不可预期的副作用。尤其地，如果x这样构建：(setf x '(1 2 3))，y这样定义：(setf y x)，那么修改x的值将修改y的值，因为这些符号只不过是它们引用的相同的Lisp数据项的两个不同的名字而已。
> (setf (select x 1) 'a)
A
> x
(1 A 3)
> (setf y x)
(1 A 3)
> y
(1 A 3)3.9 等价
当两个Lisp数据项被视为相同的时候，很多函数需要来确定这个判断。这就发生了一件微妙的事情，尤其在介绍了赋值之后。两个事物是否等价，依赖于使用它们完成了什么。字符串“fred”和“Fred”可能被看做是不同的，因为它们包含不同的字符串。它们可能被视为是相同的，因为它们都能拼出Fred这个名字。当你把一个符号的名字键入到Lisp解释器的时候，字母的大小写是被忽略的。对于这个目的，上边的两个字符串是相同的。如果使用这些字符的ASCII码来计算字符串的编码，你会对这两个字符串计算出两个不同的结果。对于这个目的，这两个字符串是不同的。
另一个例子，假设你有两个列表，都打印成这样： (A B)，它们是等价的吗？如果你仅仅是想提取它们的元素，那么这两个字符串后返回相同的结果，因此它们可能被看做相同。换句话说，随着setf的引入，我们可以物理地修改一个列表的内容。假设我们这么做了，那另一个列表也会受影响吗？这取决于它们是否处于相同的计算机内存位置。
为了解决这种情况，Lisp提供了4个不同严格等级的等价谓词。最严格的的是eq。当且仅当它们处于内存的相同位置的时候，它们才是eq的。这是我们想要的测试，用来确保在修改它们中的一个之前我们的两个列表是真的不同。
当解释器将一个字符串翻译成一个符号时，可以保证的是相同名字的两个符号是eq的。
一个密切相关的谓词是eql。eq与eql之间唯一的不同是eql将考虑以下几项指标，相同类型和值的数量，有相同值和大小写情况的字符，在相同的大小写情况下的有相同字符的字符串。依据Lisp实现，它们可能是eq的也可能不是eq的。如此，对一些Lisp实现，(eq 1 1)可能返回t，而对另一些则返回nil，但是(eql 1 1)始终返回t，换句话说，
> (eq (list 'a 'b) (list 'a 'b))
NIL
> (eql (list 'a 'b) (list 'a 'b))
NIL
> (eq 1 1.0)
NIL
> (eql 1 1.0)
NIL谓词equal和equalp用来确定两个数据项是否看起来很相似。如果(eql x y)返回t，或者x与y的程度相等所有元素也对应相等，那么表达式(equal x y)返回t。equalp谓词词性比equal略弱，如果两个数的数值是相等的，那么equalp就认为他们是equalp相等的，无论类型是否相同。如果两个字符串有相同的字符，无论大小写是否相同，它们是equalp相等的。那么：
> (equal (list 'a 'b) (list 'a 'b))
T
> (equalp (list 'a 'b) (list 'a 'b))
T
> (equalp 1 1.0)
T
> (equal 1 1.0)
NIL
> (equal "fred" "Fred")
NIL
> (equalp "fred" "Fred")
T3.10 一些例子
本章介绍了大量的新想法和技术。在继续深入之前，看一些更广泛的例子是很有帮助的，这些例子动用了这里表达的一些技术。第一个例子使用牛顿法求解一个函数的变量的平方根。第二个例子展示了一个构建表征区别的方法。
3.10.1 牛顿法求根
牛顿法求解可微函数f的根，该法带一个猜测值y，并这样计算一个改进的猜测值：y-f(y)/Df(y)，这里的Df表示f的导数。通过对如下形式的递归定义，基本的迭代可以沿着3.4节里的平方根的方法开发：
> (defun newton-search (f df guess)
(if (good-enough-p guess f df)
guess
(newton-search f df (improve guess f df))))
NEWTON-SEARCH> (defun newton-search (f df guess)
(do ((guess-guess (improve guess f df)))
((good-enough-p guess f df) guess)))
NEWTON-SEARCH> (defun improve (guess f df)
(- guess (/ (funcall f guess) (funcall df guess))))
IMPROVE
> (defun good-enoungh-p (guess f df)
(< (abc (funcall f guess)) 0.001))
GOOD-ENOUNGH-P> (newton-search #'sin #'cos 3)
3.14255> (defun newton-search (f df guess)
(flet ((improve (guess f df)
(- guess
(/ (funcall f guess)
(funcall df guess))))
(good-enough-p (guess f df)
(< (abs (funcall f guess)) .0.001)))
(do ((guess guess (improve guess f df)))
((good-enough-p guess f df) guess))))
NEWTON-SEARCH通过将improve和good-enough-p函数移动到newton-search函数里，我们可以进行一点简化。因为f和df在improve哈good-enough-p函数定义的那个环境里是可用的，所以我们不需要将它们作为参数传递：
> (defun newton-search (f df guess)
(flet ((improve (guess)
(- guess
(/ (funcall f guess)
(funcall df guess))))
(good-enough-p (guess)
(< (abs (funcall f guess)) .001)))
(do ((guess guess (improve guess)))
((good-enough-p guess) guess))))
NEWTON-SEARCH> (defun make-derivative (f h)
#'(lambda (x)
(let ((fx+ (funcall f (+ x h)))
(fx- (funcall f (- x h)))
(2h (* 2 h)))
(/ (- fx+ fx-) 2h))))
MAKE-DERIVATION> (newton-search #'sin (make-derivative #'sin .001) 3)
3.1425465668320545> (def x (gamma-rand 30 4.5))
X估计这个log似然度的函数可以这样构建：
> (def f (let ((s (sum (log x)))
(n (length x)))
#'(lambda (a)
(- (* (- a 1) s) (* n (log-gamma a))))))
F为了使用newton-search函数找到α的最大似然估计，我们需要对数似然函数的一阶导数和二阶导数。这些可以这样获取：
> (def df (make-derivative f .001))
DF
> (def ddf (make-derivative df .001))
DDF> (mean x)
4.683152258151905> (newton-search df ddf (mean x))
4.747512880561235略。
3.10.2 符号微分
符号微分化使用微分计算的规则来表达和产生表示导数的表达式。起初它看起来可能是令人吃惊的，但事实上自动地使用这些规则来开发程序是相当简单的。最难的那部分就是确定如何通过这样一个程序来表达使用的数据：被微分的表达式和表示导数的表达式。
为了保持简洁，让我们以微积分类可能的开始方式，通过考虑仅针对微分常量、变量、和还有乘积的规则，开始我们的讨论。
抽象表达式
微分函数使用的数据就是表达式。有很多不同的方式，这些方式不能用计算机来表达，但是表达式的细节与微分式要表现的基本任务几乎没有关系。为了反映这个事实，简要地想一想用来开发微分函数所需要的表达式的精确特征，还有用来捕获这些特征的函数集合，想清楚以上两点是非常重要的。这个函数集合叫做抽象数据表示法，它可以用来编写我们的微分函数。过会儿，我们能够用开发这个数据表示的不同的方式来进行试验。但是，通过将表达式的使用从他们的表示的内部细节中分离出来，我们将获得一个系统，该系统比数据表示与数据使用交织在一起的方法更容易理解和修改。这个编程策略叫做数据抽象。
在我们的函数式表达方法中，我们需要表示的表达式的基本特征是什么呢？首先，有四种数据类型：常量、变量、加法和乘积。我们需要能够识别一个特定的数据项是不是这四种数据类型中的一个。让我们做个假设：为这个目的我们可以定义四个谓词：
(constantp <e>)
(varialbep <e>)
(sump <e>)
(productp <e>)(same-variable-p <v1> <v2>)常量和变量时原子表达式，它们不能被分解或者由其它表达式构建。相反，加法和乘积是组合表达啥。因此我们需要“访问函数”来提取它们的各部分构件，需要构造函数来构建新的加法和乘积。加法的各部分构件是加数和被加数。假设我们可以用以下表达式获取：
(addend <e>)
(augend <e>)(make-sum <a1> <a2>)(multiplicand <e>)
(multiplier <e>)(make-product <m1> <m2>)> (defun deriv (exp var)
(cond
((constantp exp) 0)
((variablep exp) (if (same-variable-p exp var) 1 0))
((sump exp)
(make-sum (deriv (addend exp) var)
(deriv (augend exp) var)))
((productp exp)
(make-sum (make-product (multiplier exp)
(deriv (multiplicand exp) var))
(make-product (deriv (multiplier exp) var)
(multiplicand exp))))
(t (error "Can't differentiate this expression"))))函数deriv表示微积分课程里涵盖的前几个微分法则的简单的Lisp编码。例如，加法法则的Lisp编码为：
表达式如何实现的细节是不重要的，只要他们符合这里使用的函数式抽象的接口就可以了。在我们能使用这个函数之前，我们确实需要开发至少一个表示法用来表达。
一个用来表达的表示法
表示表达式有很多方法，但是最容易的方法就是使用标准Lisp语法，常量由数字表示，变量由符号表示。
让我们从定义加法规则和乘积规则的“读取函数”和“构造函数”。对于加法规则我们定义：
> (defun addend (e) (second e))
ADDEND
> (defun augend (e) (third e))
AUGEND
> (defun make-sum (a1 a2) (list '+ a1 a2))
MAKE-SUM对于乘积法则：
> (defun multiplier (e) (second e))
MULTIPLIER
> (defun multiplicand (e) (third e))
MULTIPLICAND
> (defun make-product (m1 m2) (list '* m1 m2))
MAKE-PRODUCT> (defun constantp (e) (numberp e))
CONSTANTP
> (defun variablep (e) (symbolp e))
VARIABLEP> (defun same-variable-p (v1 v2)
(and (variablep v1) (variablep v2) (eq v1 v2)))
SAME-VARIABLE-P对加法规则和乘积规则进行测试的谓词就稍微复杂一些了。我们需要检查一个数据项是否是三元素的列表，它们的开始元素是+或者*。那么对于加法规则有：
> (defun sump (e)
(and (listp e) (= (length e) 3) (eq (first e) '+)))
SUMP对于乘积规则有：
> (defun productp (e)
(and (listp e) (= (length e) 3) (eq (first e) '*)))
PRODUCTP现在我们可以用一些例子测试一下我们的导数函数：
> (deriv '(+ x 3) 'x)
(+ 1 0)
> (deriv '(* x y) 'x)
(+ (* X 0) (* 1 Y))
> (deriv '(* (* x y) (+ x 3)) 'x)
(+ (* (* X Y) (+ 1 0)) (* (+ (* X 0) (* 1 Y)) (+ X 3)))> (defun make-sum (a1 a2)
(cond
((and (numberp a1) (numberp a2)) (+ a1 a2))
((numberp a1) (if (= a1 0) a2 (list '+ a1 a2)))
((numberp a2) (if (= a2 0) a1 (list '+ a1 a2)))
(t (list '+ a1 a2))))
MAKE-SUM相似地，对于make-product函数，如果两个参数都是数字就返回他们的乘积，如果其中一个为零就返回零，如果其中一个为1，则返回另一个参数的数值：
> (defun make-product (m1 m2)
(cond
((and (numberp m1) (numberp m2)) (* m1 m2))
((numberp m1)
(cond ((= m1 0) 0)
((= m1 1) m2)
(t (list '* m1 m2))))
((numberp m2)
(cond ((= m2 0) 0)
((= m2 1) m1)
(t (list '* m1 m2))))
(t (list '* m1 m2))))
MAKE-PRODUCT现在结果更合理一些，尽管还不完美：
> (deriv '(+ x 3) 'x)
1
> (deriv '(* x y) 'x)
Y
> (deriv '(* (* x y) (+ x 3)) 'x)
(+ (* X Y) (* Y (+ X 3)))略。
加入一元函数
假设我们想要加入exp函数，不是为这个函数增加一个强制的规则来求得导数，而是最好增加一个表示链式规则的规则，然后在数据表示里，将这个特定的函数处理成微分形式。为了加入链式规则，我们需要一个谓词用以识别一个一元函数调用：
(unary-p <e>)我们也需要“读取函数”来确定函数名和函数的参数：
(unary-function <e>)
(unary-argument <e>)(make-unary-deriv <f> <x>)> (defun deriv (exp var)
(cond
((constantp exp) 0)
((variablep exp) (if (same-variable-p exp var) 1 0))
((sump exp)
(make-sum (deriv (addend exp) var)
(deriv (augend exp) var)))
((productp exp)
(make-sum (make-product (multiplier exp)
(deriv (multiplicand exp) var))
(make-product (deriv (multiplier exp) var)
(multiplicand exp))))
((unary-p exp)
(make-product (make-unary-deriv (unary-function exp)
(unary-argument exp))
(deriv (unary-argument exp) var)))
(t (error "Can't differentiate this expression"))))
DERIV> (defun make-unary-deriv (fcn ar)
(case fcn
(exp (make-unary 'exp arg))
(sin (make-unary 'cos arg))
(cos (make-product -1 (make-unary 'sin arg)))
(t (error "Can't differentiate this expression"))))
MAKE-UNARY-DERIV这里的case后带一个表达式，该表达是将计算出一个符号，叫做“case选择器”，它后边紧跟真一系列的case语句。每个case语句都以一个符号或符号列表开始，然后case将按流程处理每条语句直到选择器与其中一条语句里的符号匹配为止。当发现一个匹配之后，被匹配的语句的剩余的表达式将被求值，然后其最后一个表达式的结果将被返回。如果没有发现可匹配的符号，将返回nil。符号t比较特殊：它可以匹配任何选择器。
make-unary-deriv函数需要一个额外的构造器(make-unary <f> <x>)来构造一个一元函数构造表达式。
对于我们的表达式来说，谓词和读取函数都是比较容易定义的：
> (defun unary-p (e)
(and (listp e) (= (length e) 2)))
UNARY-P
> (defun unary-function (e) (first e))
UNARY-FUNCTION
> (defun unary-argument (e) (second e))
UNARY-ARGUMENT> (defun make-unary (fcn arg) (list fcn arg))
MAKE-UNARY> (deriv '(exp (* 3 x)) 'x)
(* (EXP (* 3 X)) 3)
> (deriv '(sin (* 3 x)) 'x)
(* (COS (* 3 X)) 3)这个方法的一个方面是不太令人满意的。就像你在用deriv函数一样，增加一些函数可能是你想要做的事情。现在，需要编辑make-unary-deriv函数。一个可以替代的办法就是设置一个导数数据库。让我们做一个假设，我们有一个包含处理一元函数的规则的数据库，这些规则可以使用函数get-unary-rule来查询得到。函数apply-unary-rule用来将一个规则作为参数，去产生一个通过对参数求值得到的导数表达式。我们可以这样编写make-unary-deriv函数：
> (defun make-unary-deriv (fcn arg)
(apply-unary-rule (get-unary-rule fcn) arg))
MAKE-UNARY-DERIV> (def *mylist* '((x 1) (y "hello") (abc a w (1 2 3))))
*MYLIST*
> (assoc 'x *mylist*)
(X 1)
> (assoc 'y *mylist*)
(Y "hello")
> (assoc 'abc *mylist*)
(ABC A W (1 2 3))
> (assoc 'z *mylist*)
NIL> (def *derivatives* nil)
*DERIVATIVES*> (cons 'a '(b c))
(A B C)> (defun add-unary-rule (f rule)
(setf *derivatives* (cons (list f rule) *derivatives*)))
ADD-UNARY-RULE> (defun get-unary-rule (f)
(let ((rule (assoc f *derivatives*)))
(if rule
rule
(error "Can't differentiate this expression"))))
GET-UNARY-RULE> (defun apply-unary-rule (entry arg)
(funcall (second entry) arg))> (add-unary-rule 'exp #'(lambda (x) (make-unary 'exp x)))
((EXP #<Closure: #13b0844>))
> (add-unary-rule 'sin #'(lambda (x) (make-unary 'cos x)))
((SIN #<Closure: #13b02a4>) (EXP #<Closure: #13b0844>))> (deriv '(exp x) 'x)
(EXP X)
> (deriv '(exp (* -1 (* x x))) 'x)
(* (EXP (* -1 (* X X))) (* -1 (+ X X)))
> (deriv '(sin (* 3 x)) 'x)
(* (COS (* 3 X)) 3)
> (deriv '(* (cos (* 3 x))) 'x)
Error: Can't differentiate this expression
Happened in: #<FSubr-IF: #1353650>> (add-unary-rule 'cos
#'(lambda (x)
(make-product -1 (make-unary 'sin x))))
((COS #<Closure: #13ba8b0>) (SIN #<Closure: #13aff74>) (SIN #<Closure: #13b02a4>) (EXP #<Closure: #13b0844>))
> (deriv (deriv '(sin (* 3 x)) 'x) 'x)
(* (* (* -1 (SIN (* 3 X))) 3) 3)练习 3.14
略。
来源：oschina
链接：https://my.oschina.net/u/1011760/blog/217645