第四章 其它Lisp特性
上一章介绍了Lisp编程的基础，在那章里重点展示了对编写Lisp函数有用的编程技术。为了最高效地使用这些技术，知道Lisp和Lisp-Stat提供的函数和数据类型将是很有用的。本章旨在给出这些函数和数据类型的概貌。初次阅读，你可以略读，当你需要的时候再将其作为参考手册来使用。
4.1 输入/输出
Common Lisp编程语言包含一个可扩展的工具集，可以用来读写文件、格式化输出和自定义读取输入的方式。这些特征的完整讨论将占用几章内容，因此我只展示那些我发现的对统计编程有用的方面。更多的可扩展话题可以到一些Common Lisp书籍中找到。
4.1.1 Lisp读取器
Lisp读取器负责转化类型化的字符，它通过用户或者从文件中读取的内容将数据输出到Lisp数据项。当读取一个数字时，读取器负责识别是整数或者浮点数，然后将它转换为合适的内部表示。在Common Lisp里，对浮点数据类型有一些选择，可以通过short-float、single-short、double-float和long-float等符号来指定。读取浮点数用到的数据类型，比如说读取2.0，由全局变量*read-default-float-format*控制，它的值是上边提到的四个数据类型中的一个。强制指定要解释的数字为双精度类型也是可能的，比如输入成2.d0。
读取器还负责以一个特殊的方式解释 一些字符，或者字符序列。这样一个字符序列和用来解释它的代码，叫做一个读取宏。我们已经使用过一些读取宏：引号字符"'"，反引号字符"`"，逗号字符","，和一对字符"#'"。为了理解他们是如何工作的，我们可以将包含这些读取宏的引号表达式输入到解释器，然后观察返回了什么：
> (quote 'x)
(QUOTE X)
> (quote `x)
(BACKQUOTE X)
> (quote ,x)
(COMMA X)
> (quote #'x)
(FUNCTION X)其它读取宏还有双引号字符"，他将读取紧跟着它的字符直到遇到下一个"为止，并将它们形成一个字符串，反斜线字符\，它是针对与接下来有关联的字符，用来转义任何特殊意思的字符。例如，一个反斜线可以用来产生一个包含双引号的字符串。下面我们将会遇到一些其它的读取宏。
定义自己的读取宏是可能的，通过这个方法，你可以自定义Lisp读取器来用你喜欢的语言语法来提供一个词法分析器。
4.1.2 基础打印函数
为了向标准输出流或者一个文件里打印数据，一些函数是可用的。最基本的函数是print、prin1、princ和terpri。print和prin都会打印它们的参数给一个form，这个form对Lisp读取器来说是可读的。如果可以的话，读取器应该能够读取由这些函数打印的东西。print和prin1之间的不同是print的输出的前边加了一个空行，后边跟了一个空格。princ和prin1相似，除了princ忽略了所有的转义字符。特别地，princ打印的字符串不带双引号。函数terpri输出一个新行。
为了展示这些函数，让我们看一下下边定义的函数printer：
> (defun printer ()
(print "Hello")
(print1 "this")
(princ " is a")
(print "string")
(terpri))
PRINTER> (printer)
"Hello" "this" is a
"string"
NIL4.1.3 格式化
如果你需要更多的输出控制，你可以使用format函数直接打印到标准输出流上，或者输出并建立一个输出字符串。我们暂且建立一个字符串，format函数有很多变量，但是我们仅讨论一些为了我们的目的有效的那些变量。
format函数与C语言里的sprintf函数类似。想要形成一个字符串，这样的format函数看起来像这样：(format nil <control-string> <arg-1> ... <arg-n>)，里边的control-string包含格式化指令，它以一个波浪线开头，这些位置将被剩下的参数填满。
最简单的格式化指令是~a。它将被下一个参数替换，它被处理成就像被princ函数打印成的样子。这有个例子：
> (format nil "Hello, ~a, how are you?" "Fred")
"Hello, Fred, how are you?"> (format nil "hello, ~s, how are you?" "Fred")
"hello, \"Fred\", how are you?"通过向~a和~s指令插入一个整数，你可以指定域宽度，然后该参数将使用至少是你指定的域宽度进行打印，如果需要可以比该宽度宽。在该宽度中参数是左对齐的：
> (format nil "Hello, ~10a, how are you?" "Fred")
"Hello, Fred , how are you?"> (format nil "Hello, ~va, how are you?" 10 "Fred")
"Hello, Fred , how are you?"> (format nil "The value is: ~,3g" 1.23456)
"The value is: 1.23"
> (format nil "~10,2e, ~v,vf" 123.456 10 3 56.789)
" 1.23E+2, 56.789"> (format nil "A format string ~
written on two lines")
"A format string written on two lines"> (defun plot-expr (expr var low high)
(flet ((f (x) (eval `(let ((,var ,x)) ,expr)))
(s (x) (format nil "~s" x)))
(plot-function #'f low high
:labels (list (s var) (s expr)))))
PLOT-EXPRformat函数不光可以用来建立字符串。如果format函数的第一个参数的nil被t代替的话，format函数将向标准输出流打印数据，然后返回nil。例如，你可以使用format函数打印一张小表：
> (format t
"A Small Table~%~10,3g ~10,3g~%~10,3g ~10,3g~%"
1.2 3.1 4.7 5.3)
A Small Table
1.20 3.10
4.70 5.30
NIL4.1.4 文件和流
Lisp的I/O函数从流里读取数据并向流写入数据。默认的用于输出的流是与全局变量*standard-output*绑定的；相应的默认的输入流是*standard-input*。通过给定一个流作为第二个参数，print函数可被告知使用哪个流。通过给定一个流作为一个参数，而不是用t或者nil，format函数也可以被通知使用一个流来打印数据。
文件流
流可以以一些方式形成。一个方式就是使用open函数打开一个文件，open函数带一个文件名作为参数，然后返回一个流。默认地，这个流是一个输入流。为了打开一个用于输出目的的流，你可以给定open命令一个附加的关键字参数:direction，它的值应该是另一个关键字，:input表示为输入文件而建立，它是默认值，:output表示为输出文件而建立。这里有一个例子，关于你如何写一些简单的表达式给一个名为"myfile"的文件。如果由这个文件名命名的文件已经存在，先前存在的文件将被覆写。否则，新文件将被建立：
> (setf f (open "myfile" :direction :output))
#<Character-Output-Stream 5:"e:\lisp-stat\myfile">
> (print '(+ 1 2 3) f)
(+ 1 2 3)
> (format f "~%~s~%" 'Hello)
NIL
> (close f)
T文件的内容如下：
我们可以使用read函数将这个文件的内容再读回到Lisp里：
> (setf f (open "myfile"))
#<Character-Input-Stream 5:"e:\lisp-stat\myfile">
> (read f)
(+ 1 2 3)
> (read f)
HELLO如果流是空的，或者已经到达文件尾，read函数将发出一个错误信号：
> (read f)
Error: end of file on read
Happened in: #<Subr-READ: #13e6284>> (read f nil)
NIL
> (read f nil '*eof*)
*EOF*> (with-open-file (f "myfile1" :direction :output)
(print '(+ 1 2 3) f)
(format f "~%~s~%" 'Hello))
NIL在处理文件I/O时偶尔有用的两个函数是force-output和file-position。force-output函数带一个可选的流参数，然后为流刷新输出缓冲区。如果没有提供参数，流默认将向标准输出里输出。file-position函数带一个流参数和一个可选的整型参数，这个流参数将与一个文件绑定。在仅使用流参数调用file-position函数时，它将返回针对这个文件流的文件指针的当前位置。当将一个整型数赋给函数作为第二个参数时，函数将文件指针设置到这个整型数字指定的那个位置。这个操作可以用来实现文件回读和文件I/O随机访问。
字符串流
可以构建一个流，来建立和分解字符串。假设你已经获得一个包含Lisp表达式的字符串，比如"(+ 1 2)"。这样的一个字符串可以从一个对话框窗口的文本域获取，你可以使用宏with-input-from-string从字符串里读取该表达式，这个宏这样调用：(with-input-from-string (<stream> <string>) <body>)。它使用字符串<string>创建了一个字符串输入流，并和符号<stream>绑定，然后在<body>里使用这个绑定对表达式求值。返回的结果就是<body>里最后一个表达式的求值结果。你可以使用以下函数从字符串里提取表达式：
> (with-input-from-string (s "(+ 1 2)") (read s))
(+ 1 2)4.2 定义更多灵活的函数
目前，我们遇到的一些内建函数或者是带可选参数的，或者是带关键字参数的，或者允许使用任意数量的参数。在你自定义的函数里也可以包括这些特性。
4.2.1 关键字参数
通过在参数列表里放置一个&key，你就定义了一个带关键字参数的函数。&key后边的所有参数都期望以关键字参数的形式来提供。举个例子，假设你想要递归factorial函数的一个版本，它以递归处理打印参数的当前值。这可以使用关键字参数实现：
> (defun factorial (n &key print)
(if print (format t "n = ~d~%" n))
(if (= n 0) 1 (* (factorial (- n 1) :print print) n)))
FACTORIAL> (factorial 3)
6> (factorial 3 :print t)
n = 3
n = 2
n = 1
n = 0
6> (defun factorial (n &key (print t))
(if print (format t "n = ~d~%" n))
(if (= n 0) 1 (* (factorial (- n 1) :print print) n)))
FACTORIAL> (factorial 3)
n = 3
n = 2
n = 1
n = 0
6
> (factorial 3 :print nil)
6> (defun is-it-there (&key (mykey nil is-it)) is-it)
IS-IT-THERE> (is-it-there :mykey nil)
T
> (is-it-there)
NIL> (defun factorial (n &key ((:print pr) t))
(if pr (format t "n = ~d~%" n))
(if (= n 0) 1 (* (factorial (- n 1) :print pr) n)))
FACTORIAL函数可以带多个关键字参数，关键字参数可以以任意顺序被使用，只需要跟在需要的参数后边。
4.2.2 可选参数
在我们的factorial例子中，我们可以使用一个可选参数代替关键字参数。方法是相似的：使用&optional符号代替参数列表里的&key符号：
> (defun factorial (n &optional print)
(if print (format t "n = ~d~%" n))
(if (= n 0) 1 (* (factorial (- n 1) print) n)))
FACTORIAL> (factorial 3)
6> (factorial 3 t)
n = 3
n = 2
n = 1
n = 0
6> (defun factorial (n &optional (print t))
(if print (format t "n = ~d~%" n))
(if (= n 0) 1 (* (factorial (- n 1) print) n)))
FACTORIAL与关键字参数不同的是，如果一个函数带多于一个的关键字参数，那么这些可选参数必须以他们在函数定义里指定的顺序使用。如果一个函数里既使用了可选参数也是用了关键字参数，那么在函数定义时可选参数必须要在关键字参数前边。在使用同时带可选参数和关键字参数的函数时，如果你想使用任何关键字参数，必须指定所有的可选参数。
4.2.3 参数的变量数量
在第3.7节定义的那个简单的矢量加法函数vec+仅需要两个参数，而内建的加法函数+允许任意多的参数。通过在参数列表里使用&rest符号，我们可以修改vec+的定义来允许任意数量的参数。如果一个函数的参数列表里包含&rest符号，那么在一次函数调用里的剩余的参数将被组合到一个列表里，然后被绑定到&rest符号后边的那个符号上，这里有个vec+的修改版本：
> (defun vec+ (&rest args)
(if (some #'compound-data-p args)
(apply #'map-elements #'vec+ args)
(apply #'+ args)))
VEC+可选参数、剩余参数和关键字参数全都出现在同一个参数列表里，如果他们的多个出现了，那么必须以&optional, &rest, &key的顺序出现。
4.3 控制结构
4.3.1 条件求值
我们已经广泛使用了条件求值结构cond和if。另一个条件求值结构是case，这在第3.10.2节做过简介。case可以用来根据通过表达式返回值的离散集合来选择相应动作，case表达式的一般形式是：
(case <key expr>
(<key 1> <expr 1>)
...
(<key n> <expr n>))
<key expr>被求值，然后每次与一个<key i>表达式进行比较，<key i>表达式可能是数字、符号、字符或者是他们的列表形式。如果<key expr>的值与一个键或者一个键列表的一个元素匹配，那么相应的结果表达式将被求值，然后它的结果被返回作为case表达式的结果。与cond语句相似，case语句可能包含一系列的结果表达式。这些表达式会被求值，一次只求值一个表达式，最后一个表达式的结果将返回。最后一个case语句可能以符号t开始，这种情况下如果其它语句都没被使用，最后一条语句将被用到。没有默认语句的话，如果没有一条语句是匹配的，case表达死将返回nil。举个简单的例子，下边的表达式：
> (case choice
((ok delete) (delete-file))
(cancel (restore-file)))偶尔地，如果一个谓词是or或者是非真，能够对一系列表达式求值就很有用了。这可以通过使用cond来完成，但是Lisp也提供了两个简单的替代物when和unless。表达式(when <p> <expr 1> ... <expr n>)和(unless <p> <expr 1> ... <expr n>)与(cond (<p> <expr 1> ... <expr n>))和(cond (<p> nil) () <expr 1> ... <expr n>))是分别等价的。
4.3.2 循环
目前为止，可用的最灵活的Lisp迭代结构是do，这在3.4节介绍过了。do事实上有比现在更多的选项。尤其是，它允许一系列的结果表达式跟在终端测试之后，也允许一系列的表达式被当做循环体给loop。循环体会使用do变量的当前绑定在每次迭代总执行。do表达式最一般的形式是：
(do ((<name 1> <initial 1> <update 1>)
...
(<name n> <initial n> <update n>))
(<test> <result 1> ... <result k>)
<expr 1>
...
<expr m>)> (defun my-sqrt (x &key print)
(do ((guess 1 (improve guess x)))
((goog-enough-p guess x)
(if print (formet t "Final guess: ~g~%" guess))
guess)
(if print (format t "Current guess: ~g~%" guess))))
MY-SQRT> (my-sqrt 3 :print t)
Current guess: 1.
Current guess: 2.
Current guess: 1.75
Error: The function FORMET is not defined.
Happened in: #<FSubr-DO: #140387c>do设置的变量绑定是并行设置的，就像使用let进行局部变量绑定一样。宏do*与do类似，除了一点就是它构建的绑定是串行的，因此这与let*是相似的。
一些简单的迭代结构也是可用的，有两个这样的结构dotimes和dolist，这在第2.5.6节简单介绍过。宏dotimes这样调用：
(dotimes (<var> <count> <result>) <body>)在dotimes里使用结果表达式，我们可以修改第3.8节里给出的factorial函数的C版本代码的翻译版本成这样：
(defun factorial (n)
(let ((n-fac 1))
(dotimes (i n n-fac)
(setf n-fac (* n-fac (+ i 1))))))(dolist (<var> <list> <result>) <body>)(defun sum-list (x)
(let ((sum 0))
(dolist (i x sum)
(setf sum (+ sum i)))))(defun factorial (n)
(let ((i 1)
(n-fac 1))
(loop (if (> i n) (return n-fac))
(setf n-fac (* i n-fac))
(setf i (+ i 1)))))4.4 基本Lisp数据和函数
到目前为止，我们广泛使用的Lisp数据类型仅是数值、字符串、符号和列表。本节将复习这些数据类型然后介绍一些新的数据类型，尤其是矢量和多维数组。
4.4.1 数值型
Lisp提供了一些不同的数值类型，包括整型、浮点型和复数型数值。Common Lisp也包含一个有理数数据类型。对于任何Lisp数值，谓词numberp都将返回t。谓词integerp和floatp可以用来识别整型数和浮点数。谓词complexp可识别复数数值。
在实数数值类型之间转换
函数floor、ceiling、truncate和roung可以用来将浮点数或者复数转换为与其接近的整型数，当对它们赋值整型数当参数时，它们只简单地返回它们的参数。在Lisp-Stat里，所有这四个函数都是矢量化的，floor总是返回一个接近参数但是比参数晓得整数，而truncate向零值处截断。
使用float函数强制将整型数和有理数转化为浮点数是可能的。如果float函数作用在一个浮点数上，那么那个数字将简单返回。在Common Lisp里，如果float函数作用到一个整型数或者有理数上，那么，默认地，将返回一个单精度浮点数。为了将一个不同的数据类型强制转换为浮点数，你可以赋给float函数第二个参数，一个想要的类型的数字。那么表达式为：
> (float 1 0.d0)
1.0> (float (list 1 2 3) 0.d0)
(1.0 2.0 3.0)在Common Lisp里，当给超越函数传递参数时，比如log函数和sin函数，整型数和有理数数类型将被强制成single-float类型的浮点数值。如果在你的Lisp系统里，浮点类型不能提供足够的足够的精度。在用这些函数前要将你的数据强制转换为双精度数值。
复数数值
复数数值将使用下边这个形式的表示方法打印：
#C(<realpart> <imagpart>)> (sqrt -1)
#C(0.0 1.0)> (complex 3 7)
#C(3 7)> #C(3 7)
#C(3 7)这两种方法之间有一些细微的不同。函数complex是一个普通函数，我们可以以下边的表达式作为它的参数来调用它：
> (complex (- 2 3) 1)
#C(-1 1)> #c((- 2 3) 1)
Error: not a real number - (- 2 3)
Happened in: #<Subr: #12a4f30>与实数类似，复数数值可以是整数、有理数或者浮点数。如果传递给complex函数的连个参数中有一个是浮点数，那么另一个也将被转换为浮点数，结果将是一个复类型的浮点数。如果这两个参数都是整数，结果将是复类型的整数。复类型的整数通常有一个非零虚部。虚部为零的复类型整数将被转换为实整型数。换句话说，复类型的浮点数可以有一个值为零的虚部：
> #c(1 0)
1
> #c(1.0 0.0)
#C(1.0 0.0)> (realpart #C(3 4))
3
> (imagpart #C(3 4))
4
> (phase #c(3 4))
0.9272952180016122
> (abs #C(3 4))
5.04.4.2 字符串和字符
我们已经在很多例子里使用过字符串了，它们被写成包含在一对双引号内部的字符序列。字符是组成字符串的元素。他们（字符串）被看成是一种特殊的数据类型，与单元素字符串和数值型字符代码相区别。为了弄清楚Lisp如何打印一个字符，我们可以使用函数char从字符串里提取一个字符，字符串的索引从零开始。那么字符串"Hello"里的字符的下标分别是0、1、2、3和4:
> (char "Hello" 0)
#\H
> (char "Hello" 1)
#\e> #\a
#\a
> #\3
#\3
> #\:
#\:
> #\newline
#\Newline使用string函数，一个字符可以转换为只有单个字符的字符串：
> (string #\H)
"H"4.4.3 符号
与其它大多数语言不同，Lisp符号是真正的在计算机内存中占用一定空间的物理对象。符号包含4个部分：
- 一个打印名
- 一个值单元
- 一个函数单元
- 一个属性列表
因为本书的剩余部分都不会使用属性列表，所以我不会进一步地讨论它。
符号的值单元包括由符号命名的全局变量。如果值单元里不包含一个数值，这个符号就是未绑定的，当你试图去取该符号的值时，将引发一个错误。谓词boundp可以用来确认一个符号是否有一个全局的值。一个符号的函数单元包含符号的全局函数定义，当然如果有的话。谓词fboundp将确定一个符号是否有一个全局函数定义。
一个符号的单元里的内容可以使用函数symbol-name，symbol-value和symbol-function来提取：
> (symbol-name 'pi)
"PI"
> (symbol-value 'pi)
3.141592653589793
> (symbol-function 'pi)
Error: The function PI is not defined.
Happened in: #<Subr-TOP-LEVEL-LOOP: #13e2ee0>使用setf函数，读取函数symbol-name，symbol-value和symbol-function可以被用来作为一般性的变量。例如，我们可以设置一个符号的值：
> (setf (symbol-value 'x) 2)
2
> x
2> (setf (symbol-function 'f) #'(lambda (x) (+ x 1)))
#<Closure: #141d194>
> (f 1)
2使用符号作为变量和函数的标签时，我们通常把这些符号与它们的打印名称视为是等价的，对大多数目的来说，这样做是合理的。当读取函数需要一个符号来表示一个特殊的打印名时，如果那个名字表示的符号已经不存在了，那么它仅仅构建一个新的符号而已。结果，带有相同打印名的符号应该是eq，然而，使用setf和symbol-name函数来改变一个符号的打印名称也是可能的，这么做可能会导致读取函数混乱并导致不可预知的结果，应该禁止这么做。
4.4.4 列表
列表是通过初级数据构建复杂数据的基本工具。虽然列表的结构是顺序性的，它们也可以用来表示数据项的无序集合。
图4.1 列表(a b c)的cons cells图表
基本列表结构
最基本的列表就是空列表nil，也叫null列表。它可以写成nil或者()。它可以自求值：
> nil
NIL
> ()
NILcons cells的两个域的内容可以使用函数first和rest来提取：
> (first '(a b c))
A
> (rest '(a b c))
(B C)
> (rest (rest '(a b c)))
(C)
> (rest (rest (rest '(a b c))))
NIL> (cons 'a '(b c))
(A B C)
> (cons 'C nil)
(C)
> (cons 'a (cons ' b (cons 'c nil)))
(A B C)> (setf x '(a b c))
(A B C)> (setf x '(a b c))
(A B C)
> (setf y (cons 'd (rest x)))
(D B C)> (eq x y)
NIL
> (eq (rest x) (rest y))
T在第2.4.4节里介绍的函数append，最后一个参数重用了cons cell。也就是说，表达式(append '(1 2) y)返回的结果的最后三个cons cell与组成y列表的cons cell是相同的：
> (append '(1 2) y)
(1 2 D B C)
> (eq y (rest (rest (append '(1 2) y))))
T将列表作为集合
在使用列表表示数据项集合方面，有一些函数是可用的。函数member测试一个元素是否在一个列表之中：
> (member 'b '(a b c))
(B C)
> (member 'd '(a b c))
NILadjoin函数将一个元素加到列表前边，除非这个元素已经在该列表里了：
> (adjoin 'd '(a b c))
(D A B C)
> (adjoin 'd '(d a b c))
(D A B C)> (union '(a b c) '(c d))
(D A B C)
> (intersection '(a b c) '(c d))
(C)set-difference返回了包含在第一个参数列表而不包含在第二个参数列表里的那些元素：
> (set-difference '(a b c) '(c d))
(B A)这些函数需要能够确定是否一个列表里的两个元素被视为是等价的。默认地，它们使用谓词eql来测试等价性，但是你可以使用关键字:test来指定一个备用的测试，例如：(member 1.0 '(1 2 3))返回false，因为整数1和浮点数1.0不是eql等价的。换句话说，(member 1.0 '(1 2 3) :test #'equalp)返回true，因为1与1.0是equalp等价的。你可以提供任意的带两个参数的函数作为测试谓词。
需要比较Lisp数据项的一些其它函数也允许通过使用:test关键字来指定备用的谓词。两个例子就是函数subst和remove。
4.4.5 向量
目前为止，我们已经将数值型数据集表示为列表形式，我们也可以将它们表示成向量的形式。向量可以使用类似下边的表达式来构建：
> '#(1 2 3)
#(1 2 3)字符#(是一个读取宏，表示向量的起始，接下来的表达式，一直到匹配的)，这些都将被读取函数读入并形成一个向量，不会被求值。这里需要引号，因为对一个向量求值时没有意义的。
你也可以使用vector函数，将它的参数构造成一个向量：
(vector 1 2 3)
#(1 2 3)> (setf x (vector 1 'a #\b))
#(1 A #\b)
> (length x)
3
> (elt x 1)
A
> (select x 1)
A
> (vectorp x)
Telt和select函数都可以通过使用setf被当做一般变量来使用。
是否将数据集表示成列表比表示成向量更好，还不是太清楚。向量确实提供了一些超过列表的优势，尤其地，读取向量上特定位置的元素所需要的时间是与改元素所在的位置无关的。相反，列表的元素通过遍历列表的结构单元来查找所要的元素，直到改元素被找到。如果将一个数据集表示为向量的形式，那么以随机顺序获取该数据集中元素的函数将运行得更快一些。另一方面，Lisp提供的处理列表的函数比处理向量的函数要多。在一些lisp系统里列表在使用内存方面也可以比向量更加高效。
4.4.6 序列
Common Lisp有很多好书，它们可以应用与列表、向量或者字符串上。函数length就是一个例子：
> (length '(1 2 3))
3
> (length '#(a b c d))
4
> (length "hello")
5函数elt用来提取序列里的一个元素：
> (elt '(1 2 3) 1)
2
> (elt '#(a b c d) 2)
C
> (elt "Hello" 4)
#\o> (coerce '(1 2 3) 'vector)
#(1 2 3)如果传递给coerce函数的第一个参数是指定的类型的话，它是否可以被拷贝，取决于所用的Lisp系统。如果你确实想拷贝一个序列的话，你可以使用函数copy-seq。这个函数仅拷贝序列，而不是序列的元素。元是序列和拷贝后的序列是逐元素eq等价的。如果函数coerce的结果类型符号是string类型的，但是序列的元素不都是字符，coerce函数将发出错误信号。
concatenate函数带有一个结果类型符号，并且带有任意数量的序列作为参数，它将返回一个新的序列，这个序列按顺序包含参数序列的所有元素：
> (concatenate 'list '(1 2 3) #(4 5))
(1 2 3 4 5)
> (concatenate 'vector '(1 2 3) #(4 5))
#(1 2 3 4 5)
> (concatenate 'string '(#\a #\b #\c) #(#\d #\e) "fgh")
"abcdefgh"函数map可以用来将列表和矢量进行函数映射，它的第一个参数必须是一个指定函数返回结果的符号：
> (map 'list #'+ (list 1 2 3) #(4 5 6))
(5 7 9)
> (map 'vector #'+ (list 1 2 3) #(4 5 6))
#(5 7 9)函数some对一个或多个序列逐元素地使用一个谓词，直到该谓词满足条件或者最短的那个序列用完为止：
> (some #'< '(1 2 3) '(1 2 4))
T
> (some #'> '(1 2 3) '(1 2 4))
NIL另一个有用的序列函数是reduce，这个函数带一个二进制函数和一个序列作为参数，并且使用二进制函数将序列的元素组合起来。例如，你可以使用下边的表达式将一个序列的元素逐个相加：
> (reduce #'+ '(1 2 3))
6> (reduce #'(lambda (x y) (cons y x))
'(1 2 3)
:initial-value nil)
(3 2 1)传递给reduce函数的第一个参数是获得的目前为止的减少量，第二个参数是序列里的下一个元素。
函数reverse返回一个列表，这个列表是所给参数的元素的逆序列：
> (reverse '(a b c))
(C B A)函数remove-if带有一个单独的参数谓词和一个序列作为参数，返回一个新的序列，该序列中所有满足谓词的元素都被移除掉了。例如：
> (remove-if #'(lambda (x) (<= x 0)) '(2 -1 3 0))
(2 3)使用remove作为函数名起始部分的都是非破坏性函数。他们产生一个新的序列而不修改或者重用参数。类似地，以delete作为函数名起始部分的函数是破坏性函数，它们修改或重用参数的数据，并且可以在内存利用上获得更高的效率。
函数find带一个元素和一个序列作为参数，返回与find函数的第一个参数匹配那个元素，这个元素存在于find函数的第二个参数序列里。
> (find 'b '(a b c))
B
> (find 'd '(a b c))
NIL> (position 'b '(a b c))
1
> (position 'd '(a b c))
NILCommon Lisp提供了一个强大的排序函数sort函数。sort函数需要两个参数，一个序列和一个谓词。谓词应该是一个函数，该函数带两个参数，并且仅当第一个参数严格小于第二个参数的时候返回非nil结果。sort函数应该谨慎使用，因为它会破坏性地对序列进行排序。也就是说，由于效率的原因，在运行排序算法的时候，它将部分地重用参数的数据，在处理过程中破坏了原来的序列。那么如果你想保护参数，在你将它传递给sort函数之前要进行数据拷贝。相反地，第2.7.3节里介绍的sort-data函数是非破坏性的函数。
4.4.7 数组
向量是一维的数值。Lisp还提供了多维数组。
数组的构建
make-array函数用来构建一个数组。它需要一个参数，数组的维度列表。例如：
> (make-array '(2 3))
#2A((NIL NIL NIL) (NIL NIL NIL))> (make-array '(2 3 4))
#3A(((NIL NIL NIL NIL) (NIL NIL NIL NIL) (NIL NIL NIL NIL)) ((NIL NIL NIL NIL) (NIL NIL NIL NIL) (NIL NIL NIL NIL)))一个向量也可以使用make-array函数来构建：
> (make-array '(3))
#(NIL NIL NIL)> (make-array 3)
#(NIL NIL NIL)> (make-array '(2 3) :initial-element 1)
#2A((1 1 1) (1 1 1))> (make-array '(3 2) :initial-contents '((1 2) (3 4) (5 6)))
#2A((1 2) (3 4) (5 6))> (setf x (make-array '(3 2)
:initial-contents '((1 2) (3 4) (5 6))))
#2A((1 2) (3 4) (5 6))
> (make-array '(2 3) :displaced-to x)
#2A((1 2 3) (4 5 6)):dispaced-to关键字在将一个数组数据读取成为一个向量的时候是很有用的：
> (make-array 6 :displaced-to x)
#(1 2 3 4 5 6)多维数组的打印形式可以使用读取函数来读入。那么你可以通过键入这个数组就像它打印成的样子，用这样的办法来构建一个数组：
#2A((1 2) (3 4) (5 6))
> '#2a((1 2) (3 4) (5 6))
#2A((1 2) (3 4) (5 6))这里又需要引号了，因为对一个数组求值是没有意义的。使用矢量读取宏，当一个数组以这种方式构建的时候数组元素是不被求值的。
数组读取
aref函数可以用来提取数组的元素。使用上边构建的数组x，我们可以提取第一行第零列的元素：
> x
#2A((1 2) (3 4) (5 6))
> (aref x 1 0)
3> (setf (aref x 1 0) 'a)
A
> x
#2A((1 2) (A 4) (5 6))> x
#2A((1 2) (A 4) (5 6))
> (select x 1 0)
A
> (setf (select x 1 0) 'b)
B
> (select x '(0 1) 1)
#2A((2) (4))
> (select x 1 '(0 1))
#2A((B 4))
> (select x '(0 1) '(0 1))
#2A((1 2) (B 4))> (setf (select x '(0 1) 1) '#2A((x) (y)))
#2A((X) (Y))
> x
#2A((1 X) (B Y) (5 6))aref函数不允许索引列表，但是这在一些Lisp系统里可能更加高效。
额外的数组信息
array-rank函数返回一个数组的阶数：
> (array-rank '#(1 2 3))
1
> (array-rank '#2A((1 2 3) (4 5 6)))
2
> (array-rank (make-array '(2 3 4)))
3> (array-dimension '#(1 2 3) 0)
3
> (array-dimension '#2A((1 2 3) (4 5 6)) 0)
2
> (array-dimension '#2a((1 2 3) (4 5 6)) 1)
3> (array-dimensions '#(1 2 3))
(3)
> (array-dimensions '#2a((1 2 3) (4 5 6)))
(2 3)> (array-total-size '#2a((1 2 3) (4 5 6)))
6
> (array-in-bounds-p '#2a((1 2 3) (4 5 6)) 2 1)
NIL
> (array-in-bounds-p '#2a((1 2 3) (4 5 6)) 1 2)
T> (array-row-major-index '#2a((1 2 3) (4 5 6)) 1 2)
5注："以行为主要的顺序存储结构"，原文为row-major ordering，即多维数组元素在内存里的存储顺序，将多维的数组元素以一维的形式存放于内存之中。
4.4.8 其它的数据类型
除了在本节里讨论的数据类型之外，Lisp-Stat还有一个叫做object的数据类型，它用于面向对象编程。对象是第六章的主题。Common Lisp也有结构体这个数据类型，这与C的结构体和pascal的记录数据类型是相似的。
4.5 什物
本节包含一些杂项主题集合，这些主题与前边几节不能很方便地切合。
4.5.1 错误
在计算过程中发生一个错误的时候，Lisp将进入调试器，这个在4.5.3节里描述，或者重启系统之后返回到解释器。Lisp提供一些工具用来从你的函数里发送一个错误信号，这些工具还可以用来确保执行一个清理步骤，即使错误发生在表达式求值阶段。
发送错误信号
比如说一个内置函数的参数不是合适的类型，它将打印一个合理的带有信息的错误消息。你可以使用error函数让你的函数打印这样的消息。error函数带有一个格式化字符参数，后边还跟着一个格式化指令需要的额外的参数。错误字符串不应该包含指示错误已经发生的状态，系统将提供这种指示，这里有几个例子：
> (error "An error has occurred")
Error: An error has occurred
Happened in: #<Subr-TOP-LEVEL-LOOP: #1372f1c>
> (error "Bad argment type type - ~a" 3)
Error: Bad argment type type - 3
Happened in: #<Subr-TOP-LEVEL-LOOP: #1372f1c> 随着出现错误的可能性程度，确保在错误发生之后系统重启之前，采取一定的动作，这是很重要的。例如，如果在处理一个对话框窗体的动作时发生了一个错误，你可能想要确保这个对话框从屏幕移除。unwind-protect函数就是用来保证一定的清除动作发生的函数。调用一个unwind-protect函数的一般形式是：
(unwind-protect <protected expr>
<cleanup expr1 1>
...
<cleanup expr n>)
unwind-protect对<protected expr>求值，然后对<cleanup expr1 1>, ...,<cleanup expr1 n>求值。即使在错误发生以后，在函数对<protected expr>表达式求值过程中，发生了系统重启，也会执行清楚表达式的。清除表达式本身不被进一步保护。unwind-protect表达式返回的结果就是<protected expr>表达式返回的结果。举个例子，处理对话框并且保证及时发生错误对话框也能关闭的表达式可以这样编写：(unwind-protect (do-dialog) (close-dialog))。
4.5.2 代码编写帮助
注释，缩进和文档
Lisp里的注释前边要加一个分号。一行之中所有跟在一个分号之后的文本都会被Lisp读取器忽略。依据惯例，不同数目的分号用在不同层次层级上：4个分号用于文件头注释，3个分号用于函数定义的注释，2个分号用于函数内部开始部分的注释，1个分号用于代码的行注释。
注释当然也经常可以用来临时性地移除某个代码段。在每行前边都加一个分号是件烦人的事儿，所以出现了多行注释系统：所有出现在符号"#|"和"|#"之间的文本都将被忽略，无论有多少行。Lisp代码，通常都带有很多括号，如果不对它进行缩进处理以反映它的结构，它就会极难阅读。好的Lisp编辑器，比如emacs编辑器，都会提供一个机制来根据一定的缩进惯例对函数进行自动缩进。Macintosh操作系统的XLISP-STAT解释器和编辑器窗口也包含一个简单的缩进机制：在一个代码行上敲击tab键，改行将缩进到合理的层次上。
Lisp代码在进行定义时包含一个机制即在代码里家入文档。如果在一个由defun定义的函数体里的第一个表达式是字符串的话，并且如果在函数体里的表达式多于一个，那么这个字符串将作为函数符号的文档安装到函数内部，这里的函数符号在defun定义的函数体里作为函数名。这些文档字符串可以使用documentation函数或者Lisp-Stat的help和help*函数获取。例如，为了提取函数符号mean的文档，
> (documentation 'mean 'function)
loading in help file information - this will take a minute ...done
"Args: (x)
Returns the mean of the elements x. Vector reducing."> (documentation 'pi 'variable)
"The floating-point number that is approximately equal to the ratio of the
circumference of a circle to its diameter."
> (documentation 'complex 'type)
"A complex number"在将一个函数定义拆散并放到多个文件方面，函数require和provide是很有用的。函数provide将它的参数，一个字符串加到*modules*这个列表中，前提是它不在该列表内。函数require检查它的参数是否已经存在于*modules*列表。如果已经存在于该列表，就什么也不做；否则，它将试图加载它的参数。require也接受第二个参数用来作为将被加载的文件的名字。如果没有提供第二个参数，这个名字将从模块的名字里构造。
为了使用多个文件实现一个模块系统，在文件起始部分放置一个provide表达式，后边跟着一个require表达式，该require表达式引入该文件依赖的每一个模块。加载感兴趣的主文件应该同时会引进其它文件，被require命令引入两次及以上次数的文件只加载一次。
适应系统特征
Common Lisp提供了一个机制，来探测系统是否有特别特性，还可以在一定特征或者一定特征的组合的情况下对表达式求值。
针对特定的系统，全局变量*features*包括一个特性列表。在带色彩监视器的一个Macintosh系统里的XLISP-STAT上，这个变量的值可能是：
(注：各位，不好意思，没在Mac上试验过，现将原文拷贝如上图，但是Windows下的XLISP-STAT里的*features*是有的)
> *features*
(:COLOR :DIALOGS :WINDOWS :WIN32 :MSDOS :XLISP-STAT :XLISP-PLUS :XLISP)跟在#+和#-后边的符号也可以替换成features里的符号的逻辑表达式。例如：#+(and windows (not color)) (fake-color)表达式确保符号windows在features列表里并且color符号不在features列表的时候，(fake-color)才被求值。
4.5.3 调试工具
在Lisp里，三个调试工具是可用的：断点、跟踪机制和步进器。所有与Comon Lisp标准兼容的Lisp系统都至少提供了这三个机制，但是它们如何工作和它们产生的输出因系统的不同而不同。本节我将描述在XLISP-STAT系统里提供的这些机制的版本。
断点
通过执行break函数，可以输入一个断点。在一个函数代码里放置一个(break)表达式，就像这样：
(defun f (x) (break) x)允许你在函数环境里检测变量。为了从断点处继续运行，可以执行continue函数：
> (defun f (x) (break) x)
F
> (f 3)
Break: **BREAK**
Break level 1.
To continue, type (continue n), where n is an option number:
0: Return from BREAK.
1: Return to Lisp Toplevel.
1> x
3
1> (continue)
3 如果全局变量*breakenable*不为nil，这时发生了一个错误，系统将自动进入断点。如果*tracenable*也不是nil，一个调用的回溯引出的断点将被打印出来。断点的层级序号将由变量*tracelimit*控制。如果*tracenable*是nil的话，通过调用baktrace (sic) 函数你仍然可以获得调用堆栈追溯。
函数debug和nodebug提供了一个方便的方式来使*breakenable*在值nil和t之间来回切换。
如果是因为发生一个错误而进入一个断点，可能就无法使用continue函数了。对于这种无法继续执行的错误，你可以通过调用top-level函数来返回到顶层。在Macintosh版本的XLISP-STAT里，你也可以在Command菜单里选择Top-Level选项，或者是与它等价的命令键。
下边是一个断点使能的例子：
> (defun f (x) (/ x 0))
F
> (debug)
T
> (f 3)
Error: illegal zero argument
Break level 1.
To continue, type (continue n), where n is an option number:
0: Return to Lisp Toplevel.
1> (baktrace)
Function: #<Subr-/: #13df124>
Arguments:
3
0
Function: #<Closure-F: #140eaac>
Arguments:
3
Function: #<Subr-TOP-LEVEL-LOOP: #13e2ac4>
1> (f 3)
Error: illegal zero argument
Break level 2.
To continue, type (continue n), where n is an option number:
0: Return to break level 1.
1: Return to Lisp Toplevel.
2> (clean-up)
NIL
2> (continue 0)
Break level 1.
To continue, type (continue n), where n is an option number:
0: Return to Lisp Toplevel.
1> x
3
1> (top-level)
[ back to top level ]为了追踪一个没有使用断点中断的一个特定的函数的用途，你可以使用trace函数跟踪它。为了跟踪函数f，对下边的表达式求值(trace f)，为了停止跟踪，计算这个表达式(untrace f)。调用一个不带参数的untrace函数将停止对当前所有的被跟踪函数的跟踪。在不需要引用参数的时候，trace和untrace函数就是宏t'。
举个例子，让我们来葛总一下下边定义的一个递归函数factorial的执行过程吧：
> (defun factorial (n)
(if (= n 0) 1
(* (factorial (- n 1)) n)))
FACTORIAL
> (trace factorial)
(FACTORIAL)
> (factorial 6)
Entering: FACTORIAL, Argument list: (6)
Entering: FACTORIAL, Argument list: (5)
Entering: FACTORIAL, Argument list: (4)
Entering: FACTORIAL, Argument list: (3)
Entering: FACTORIAL, Argument list: (2)
Entering: FACTORIAL, Argument list: (1)
Entering: FACTORIAL, Argument list: (0)
Exiting: FACTORIAL, Value: 1
Exiting: FACTORIAL, Value: 1
Exiting: FACTORIAL, Value: 2
Exiting: FACTORIAL, Value: 6
Exiting: FACTORIAL, Value: 24
Exiting: FACTORIAL, Value: 120
Exiting: FACTORIAL, Value: 720
720
> (untrace factorial)
NIL
> (factorial 6)
720步进器允许你每次只运行一个表达式求值。你可以通过对下式求值来步进地对表达式求值：(step expr)。每一步步进器都会等待一个应答，可能的应答如下：
- :b - break
- :h - help (this message)
- :n - next
- :s - skip
- :e - evaluate
在Macintosh操作系统的XLISP-STAT里，step函数将打开一个带按钮的对话框，用来构建这个应答。下边是步进器会话的一个简单的例子：
> (step (break '(+ 1 2 (* 3 (/ 2 4)))))
0 >==> (BREAK (QUOTE (+ 1 2 (* 3 (/ 2 4)))))
1 >==> (QUOTE (+ 1 2 ...)) :n
1 <==< (+ 1 2 (* 3 (/ 2 4)))Break:
1 >==> (XLISP::%STRUCT-REF X 1) :n
X = #<Condition SIMPLE-CONDITION: 1417be8>
1 <==< (+ 1 2 (* 3 (/ 2 4)))
1 >==> (XLISP::%STRUCT-REF X 2) :n
X = #<Condition SIMPLE-CONDITION: 1417be8>
1 <==< NIL#<Condition SIMPLE-CONDITION: 1417be8>
Break level 1.
To continue, type (continue n), where n is an option number:
0: Return from BREAK.
1: Return to Lisp Toplevel.
1> (continue 0)
0 <==< NIL
NIL4.5.4 定时器
为了定时地计算求值和确定系统时钟的当前状态，一些宏和函数是可用的。宏time带一个表达式参数，对该表达式参数求值后，将打印本次求值需要的时间，最后返回表达式的结果：
> (time (mean (iseq 1 100000)))
The evaluation took 0.03 seconds; 0.03 seconds in gc.
50000.5函数get-internal-run-time和get-internal-real-time返回离起始点的总运行时间和总共过去的时间。时间起始点和量度单位是系统决定的。每秒钟的内部时间单元的数量是全局变量internal-time-units-per-second的值。
4.5.5 Defsetf
使用setf可以将一些读取函数当做一般变量来操作。使用defsetf宏，你可以定义setf方法来读取你自己的函数。defsetf有好几种用法，最简答的形式是(defsetf <accessor> <access-fcn>)。参数<access-fcn>是一个命名函数的符号，它将传递给<accessor>的参数作为自己的参数，这些参数后边后跟着一个数值，通过使用<accessor>参数来进行位置定位。<access-fcn>应该返回参数的值作为它的返回值。
举个例子，在3.10.2节中我介绍了功能抽象来表示加法的表达式。这个抽象包括一个构造函数make-sum和两个读取函数addend和augend。为了能够改变一个加法操作里的加数，我们可以使用这样一个表达式(setf (addend mysum) 3)，假设加法被表达出Lisp表达式，修改加数的函数可以被定义成这样：
> (defun set-addend (sum new)
(setf (select sum 1) new)
new)
SET-ADDEND> (defsetf addend set-addend)
ADDEND现在，我们可以使用setf来改变一个加法式里的加数：
> (defun make-sum (a1 a2) (list '+ a1 a2))
MAKE-SUM
> (defun addend (e) (second e))
ADDEND
> (defun augend (e) (third e))
AUGEND
> (setf s (make-sum 1 3))
(+ 1 3)
> (setf (addend s) 2)
2
> s
(+ 2 3)4.5.6 特殊变量
默认地，Common Lisp变量是词法作用域的。通过使用一个特殊的符号，使Lisp把变量看做成动态作用域变量，这是可能的。这样的变量叫做特殊变量。很多预定义的系统常量就是这样的特殊变量。
特殊全局变量可以使用defvar、defparameter和defconstant来设置。defvar设置一个全局变量并将它初始化为nil或者通过第二个可选参数来指定初始化值，除非它已经有一个值了。如果该变量已经有一个值，该值将不会改变，并且参数列表提供的赋值表达式也不会被求值。defvar也接收一个字符串作为第三个参数，它将被安装到变量里作为变量的文档字符串。可以使用documentation函数或者help或者help*函数来取得该字符串：
> (defvar x (list 1 2 3) "A simple data set")
X> (defconstant e (exp 1) "Base of the natural logarithm")
E
> (setf e 3)
Error: can't assign/bind to constant - E
Happened in: #<FSubr-SETQ: #13c4b50>