标题：lisp语言
Lisp之根源
保罗格雷厄姆
约翰麦卡锡于1960年发表了一篇非凡的论文，他在这篇论文中对编程的贡献有如欧几里德对几何的贡献.[1] 他向我们展示了，在只给定几个简单的操作符和一个表示函数的记号的基础上，如何构造出一个完整的编程语言. 麦卡锡称这种语言为Lisp，意为List Processing，因为他的主要思想之一是用一种简单的数据结构表（list）来代表代码和数据. 
值得注意的是，麦卡锡所作的发现，不仅是计算机史上划时代的大事，而且是一种在我们这个时代编程越来越趋向的模式.我认为目前为止只有两种真正干净利落，始终如一的编程模式：C语言模式和Lisp语言模式.此二者就象两座高地，在它们中间是尤如沼泽的低地.随着计算机变得越来越强大，新开发的语言一直在坚定地趋向于Lisp模式. 二十年来，开发新编程语言的一个流行的秘诀是，取C语言的计算模式，逐渐地往上加Lisp模式的特性，例如运行时类型和无用单元收集. 
在这篇文章中我尽可能用最简单的术语来解释约翰麦卡锡所做的发现. 关键是我们不仅要学习某个人四十年前得出的有趣理论结果，而且展示编程语言的发展方向. Lisp的不同寻常之处--也就是它优质的定义--是它能够自己来编写自己. 为了理解约翰麦卡锡所表述的这个特点，我们将追溯他的步伐，并将他的数学标记转换成能够运行的Common Lisp代码.
七个原始操作符
表达式开始我们先定义表达式.表达式或是一个原子（atom），它是一个字母序列（如 foo），或是一个由零个或多个表达式组成的表（list），表达式之间用空格分开，放入一对括号中. 以下是一些表达式： 
foo
()
(foo)
(foo bar)
(a b (c) d)
最后一个表达式是由四个元素组成的表，第三个元素本身是由一个元素组成的表. 
在算术中表达式 1 + 1 得出值2. 正确的Lisp表达式也有值. 如果表达式e得出值v，我们说e返回v. 下一步我们将定义几种表达式以及它们的返回值. 
如果一个表达式是表，我们称第一个元素为操作符，其余的元素为自变量.我们将定义七个原始（从公理的意义上说）操作符： quote,atom,eq,car,cdr,cons，和 cond.quote（quote x) 返回x.为了可读性我们把（quote x）简记 为'x. 
> (quote a)
a
> 'a
a
> (quote (a b c))
(a b c)atom（atom x）返回原子t如果x的值是一个原子或是空表，否则返回（）. 在Lisp中我们按惯例用原子t表示真，而用空表表示假. 
> (atom 'a)
t
> (atom '(a b c))
()
> (atom '())
t
既然有了一个自变量需要求值的操作符，我们可以看一下quote的作用. 通过引用（quote)一个表，我们避免它被求值. 一个未被引用的表作为自变量传给象 atom这样的操作符将被视为代码： 
> (atom (atom 'a))
t
反之一个被引用的表仅被视为表，在此例中就是有两个元素的表： 
> (atom '(atom 'a))
()
这与我们在英语中使用引号的方式一致. Cambridge(剑桥）是一个位于麻萨诸塞州有90000人口的城镇. 而``Cambridge''是一个由9个字母组成的单词. 
引用看上去可能有点奇怪因为极少有其它语言有类似的概念. 它和Lisp最与众不同的特征紧密联系：代码和数据由相同的数据结构构成，而我们用quote操作符来区分它们.eq（eq x y）返回t如果x和y的值是同一个原子或都是空表，否则返回（）. 
> (eq 'a 'a)
t
> (eq 'a 'b)
()
> (eq '() '())
tcar（car x)期望x的值是一个表并且返回x的第一个元素. 
> (car '(a b c))
acdr（cdr x)期望x的值是一个表并且返回x的第一个元素之后的所有元素. 
> (cdr '(a b c))
(b c)cons（cons x y）期望y的值是一个表并且返回一个新表，它的第一个元素是x的值，后面跟着y的值的各个元素. 
> (cons 'a '(b c))
(a b c)
> (cons 'a (cons 'b (cons 'c '())))
(a b c)
> (car (cons 'a '(b c)))
a
> (cdr (cons 'a '(b c)))
(b c)cond（cond (...) ...(...)) 的求值规则如下. p表达式依次求值直到有一个返回t. 如果能找到这样的p表达式，相应的e表达式的值作为整个cond表达式的返回值. 
> (cond ((eq 'a 'b) 'first)
((atom 'a) 'second))
second
函数
当表达式以七个原始操作符中的五个开头时，它的自变量总是要求值的.[2] 我们称这样 的操作符为函数.函数的表示接着我们定义一个记号来描述函数.函数表示为(lambda (...) e），其中 ...是原子（叫做参数），e是表达式. 如果表达式的第一个元素形式如上 
((lambda (...) e) ...) 
则称为函数调用.它的值计算如下.每一个表达式先求值，然后e再求值.在e的求值过程中，每个出现在e中的的值是相应的在最近一次的函数调用中的值. 
> ((lambda (x) (cons x '(b))) 'a)
(a b)
> ((lambda (x y) (cons x (cdr y))) 'z '(a b c))
(z b c)
如果一个表达式的第一个元素f是原子且f不是原始操作符 
(f ...) 
并且f的值是一个函数（lambda (...）），则以上表达式的值就是 
((lambda (...) e) ...) 
的值. 换句话说，参数在表达式中不但可以作为自变量也可以作为操作符使用： 
> ((lambda (f) (f '(b c))) '(lambda (x) (cons 'a x)))
(a b c)
有另外一个函数记号使得函数能提及它本身，这样我们就能方便地定义递归函数.[3] 记号 
(label f (lambda (...) e)) 
表示定义函数名为 f 的函数为（lambda (...) e）。特别的，次定义语句本身e之中可以出现 f ，且任何出现在e中的f将求值为此label表达式，就好象f是此函数已知的参数。如此形成了自指嵌套。示例假设我们要定义函数（subst x y z），它取表达式x，原子y和表z做参数，返回一个象z那样的表，不过z中出现的y（在任何嵌套层次上）被x代替. 
> (subst 'm 'b '(a b (a b c) d))
(a m (a m c) d)
我们可以这样表示此函数 
(label subst (lambda (x y z)
(cond ((atom z)
(cond ((eq z y) x)
('t z)))
('t (cons (subst x y (car z))
(subst x y (cdr z)))))))
我们简记f=(label f (lambda (...) e））为 
(defun f (...) e) 
于是 
(defun subst (x y z)
(cond ((atom z)
(cond ((eq z y) x)
('t z)))
('t (cons (subst x y (car z))
(subst x y (cdr z))))))
偶然地我们在这儿看到如何写cond表达式的缺省子句. 第一个元素是't的子句总是会成功的. 于是 
(cond (x y) ('t z)) 
等同于我们在某些语言中写的 
if x then y else z 
一些函数 
既然我们有了表示函数的方法，我们根据七个原始操作符来定义一些新的函数. 为了方便我们引进一些常见模式的简记法. 我们用cxr，其中x是a或d的序列，来简记相应的car和cdr的组合. 比如（cadr e)是（car (cdr e））的简记，它返回e的第二个元素. 
> (cadr '((a b) (c d) e))
(c d)
> (caddr '((a b) (c d) e))
e
> (cdar '((a b) (c d) e))
(b)
我们还用（list ...）表示（cons ...(cons '()) ...). 
> (cons 'a (cons 'b (cons 'c '())))
(a b c)
> (list 'a 'b 'c)
(a b c)
现在我们定义一些新函数. 我在函数名后面加了点,以区别函数和定义它们的原始函数，也避免与现存的common Lisp的函数冲突. 
(null. x）测试它的自变量是否是空表. 
(defun null. (x)
(eq x '()))
> (null. 'a)
()
> (null. '())
t
(and. x y)返回t如果它的两个自变量都是t，否则返回（）. 
(defun and. (x y)
(cond (x (cond (y 't) ('t '())))
('t '())))
> (and. (atom 'a) (eq 'a 'a))
t
> (and. (atom 'a) (eq 'a 'b))
()
(not. x）返回t如果它的自变量返回（），返回（）如果它的自变量返回t. 
(defun not. (x)
(cond (x '())
('t 't)))
> (not. (eq 'a 'a))
()
> (not. (eq 'a 'b))
t
(append. x y)取两个表并返回它们的连结. 
(defun append. (x y)
(cond ((null. x) y)
('t (cons (car x) (append. (cdr x) y)))))
> (append. '(a b) '(c d))
(a b c d)
> (append. '() '(c d))
(c d)
(pair. x y）取两个相同长度的表，返回一个由双元素表构成的表，双元素表是相应位置的x,y的元素对. 
(defun pair. (x y)
(cond ((and. (null. x) (null. y)) '())
((and. (not. (atom x)) (not. (atom y)))
(cons (list (car x) (car y))
(pair. (cdr) (cdr y))))))
> (pair. '(x y z) '(a b c))
((x a) (y b) (z c))
(assoc. x y)取原子x和形如pair.函数所返回的表y，返回y中第一个符合如下条件的表的第二个元素：它的第一个元素是x. 
(defun assoc. (x y)
(cond ((eq (caar y) x) (cadar y))
('t (assoc. x (cdr y)))))
> (assoc. 'x '((x a) (y b)))
a
> (assoc. 'x '((x new) (x a) (y b)))
new
一个惊喜 
因此我们能够定义函数来连接表，替换表达式等等.也许算是一个优美的表示法，那下一步呢? 现在惊喜来了. 我们可以写一个函数作为我们语言的解释器：此函数取任意Lisp表达式作自变量并返回它的值. 如下所示： 
(defun eval. (e a)
(cond 
((atom e) (assoc. e a))
((atom (car e))
(cond 
((eq (car e) 'quote) (cadr e))
((eq (car e) 'atom) (atom (eval. (cadr e) a)))
((eq (car e) 'eq) (eq (eval. (cadr e) a)
(eval. (caddr e) a)))
((eq (car e) 'car) (car (eval. (cadr e) a)))
((eq (car e) 'cdr) (cdr (eval. (cadr e) a)))
((eq (car e) 'cons) (cons (eval. (cadr e) a)
(eval. (caddr e) a)))
((eq (car e) 'cond) (evcon. (cdr e) a))
('t (eval. (cons (assoc. (car e) a)
(cdr e))
a))))
((eq (caar e) 'label)
(eval. (cons (caddar e) (cdr e))
(cons (list (cadar e) (car e)) a)))
((eq (caar e) 'lambda)
(eval. (caddar e)
(append. (pair. (cadar e) (evlis. (cdr e) a))
a)))))
(defun evcon. (c a)
(cond ((eval. (caar c) a)
(eval. (cadar c) a))
('t (evcon. (cdr c) a))))
(defun evlis. (m a)
(cond ((null. m) '())
('t (cons (eval. (car m) a)
(evlis. (cdr m) a)))))
eval.的定义比我们以前看到的都要长. 让我们考虑它的每一部分是如何工作的. 
eval.有两个自变量： e是要求值的表达式，a是由一些赋给原子的值构成的表，这些值有点象函数调用中的参数. 这个形如pair.的返回值的表叫做环境. 正是为了构造和搜索这种表我们才写了pair.和assoc.. 
eval.的骨架是一个有四个子句的cond表达式. 如何对表达式求值取决于它的类型. 第一个子句处理原子. 如果e是原子，我们在环境中寻找它的值： 
> (eval. 'x '((x a) (y b)))
a
第二个子句是另一个cond，它处理形如（a ...）的表达式，其中a是原子. 这包括所有的原始操作符，每个对应一条子句. 
> (eval. '(eq 'a 'a) '())
t
> (eval. '(cons x '(b c))
'((x a) (y b)))
(a b c)
这几个子句（除了quote）都调用eval.来寻找自变量的值. 
最后两个子句更复杂些. 为了求cond表达式的值我们调用了一个叫 evcon.的辅助函数. 它递归地对cond子句进行求值，寻找第一个元素返回t的子句. 如果找到了这样的子句，它返回此子句的第二个元素. 
> (eval. '(cond ((atom x) 'atom)
('t 'list))
'((x '(a b))))
list
第二个子句的最后部分处理函数调用. 它把原子替换为它的值（应该是lambda 或label表达式)然后对所得结果表达式求值. 于是 
(eval. '(f '(b c))
'((f (lambda (x) (cons 'a x)))))
变为 
(eval. '((lambda (x) (cons 'a x)) '(b c))
'((f (lambda (x) (cons 'a x)))))
它返回（a b c). 
eval.的最后cond两个子句处理第一个元素是lambda或label的函数调用.为了对label 表达式求值，先把函数名和函数本身压入环境，然后调用eval.对一个内部有 lambda的表达式求值. 即： 
(eval. '((label firstatom (lambda (x)
(cond ((atom x) x)
('t (firstatom (car x))))))
y)
'((y ((a b) (c d)))))
变为 
(eval. '((lambda (x)
(cond ((atom x) x)
('t (firstatom (car x)))))
y)
'((firstatom
(label firstatom (lambda (x)
(cond ((atom x) x)
('t (firstatom (car x)))))))
(y ((a b) (c d)))))
最终返回a. 
最后，对形如（（lambda (...) e) ...）的表达式求值，先调用evlis.来求得自变量（...）对应的值（...），把（）...（）添加到环境里，然后对e求值. 于是 
(eval. '((lambda (x y) (cons x (cdr y)))
'a
'(b c d))
'())
变为 
(eval. '(cons x (cdr y))
'((x a) (y (b c d))))
最终返回（a c d). 
后果 
既然理解了eval是如何工作的，让我们回过头考虑一下这意味着什么. 我们在这儿得到了一个非常优美的计算模型. 仅用quote,atom,eq,car,cdr,cons，和cond，我们定义了函数eval.，它事实上实现了我们的语言，用它可以定义任何我们想要的额外的函数.
约翰麦卡锡定义lisp
当然早已有了各种计算模型--最著名的是图灵机. 但是图灵机程序难以读懂. 如果你要一种描述算法的语言，你可能需要更抽象的，而这就是约翰麦卡锡定义 Lisp的目标之一. 
约翰麦卡锡于1960年定义的语言还缺不少东西. 它没有副作用，没有连续执行 （它得和副作用在一起才有用），没有实际可用的数，[4] 没有动态可视域. 但这些限制可以令人惊讶地用极少的额外代码来补救. Steele和Sussman在一篇叫做``解释器的艺术''的著名论文中描述了如何做到这点.[5] 
如果你理解了约翰麦卡锡的eval，那你就不仅仅是理解了程序语言历史中的一个阶段. 这些思想至今仍是Lisp的语义核心. 所以从某种意义上，学习约翰麦卡锡的原著向我们展示了Lisp究竟是什么. 与其说Lisp是麦卡锡的设计，不如说是他的发现. 它不是生来就是一门用于人工智能，快速原型开发或同等层次任务的语言. 它是你试图公理化计算的结果（之一）. 
随着时间的推移，中级语言，即被中间层程序员使用的语言，正一致地向Lisp靠近. 因此通过理解eval你正在明白将来的主流计算模式会是什么样. 
注释 
把约翰麦卡锡的记号翻译为代码的过程中我尽可能地少做改动. 我有过让代码更容易阅读的念头，但是我还是想保持原汁原味. 
在约翰麦卡锡的论文中，假用f来表示，而不是空表. 我用空表表示假以使例子能在Common Lisp中运行. (fixme) 
我略过了构造dotted pairs，因为你不需要它来理解eval. 我也没有提apply，虽然是apply（它的早期形式，主要作用是引用自变量），被约翰麦卡锡在1960年称为普遍函数，eval只是不过是被apply调用的子程序来完成所有的工作. 
我定义了list和cxr等作为简记法因为麦卡锡就是这么做的. 实际上 cxr等可以被定义为普通的函数. List也可以这样，如果我们修改eval，这很容易做到，让函数可以接受任意数目的自变量. 
麦卡锡的论文中只有五个原始操作符. 他使用了cond和quote，但可能把它们作为他的元语言的一部分. 同样他也没有定义逻辑操作符and和not，这不是个问题，因为它们可以被定义成合适的函数. 
在eval.的定义中我们调用了其它函数如pair.和assoc.，但任何我们用原始操作符定义的函数调用都可以用eval.来代替. 即 
(assoc. (car e) a)
能写成 
(eval. '((label assoc.
(lambda (x y)
(cond ((eq (caar y) x) (cadar y))
('t (assoc. x (cdr y))))))
(car e)
a)
(cons (list 'e e) (cons (list 'a a) a)))
麦卡锡的eval有一个错误. 第16行是（相当于）（evlis. (cdr e) a）而不是（cdr e),这使得自变量在一个有名函数的调用中被求值两次. 这显示当论文发表的时候，eval的这种描述还没有用IBM 704机器语言实现. 它还证明了如果不去运行程序，要保证不管多短的程序的正确性是多么困难. 
我还在麦卡锡的论文中碰到一个问题. 在定义了eval之后，他继续给出了一些更高级的函数--接受其它函数作为自变量的函数. 他定义了maplist: 
(label maplist
(lambda (x f)
(cond ((null x) '())
('t (cons (f x) (maplist (cdr x) f))))))
然后用它写了一个做微分的简单函数diff. 但是diff传给maplist一个用x做参数的函数，对它的引用被maplist中的参数x所捕获.[6] 
这是关于动态可视域危险性的雄辩证据，即使是最早的更高级函数的例子也因为它而出错. 可能麦卡锡在1960年还没有充分意识到动态可视域的含意. 动态可视域令人惊异地在Lisp实现中存在了相当长的时间--直到Sussman和Steele于 1975年开发了Scheme. 词法可视域没使eval的定义复杂多少，却使编译器更难写了.
About this document
About this document ...Lisp之根源This document was generated using the LaTeX2HTML translator Version 2K.1beta (1.48) 
Copyright © 1993,1994,1995,1996,Nikos Drakos,Computer Based Learning Unit,University of Leeds. 
Copyright © 1997,1998,1999,Ross Moore,Mathematics Department,Macquarie University,Sydney. 
The command line arguments were: 
latex2html -split=0 roots_of_lisp.tex 
The translation was initiated by Dai Yuwen on 2003-10-24 
--------------------------------------------------------------------------------Footnotes[1] 欧几里德对几何的贡献. 
``Recursive Functions of Symbolic Expressions and Their Computation by Machine,Part1.'' Communication of the ACM 3:4,April 1960,pp. 184-195. 
[2]当表达式以七个原始操作符中的五个开头时，它的自变量总是要求值的.
[3]以另外两个操作符quote和cond开头的表达式以不同的方式求值. 当 quote表达式求值时，它的自变量不被求值，而是作为整个表达式的值返回. 在 一个正确的cond表达式中，只有L形路径上的子表达式会被求值. 
[4]逻辑上我们不需要为了这定义一个新的记号. 在现有的记号中用 一个叫做Y组合器的函数上的函数，我们可以定义递归函数. 可能麦卡锡在写 这篇论文的时候还不知道Y组合器； 无论如何，label可读性更强. 
没有实际可用的数，
在麦卡锡的1960 年的Lisp中，做算术是可能的，比如用一个有n个原子的表表示数n. 
... 的艺术''的著名论文中描述了如何做到这点.5 
Guy Lewis Steele,Jr. and Gerald Jay Sussman,``The Art of the Interpreter,or the Modularity Complex(Parts Zero,One,and Two),'' MIT AL Lab Memo 453,May 1978. 
... 对它的引用被maplist中的参数x所捕获.6 
当代的Lisp程序 员在这儿会用mapcar代替maplist. 这个例子解开了一个谜团： maplist为什 么会在Common Lisp中. 它是最早的映射函数，mapcar是后来增加的. 
--------------------------------------------------------------------------------
Common Lisp语言快速入门：
简介Lisp是软件领域的分裂力量。一方面，Lisp爱好者誓言Lisp比软件领域内的其它语言都更加快捷、整洁和强大；而反对者则辩称，不可靠的执行和库支持不足使得开发者难以在其中编写任何真正的软件。事实上，他们都有各自的道理。
第一版Lisp于大约50年前推出，这使得它和FORTRAN一样，成为现在仍在使用的最古老的编程语言之一。可以证明，它拥有（它们将会拥有）最庞大的特性列表，它也是第一种包括一整套今天我们全都认为是标准语言特性的语言，如垃圾收集、递归、函数作为对象、甚至是普通的if-then-else子句。同时，人们也认为它是一款优秀的教学语言：MIT使用方案、Lisp衍生物，传授它们的介绍性编程类。
我们将一起学习最强大和项目就绪的Lisp版本：Common Lisp，使其正常运行，并了解一些Lisp应用。为何选择Lisp？代码和数据并无差异——在Lisp中，代码只是一个函数对象列表。源代码和数据源之间不存在区别，允许Lisp把它的内在呈现给编译器、注释器和程序员。这允许你方便地本地读入和评估代码，甚至可以允许你使用宏。
宏——定义和重新定义任何语言元素。不喜欢条件、或循环或函数的运行方式吗？好，你可以定义自己的注释。如果你在代码中多次执行某个特定的任务，把那个特性添加到语言中不是更加方便吗？应用Lisp，你可以实现上述功能。
速度——虽然在许多情况下Common Lisp不如C或OCaml这类速度巨人快捷，但它在一系列测试中表现良好，特别是在执行一小段程序的情况下。了解一些基本的编译器知识，你就能够编写出处理列表和大型数字的代码，在执行速度和内存使用方面都要优于其它语言。
简化——Lisp的一切功能都基于一些基本的理念——一旦你了解那些理念，你就几乎能够处理任何问题。Lisp程序员常常自夸说，仅仅用几百行代码，你就能在几乎任何语言（如C++或Haskell）中执行一个Lisp注释器。
灵活——以你喜欢的任何方式编写代码。更喜欢功能性的编程方法吗？没问题！想要完全反复编程吗？草草写下几个快速的宏就可以完成任务。你可以用最方便最高效的方式编写程序，而且这些程序都能良好地运行。如何安装好，行了！我购买了Lisp，我如何进行安装呢？
这是棘手的问题。不像是Python或C#一样，Common Lisp没有标准执行——该语言由一个规范，而不是执行来定义。Common Lisp也没有C语言的优势：在每一个平台上都是一种支配性的执行或流行的执行。每个版本都应执行上述标准，但有一些细节要由编译器或注释器来处理，这使得每个执行都稍有不同。
你可以使用几种选项——在本文中我使用CLISP，它在Windows、Linux和Mac（仅PPC）上运行良好。如果你使用英特尔Mac，则必须使用其它执行，如Allegro Common Lisp或SBCL。对于这篇快速入门中的简单例子，你使用哪个执行都不要紧。
使用Lispbox可以快速安装Common Lisp系统，Lispbox为你提供一个Common Lisp执行、Emacs和SLIME——Emacs高级Lisp整合模式，许多Lisp程序员会告诉你说，它是使用Lisp的唯一方法。如果你并非Emacs用户（我本人也和你一样），不要担心，它并非必要条件，只是使得编写Common Lisp程序更加简便。
安装过程因平台而异，在Windows中你只能运行安装程序，多数Linux软件包管理器提供安装包等。选择一个执行并遵循安装指令即可。打开REPL（交互式提示符）之后再返回这里，我们继续往后讲。REPLREPL代表“阅读-评估-打印-循环”（Read-Evaluate-Print-Loop），它简单表示注释器的一个交互式提示符。你可以从这里输出一些简单的Lisp代码。如果你使用另一种注释器提示符，你可以在这里使用提示符作为计算器输出一些基本的数学表达式——但它不能正常运行。在CLISP中输入5*2不会返回任何有意义的结果：
[1]> 5 * 2
5
[2]> 
5
[3]> 
2
Lisp并非以那种方式运行，运算符，如“+”不是在数字之间，而是在数字前面，就好像它们是函数名称一样。因此，如果你想将REPL当作计算器使用，你必须输入：
[1]> (* 5 2)
10
[2]> (+ 1 2 3 4)
10
[3]> (+ (* 5 2) (* 10 3) (/ 100 4))
65
对你来说，理解这种用法可能更难一些，但它拥有一些优势：它便于编译器解析、它对所有函数和运算符都一样、它让你给函数添加尽可能多的自变量——例如，在上面的第二个例子中，你可以任意扩充加数，使得加法函数和总计函数完全一样。
另外你会注意到，函数名在括号内，而不像许多其它语言一样函数名在括号以外。这表示你要写（函数自变量）而不是函数（自变量）。
每个Lisp表达式会返回一个值，一个函数总是返回最后一个表达式的结果——即使是NIL，NULL在Java或C++中的对等值也是这样。因此在Lisp中显示“Hello World”相当简单：
[3]> "Hello World"
"Hello World"
如果你希望在屏幕上打印一些内容，并返回其它内容，你应该使用打印函数：
[4]> (print "Hello World")
"Hello World" 
"Hello World"
这个字符串显示两次，一个是打印结果，一个是函数返回的结果。
Lisp表示LIST Processor（列表处理器），Lisp中的几乎所有内容都以列表的形式存在，因此有时你必须处理列表。定义列表非常容易：
[5]> (list 1 2 3 4 5)
(1 2 3 4 5)
[6]> '(1 2 3 4 5)
(1 2 3 4 5)
第二种定义方法叫做引用，除定义简单的列表外，它还有更多用途，不过我们必须在后面的另一篇文章中讨论那个主题。控制流程Lisp拥有全部标准控制流程方法。定义一个重复一个值的简单循环相当容易：
[7]> (dotimes (i 10) (print i))0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
NIL
同样，重复一个列表也很简单：
[8]> (dolist (i '(0 1 2 3 4 5 6 7 8 9)) (print i))
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
NIL
以上两个函数都是DO函数的特殊版本，它就像在其它语言中组合使用while和for函数一样。它由三个部分组成：循环变更定义、终止条件和语句主体：
[9]> (do ((i 0 (+ 1 i))) ((> i 10)) (print i))
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
NIL
在这个例子中，变更定义部分为（（i 0 (+ 1 i)))，它定义变量i为0，并在每次循环时调用函数（+ 1 0）。终止条件为（（> i 10）），表示在i大于10时函数终止运行。最后主体部分打印i的值。
Lisp中也有条件函数，最基本的条件函数为if函数：
[10]> (if (> 10 20) (print "Hello") (print "World"))
"World" 
"World"
if函数由三部分组成：条件、then语句和else语句。如果条件为真，则执行then语句，否则就执行else语句。
你可能已经注意到，到现在为止我们仅使用了单个的语句——但如果你需要把几个语句连接在一起，那该怎么办呢？在Lisp中，要将几个语句连接起来，你需要使用progn这个特殊的控制流程函数：
[11]> (progn (print "Hello") (print "World"))
"Hello" 
"World" 
"World"
例如，上例允许你在条件函数和循环中使用几个语句。
好了，以上内容已足以让你初步认识Common Lisp语言：通过你了解的内容，你可以编写出一些微型程序，对Lisp语言进行测试。请密切关注本系列的下一篇文章，到时我们将介绍Lisp独特的列表处理机制。