2024-08-22 |欢迎您，第位读者！|

005 好奇先生用Lisp来探索Lisp

鲁莽先生什么都不管

鲁莽先生打开电脑，安装一堆东西，噼里啪啦敲了一堆代码，叽里呱啦说了一堆话，然后累了就回家睡觉了。

这可把好奇先生的兴趣勾起来，他怎么也睡不着。好奇先生打开电脑，看了看鲁莽先生留下的代码和可执行文件，然后开始研究起来。

好奇先生第一次见到Lisp

好奇先生看到了一堆括号，他不知道这是什么，但是他知道这是一种编程语言，于是他开始查资料，了解到这是一种叫做Lisp的语言。

这个语言最大的特点就是括号，括号里面是函数名，括号外面是参数。因为括号很多，Lisp也被称为Lots of Irritating Silly Parentheses（许多令人烦恼的愚蠢括号）。

真是好玩啊！好奇先生想，真想要试试看。

好奇先生按照鲁莽先生的说明，安装SBCL，然后打开REPL，输入了一行代码：

1This is SBCL 2.4.6, an implementation of ANSI Common Lisp.
2More information about SBCL is available at <http://www.sbcl.org/>.
3
4SBCL is free software, provided as is, with absolutely no warranty.
5It is mostly in the public domain; some portions are provided under
6BSD-style licenses.  See the CREDITS and COPYING files in the
7distribution for more information.
8* (+ 1 2)
93

好的，这下可以做加法啦！实际上，Lisp的加法可以加多个数：

1(+ 1 2 3 4 5 6)
221

这不是很好理解吗？括号里面是一个列表，列表的第一个元素是+，后面的元素是被加的数字。画出来就是这样的：

graph TD
    +[+add] --> 1[1]
    + --> 2[2]
    + --> 3[3]
    + --> 4[4]
    + --> 5[5]
    + --> 6[6]

这不算什么，好奇先生想，我可以用Lisp来做更复杂的事情。

1(+ 1 (* 2 3) (- 4 5))
26

再按照上面的方法画出来：

graph TD
    +[+add] --> 1[1]
    + --> *[*times]
    * --> 2[2]
    * --> 3[3]
    + --> -[-minus]
    - --> 4[4]
    - --> 5[5]

1 + 2 * 3 + (4 - 5) = 6 ，结果是6。其实很直观！

好奇先生觉得自己完全懂了：每个列表第一个元素是要干什么，后面的元素是对谁干。而且，后面的元素也可以是列表，这个列表的第一个元素同样是要干什么，后面的元素是对谁干。

好奇先生更好奇了

好奇先生觉得自己完全懂了，Lisp的代码就是一个括号套住的内容（包括括号本身），可以称为表达式（expression），表达式的左边一个括号，右边一个括号，中间是一个操作符（operator）和零个或多个操作数（operand）。

1<left_parenthesis> = "("
2<right_parenthesis> = ")"
3<expression> ::= <left_parenthesis> <operator> <operand>* <right_parenthesis>
4<operand> ::= <expression> | <???>

这个<operator>是什么？这个<operand>是什么？到底是几个？为什么还能是0个？这个<???>是什么？好奇先生更好奇了。

好奇先生继续研究

好奇先生因为很好奇，早就学过无数种编程语言，他能理解这个<operator>是一个函数或者方法或者操作符，比如+、-、*、/、sin、cos、tan、sqrt、log、exp等等。而这个<operand>是一个值，或者一个变量。当然，无论是值或者变量，其实都有一个很本质的含义，就是内存中的一块区域，这个区域在某些程序设计语言中，表达为地址头、内存长度，这两个两可以完全定位这个区域。但是在Lisp中，到底是什么呢？

Lisp的数据类型

好奇先生查了一下，Lisp中貌似就只有两类大类数据类型：列表（list）和原子（atom）。

列表
- 由括号括起来的列表
- 列表的元素可以是列表
- 列表的元素可以是atom
- listp可以判断是否是列表
Atom，中文直译为原子，在这里可以理解为不可再分的最小单位，比如：
- 数字，numberp可以判断是否是数字
- 字符串，stringp可以判断是否是字符串
- 符号，symbolp可以判断是否是符号
- 函数，functionp可以判断是否是函数

通过这些操作符（函数）就能够探索各种对象的类型。好奇先生对自己的说法又有了亿点点更多的好奇。对象？什么对象？Lisp里面操作的是什么？好奇先生继续研究。

Lisp中的字面量

字面量，就是直接表示的值，比如1、"hello"、'a、t、nil、:my-key等等。这些值是直接表示的，不需要计算，不需要解释，不需要转换，就是它们自己。实际上，这些值就是Lisp中基本被操作的对象。并非是面向对象编程中的对象。

那么，跟C中间每个量实际上都是一块内存区域是否一样呢？好奇先生不停地问出新问题。

啊，问题太多了，太多啦！好奇先生觉得自己的好奇心已经被点燃了，他决定继续研究，继续探索，继续学习。

好奇先生工具箱

好奇先生每次到第一个新地方，总是最先想知道公共交通能到哪里，所以在打探一个新的编程语言时，他总是先找找有没有什么探索工具可以用。

比如上面的type-of，以及哪些判断类型的命令。此外，lisp还有一些其他的工具，比如：

list-all-packages，可以列出所有的包
do-external-symbols，可以遍历一个包中的所有符号
apropos，可以找到一个符号的定义

好奇先生最喜欢这种工具箱！用这些工具，他就能探索这个SBCL世界！

packages

Common Lisp中的包（package）是一种组织符号的方式，可以把符号分组，然后通过包的名字来访问这些符号。比如，cl-user包中有+这个符号，那么我们可以通过cl-user:+来访问这个符号。

1(apropos 'list-all-packages)
2
3;; LIST-ALL-PACKAGES (fbound)
4;; NIL

好像没有提供太多的信息。

 1(list-all-packages)
 2
 3;; (#<PACKAGE "QUICKLISP-CLIENT"> #<PACKAGE "UIOP/FILESYSTEM">
 4;; #<PACKAGE "ALIVE/SBCL/SYMBOLS"> #<PACKAGE "IMPL-SPECIFIC-GRAY">
 5;; #<PACKAGE "QL-IMPL"> #<PACKAGE "UIOP/DRIVER"> #<PACKAGE "ALIVE/INSPECTOR">
 6;; #<PACKAGE "SB-WALKER"> #<PACKAGE "ASDF/FIND-COMPONENT"> #<PACKAGE "SB-MOP">
 7;; #<PACKAGE "UIOP/PACKAGE"> #<PACKAGE "ASDF/BACKWARD-INTERNALS">
 8;; #<PACKAGE "ALIVE/LSP/TYPES/FORMAT-OPTIONS"> #<PACKAGE "QL-MKCL">
 9;; #<PACKAGE "SB-BIGNUM"> #<PACKAGE "ALIVE/PACKAGES">
10;; #<PACKAGE "UIOP/BACKWARD-DRIVER"> #<PACKAGE "ALIVE/UTILS">
11;; #<PACKAGE "UIOP/LAUNCH-PROGRAM"> #<PACKAGE "ALIVE/SBCL/THREADS">
12;; #<PACKAGE "ASDF/FOOTER"> #<PACKAGE "ALIVE/SESSION"> #<PACKAGE "SB-REGALLOC">
13;; #<PACKAGE "QL-CMUCL"> #<PACKAGE "SB-PCL"> #<PACKAGE "QL-CCL">
14;; #<PACKAGE "SB-EXT"> #<PACKAGE "ASDF/OPERATE"> #<PACKAGE "ALIVE/RANGE">
15;; #<PACKAGE "ALIVE/FILE"> #<PACKAGE "UIOP/RUN-PROGRAM">
16;; #<PACKAGE "ALIVE/LSP/DEFINITION"> #<PACKAGE "ASDF/PARSE-DEFSYSTEM">
17;; #<PACKAGE "ALIVE/LSP/COMPLETIONS"> #<PACKAGE "ALIVE/STREAMS">
18;; #<PACKAGE "QL-DIST-USER"> #<PACKAGE "ALIVE/SBCL/FILE"> #<PACKAGE "QL-INFO">
19;; #<PACKAGE "SB-SYS"> #<PACKAGE "QL-CONFIG"> #<PACKAGE "ALIVE/LSP/UTILS">
20;; #<PACKAGE "ALIVE/SBCL/STREAMS"> #<PACKAGE "ALIVE/LSP/TYPES/SEM-TOKENS">
21;; #<PACKAGE "SB-DISASSEM"> #<PACKAGE "BORDEAUX-THREADS">
22;; #<PACKAGE "ALIVE/LSP/PACKET"> #<PACKAGE "ALIVE/LSP/MESSAGE/RESPONSE">
23;; #<PACKAGE "SB-FASL"> #<PACKAGE "UIOP/UTILITY"> #<PACKAGE "JSON-SYSTEM">
24;; #<PACKAGE "QL-SETUP"> #<PACKAGE "SB-POSIX"> #<PACKAGE "ALIVE/PARSE/TOKENIZER">
25;; #<PACKAGE "ASDF/FIND-SYSTEM"> #<PACKAGE "SB-UNICODE">
26;; #<PACKAGE "FLEXI-STREAMS-SYSTEM"> #<PACKAGE "ASDF/CONCATENATE-SOURCE">
27;; #<PACKAGE "SB-DEBUG"> #<PACKAGE "ALIVE/FORMAT"> #<PACKAGE "QL-UTIL">
28;; #<PACKAGE "SB-LOCKLESS"> #<PACKAGE "SB-ALIEN-INTERNALS">
29;; #<PACKAGE "BORDEAUX-THREADS-2"> #<PACKAGE "SB-ALIEN">
30;; #<PACKAGE "ALEXANDRIA-2"> #<PACKAGE "QL-SCL"> #<PACKAGE "ASDF/USER">
31;; #<PACKAGE "ALIVE/TYPES"> #<PACKAGE "ALIVE/THREADS">
32;; #<PACKAGE "SPLIT-SEQUENCE"> #<PACKAGE "ASDF/COMPONENT">
33;; #<PACKAGE "ASDF/FORCING"> #<PACKAGE "QL-GUNZIPPER"> #<PACKAGE "SB-INTROSPECT">
34;; #<PACKAGE "UIOP/STREAM"> #<PACKAGE "ASDF/PACKAGE-INFERRED-SYSTEM">
35;; #<PACKAGE "SB-PRETTY"> #<PACKAGE "ASDF/SOURCE-REGISTRY">
36;; #<PACKAGE "SB-SEQUENCE"> #<PACKAGE "ASDF/SYSTEM-REGISTRY">
37;; #<PACKAGE "SB-APROF"> #<PACKAGE "ALIVE/POSITION"> #<PACKAGE "SB-PROFILE">
38;; #<PACKAGE "ALIVE/COMPILE-MESSAGE"> #<PACKAGE "ALEXANDRIA">
39;; #<PACKAGE "UIOP/OS"> #<PACKAGE "QL-NETWORK"> #<PACKAGE "ASDF/LISP-ACTION">
40;; #<PACKAGE "ALIVE/LSP/HOVER"> #<PACKAGE "ALIVE/LSP/SYMBOL">
41;; #<PACKAGE "ASDF/PLAN"> #<PACKAGE "ALIVE/LOGGER"> #<PACKAGE "SB-C">
42;; #<PACKAGE "QL-BUNDLE"> #<PACKAGE "UIOP/PATHNAME"> #<PACKAGE "SB-BSD-SOCKETS">
43;; #<PACKAGE "ALIVE/TEXT-EDIT"> #<PACKAGE "ASDF/SESSION"> #<PACKAGE "JSON">
44;; #<PACKAGE "ALIVE/SELECTION"> #<PACKAGE "QL-HTTP"> #<PACKAGE "ASDF/INTERFACE">
45;; #<PACKAGE "ASDF/OUTPUT-TRANSLATIONS"> #<PACKAGE "ALIVE/LSP/PARSE">
46;; #<PACKAGE "QL-MINITAR"> #<PACKAGE "ASDF/ACTION"> #<PACKAGE "UIOP/VERSION">
47;; #<PACKAGE "ALIVE/LSP/MESSAGE/REQUEST"> #<PACKAGE "SB-THREAD">
48;; #<PACKAGE "QL-SBCL"> #<PACKAGE "ASDF/BUNDLE"> #<PACKAGE "KEYWORD">
49;; #<PACKAGE "ALIVE/EVAL"> #<PACKAGE "ALIVE/PARSE/FORMS">
50;; #<PACKAGE "ALIVE/LSP/MESSAGE/ABSTRACT"> #<PACKAGE "SB-LOOP">
51;; #<PACKAGE "SB-DI"> #<PACKAGE "SB-UNIX"> #<PACKAGE "UIOP/CONFIGURATION">
52;; #<PACKAGE "UIOP/IMAGE"> #<PACKAGE "SB-IMPL"> #<PACKAGE "SB-GRAY">
53;; #<PACKAGE "COMMON-LISP-USER"> #<PACKAGE "SB-BROTHERTREE">
54;; #<PACKAGE "ASDF/OPERATION"> #<PACKAGE "ALIVE/DEBUGGER">
55;; #<PACKAGE "QL-IMPL-UTIL"> #<PACKAGE "ALIVE/PARSE/TOKEN">
56;; #<PACKAGE "ALIVE/LSP/SEM-ANALYSIS"> #<PACKAGE "ALIVE/MACROS">
57;; #<PACKAGE "QL-LISPWORKS"> #<PACKAGE "SB-VM"> #<PACKAGE "GLOBAL-VARS">
58;; #<PACKAGE "SB-ASSEM"> #<PACKAGE "UIOP/COMMON-LISP">
59;; #<PACKAGE "ALIVE/LSP/TYPES/CONFIG-ITEM"> #<PACKAGE "TRIVIAL-GARBAGE">
60;; #<PACKAGE "ASDF/BACKWARD-INTERFACE"> #<PACKAGE "ALIVE/LSP/TYPES/RESTART-INFO">
61;; #<PACKAGE "SB-FORMAT"> #<PACKAGE "ASDF/UPGRADE"> #<PACKAGE "SB-INT">
62;; #<PACKAGE "QL-CLISP"> #<PACKAGE "USOCKET"> #<PACKAGE "ALIVE/PARSE/FORM">
63;; #<PACKAGE "ALIVE/LSP/MESSAGE/NOTIFICATION"> #<PACKAGE "SB-WIN32">
64;; #<PACKAGE "ALIVE/SYMBOLS"> #<PACKAGE "SB-EVAL"> #<PACKAGE "SB-X86-64-ASM">
65;; #<PACKAGE "QL-MEZZANO"> #<PACKAGE "QL-PROGRESS"> #<PACKAGE "QL-ALLEGRO">
66;; #<PACKAGE "COMMON-LISP"> #<PACKAGE "ALIVE/SERVER">
67;; #<PACKAGE "ALIVE/LSP/MESSAGE/FORMAT-UTILS"> #<PACKAGE "QL-CDB">
68;; #<PACKAGE "ALIVE/ERRORS"> #<PACKAGE "ALIVE/FRAMES"> #<PACKAGE "JSON-RPC">
69;; #<PACKAGE "QL-CLASP"> #<PACKAGE "UIOP/LISP-BUILD"> #<PACKAGE "SB-KERNEL">
70;; #<PACKAGE "FLEXI-STREAMS"> #<PACKAGE "TRIVIAL-GRAY-STREAMS">
71;; #<PACKAGE "ASDF/SYSTEM"> #<PACKAGE "QL-DIST"> #<PACKAGE "ALIVE/LSP/ERRORS">
72;; #<PACKAGE "QL-ECL"> #<PACKAGE "ALIVE/ASDF">
73;; #<PACKAGE "SB-BSD-SOCKETS-INTERNAL"> #<PACKAGE "QL-ABCL">)

原来好奇先生已经安装这么多有用的（或者没用的）包。

还可以自己定义一个包，并且看看自己定义的包是不是能被找到。好奇先生看到结果，高兴得不得了。

1(let ((before (list-all-packages))) 
2  (make-package 'temp) 
3  (set-difference (list-all-packages) before))
4
5;; (#<PACKAGE "TEMP">)

当然，我们还可以查找一个包，这里用的是find-package。

1(find-package 'cl-user)
2(find-package :cl-user)
3(find-package "CL-USER")

这三种形式都可以，只是注意，最后那个用字符串的方式，必须是大写的。太麻烦，好奇先生动动手指，写了一个函数。

1(defun find-package-ignore-case (name)
2  "Find a package by name, ignoring case"
3  (if (stringp name)
4      (find-package (string-upcase name))
5      (find-package name)))

这下子，就可以直接忽视大小写了。那么，能不能用一个包的名字的一部分来查找一个包呢？好奇先生又动动手指，写了一个函数。

 1(defun part-in-list-p (part list)
 2  "Return true if any element of list contains part"
 3  (find-if (lambda (x) (search part x)) list))
 4
 5(defun find-package-with-part (part)
 6  "Find a package by part of its name or nickname"
 7  (let ((result '())
 8        (part-upcase (string-upcase part)))
 9    (dolist (package (list-all-packages))
10      (if (or (search part-upcase (package-name package))
11              (part-in-list-p part-upcase (package-nicknames package)))
12          (push package result)))
13    result))

第一个函数，用来在一个列表中找到是否包含一个字符串，如果包含，就返回真。第二个函数，用来查找一个包的名字或者别名中是否包含一个字符串。

1(find-package-with-part "cl")
2; (#<PACKAGE "QL-ABCL"> #<PACKAGE "QL-ECL"> #<PACKAGE "QL-CLASP">
3;  #<PACKAGE "COMMON-LISP"> #<PACKAGE "QL-CLISP"> #<PACKAGE "UIOP/COMMON-LISP">
4;  #<PACKAGE "COMMON-LISP-USER"> #<PACKAGE "QL-SBCL"> #<PACKAGE "JSON">
5;  #<PACKAGE "QL-SCL"> #<PACKAGE "ALIVE/SBCL/STREAMS">
6;  #<PACKAGE "ALIVE/SBCL/FILE"> #<PACKAGE "QL-CCL"> #<PACKAGE "SB-PCL">
7;  #<PACKAGE "QL-CMUCL"> #<PACKAGE "ALIVE/SBCL/THREADS"> #<PACKAGE "QL-MKCL">
8;  #<PACKAGE "ALIVE/SBCL/SYMBOLS"> #<PACKAGE "QUICKLISP-CLIENT">)

现在，好奇先生对自己系统中的包了如指掌，完全满足了他的部分好奇心，因为好奇先生的好奇先生是无穷无尽的！知道自己的系统中有这么多包之后，好奇先生的好奇心简直要爆炸了，每个包里到底有什么？

包里有什么呢？当然是symbols

粗鲁先生看到好奇先生噼里啪啦地敲着键盘，嘴里念念有词，突然听到一句”包里有什么呢？“，他大声回答：“当然是符号啦！”好奇先生听到这个回答，觉得很有道理，于是他开始查找一个包里面的所有符号。

1
2;; list all external symbols in a package
3(defun dir (package)
4  (let ((result '())
5        (len 0))
6    (do-external-symbols (s package (values result len))
7      ;   (format t "~a~%" s)
8      (push s result)
9      (incf len))))

因为这就像是列出一个目录的文件，好奇先生当然把这个函数命名为dir。

  1(dir (find-package 'cl))
  2; (READ-BYTE FIND-PACKAGE ROUND LET* +++ COPY-SYMBOL BREAK ARRAY
  3;            LISP-IMPLEMENTATION-TYPE PPRINT-FILL REMHASH FILE-LENGTH FLOOR
  4;            MOST-POSITIVE-LONG-FLOAT STRING= BOOLE-C1 LOGNAND BIT-IOR
  5;            SYNONYM-STREAM-SYMBOL STANDARD-GENERIC-FUNCTION
  6;            GET-INTERNAL-REAL-TIME DESCRIBE-OBJECT IN-PACKAGE SET
  7;            *COMPILE-FILE-PATHNAME* ISQRT PROBE-FILE UNION VECTOR MEMBER-IF-NOT
  8;            LOGBITP STREAM-ERROR-STREAM APPEND NSUBLIS PATHNAME
  9;            SET-DISPATCH-MACRO-CHARACTER CDAADR PROG SYNONYM-STREAM CONJUGATE
 10;            LOGTEST SPECIAL NIL DOUBLE-FLOAT-EPSILON SHADOW TRACE SYMBOL-PLIST
 11;            CADAR DELETE-FILE COPY-ALIST PATHNAME-DIRECTORY SIN SHIFTF
 12;            STANDARD-METHOD TYPE PROG1 FLOAT-SIGN BIT-AND PLUSP COMPILER-MACRO
 13;            NOT STREAM-ELEMENT-TYPE CADDDR STRING<= ADJOIN REMPROP CHAR-EQUAL
 14;            RETURN-FROM LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT BOOLE-CLR LCM
 15;            POSITION HANDLER-CASE COMPUTE-APPLICABLE-METHODS DEFMETHOD BOOLE-1
 16;            CONTROL-ERROR CLASS CHAR-LESSP DELETE-PACKAGE
 17;            BROADCAST-STREAM-STREAMS LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT NULL
 18;            FIFTH EXP WITH-OUTPUT-TO-STRING FTRUNCATE LAST STRING-CAPITALIZE
 19;            MAPCON CDDDDR LOGORC2 PRINT-OBJECT >= USER-HOMEDIR-PATHNAME
 20;            *MODULES* CAAADR SLOT-MISSING RATIONALIZE TANH BIT-EQV ///
 21;            ROW-MAJOR-AREF *LOAD-PATHNAME* *PRINT-ESCAPE* READTABLE-CASE NCONC
 22;            BOOLE-2 STANDARD-CLASS SIMPLE-BIT-VECTOR COUNT-IF BOOLE-SET
 23;            DEFPARAMETER ZEROP DYNAMIC-EXTENT FILE-STRING-LENGTH STRUCTURE
 24;            RPLACD SET-MACRO-CHARACTER CHAR/= SYMBOL-MACROLET CAAAR // *PACKAGE*
 25;            WITH-OPEN-FILE DEFSTRUCT TWO-WAY-STREAM ASSOC-IF-NOT SHORT-FLOAT
 26;            EXTENDED-CHAR < READ-CHAR-NO-HANG LOGAND ECHO-STREAM-INPUT-STREAM T
 27;            CHAR< FUNCTION BOOLE-ORC2 *MACROEXPAND-HOOK* STRING/= FBOUNDP /
 28;            RASSOC EVAL-WHEN CLRHASH WARN AND LISTEN RANDOM-STATE
 29;            SPECIAL-OPERATOR-P SYMBOL-PACKAGE COMPILATION-SPEED *LOAD-PRINT*
 30;            PPRINT-POP SEARCH LONG-FLOAT-EPSILON *TERMINAL-IO* CDDDAR
 31;            ADJUST-ARRAY MAKE-PATHNAME KEYWORD MERGE NO-APPLICABLE-METHOD
 32;            *PRINT-PPRINT-DISPATCH* VECTOR-POP SEQUENCE BIGNUM POP CHAR SETQ MOD
 33;            SIMPLE-STRING-P CERROR MAKE-ECHO-STREAM STRING-NOT-LESSP
 34;            *PRINT-BASE* UPDATE-INSTANCE-FOR-DIFFERENT-CLASS
 35;            FLOATING-POINT-UNDERFLOW HASH-TABLE-REHASH-THRESHOLD INCF LDB-TEST
 36;            LIST MEMBER-IF ARRAY-HAS-FILL-POINTER-P OPEN-STREAM-P THIRD &WHOLE
 37;            BIT-NOT GENSYM CCASE BOOLE-XOR SET-SYNTAX-FROM-CHAR DOLIST
 38;            ALPHANUMERICP STRING-STREAM MOST-NEGATIVE-SINGLE-FLOAT ELT TRUENAME
 39;            NSTRING-DOWNCASE LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT *READ-BASE*
 40;            NSET-DIFFERENCE THROW PHASE THE BIT-ANDC1 ASSERT ACOS
 41;            WILD-PATHNAME-P CDR DIGIT-CHAR-P MACROEXPAND-1 NSET-EXCLUSIVE-OR
 42;            TYPECASE PPRINT-INDENT CDADR CLASS-NAME COMPILE-FILE-PATHNAME
 43;            FDEFINITION RASSOC-IF APROPOS-LIST INTEGER-LENGTH *READ-SUPPRESS*
 44;            UNLESS NSTRING-CAPITALIZE FTYPE BUILT-IN-CLASS ** MAKE-CONDITION
 45;            STRING ENCODE-UNIVERSAL-TIME BIT-ANDC2 HASH-TABLE-SIZE CELL-ERROR
 46;            ATANH RATIONALP NAME-CHAR SET-DIFFERENCE BIT-NAND CONDITION
 47;            CHAR-GREATERP &OPTIONAL DISASSEMBLE ERROR CADDR SAFETY CHAR-CODE
 48;            WARNING ENDP *PRINT-RADIX* STANDARD-OBJECT MAPCAN PATHNAMEP
 49;            TWO-WAY-STREAM-OUTPUT-STREAM FMAKUNBOUND ARRAY-ROW-MAJOR-INDEX
 50;            SUBSEQ LOAD DELETE-IF-NOT UNBOUND-SLOT-INSTANCE LOGORC1 OPTIMIZE
 51;            STRING< STABLE-SORT NSUBSTITUTE DIGIT-CHAR ENOUGH-NAMESTRING
 52;            BYTE-POSITION PPRINT-LOGICAL-BLOCK SUBSTITUTE-IF TAILP
 53;            FLOATING-POINT-INEXACT EQL FIND-METHOD FLET ARRAY-TOTAL-SIZE-LIMIT
 54;            UNUSE-PACKAGE RATIO LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT
 55;            GET-DISPATCH-MACRO-CHARACTER MAKE-SEQUENCE NBUTLAST NRECONC MACROLET
 56;            CHAR<= MINUSP PRINT-UNREADABLE-OBJECT LOWER-CASE-P STANDARD
 57;            HASH-TABLE-COUNT FLOAT-PRECISION REVAPPEND CALL-ARGUMENTS-LIMIT
 58;            READ-FROM-STRING UNDEFINED-FUNCTION COPY-READTABLE ASIN
 59;            DEFINE-SETF-EXPANDER HANDLER-BIND
 60;            LEAST-POSITIVE-NORMALIZED-LONG-FLOAT PPRINT-TAB NUNION REALP
 61;            POSITION-IF BOOLE-ANDC1 ABORT NUMBER DECLAIM COMPILED-FUNCTION-P
 62;            PACKAGE-USED-BY-LIST CHAR-NOT-LESSP WITH-INPUT-FROM-STRING
 63;            SIMPLE-WARNING STORE-VALUE *COMPILE-VERBOSE* DELETE-DUPLICATES
 64;            MOST-NEGATIVE-FIXNUM DELETE AREF DEFUN STREAM-ERROR BOOLE-C2
 65;            PPRINT-LINEAR MULTIPLE-VALUE-SETQ FILE-STREAM STRING-TRIM
 66;            REMOVE-IF-NOT UNREAD-CHAR OTHERWISE DESCRIBE RPLACA WRITE-SEQUENCE
 67;            MIN SOFTWARE-VERSION *PRINT-LEVEL* SECOND CHECK-TYPE PPRINT BUTLAST
 68;            BASE-CHAR COMPLEXP PATHNAME-NAME SLOT-UNBOUND ODDP PRIN1-TO-STRING
 69;            STRING-RIGHT-TRIM COMPILE-FILE ++ FILE-ERROR-PATHNAME PRINC
 70;            GET-PROPERTIES MOST-POSITIVE-FIXNUM MAKE-LOAD-FORM-SAVING-SLOTS
 71;            REALPART DIRECTORY CDADAR CONSTANTLY
 72;            FLOATING-POINT-INVALID-OPERATION NOTANY PATHNAME-MATCH-P DECF MEMBER
 73;            MULTIPLE-VALUE-PROG1 DEFGENERIC IDENTITY CHAR-CODE-LIMIT VECTOR-PUSH
 74;            DEFINE-SYMBOL-MACRO + GETF LEAST-NEGATIVE-LONG-FLOAT CHAR-DOWNCASE
 75;            LEAST-NEGATIVE-DOUBLE-FLOAT SINGLE-FLOAT-NEGATIVE-EPSILON
 76;            ADJUSTABLE-ARRAY-P SUBTYPEP *FEATURES* NUMBERP FILE-ERROR
 77;            POSITION-IF-NOT > DEFPACKAGE PPRINT-DISPATCH
 78;            MOST-POSITIVE-SINGLE-FLOAT SUBSTITUTE-IF-NOT COMPILED-FUNCTION LOG
 79;            DO* PARSE-INTEGER SIMPLE-ERROR LEAST-NEGATIVE-SINGLE-FLOAT
 80;            DEFINE-COMPILER-MACRO LOGANDC2 KEYWORDP FIND-ALL-SYMBOLS BIT-ORC1
 81;            *PRINT-CIRCLE* ARRAY-DIMENSION-LIMIT CAAR SPACE DOCUMENTATION
 82;            UPGRADED-COMPLEX-PART-TYPE STREAM PROGRAM-ERROR PUSHNEW MASK-FIELD
 83;            CHARACTERP LDIFF DIRECTORY-NAMESTRING LOOP-FINISH DPB
 84;            CHAR-NOT-GREATERP LENGTH LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT
 85;            DRIBBLE SLOT-VALUE PPRINT-TABULAR SIMPLE-BASE-STRING SIGNED-BYTE
 86;            PACKAGE-ERROR-PACKAGE DEFINE-MODIFY-MACRO SHORT-SITE-NAME
 87;            ARRAY-RANK-LIMIT CODE-CHAR FUNCALL DEPOSIT-FIELD MAKE-ARRAY ED
 88;            COPY-PPRINT-DISPATCH BIT-ORC2 LOGICAL-PATHNAME FIND-SYMBOL
 89;            WRITE-STRING DO WRITE-BYTE CHAR-NOT-EQUAL MAPLIST BOOLEAN
 90;            ECHO-STREAM MAPL NSUBST-IF DEFTYPE EVAL USE-VALUE
 91;            TRANSLATE-LOGICAL-PATHNAME PRINT-NOT-READABLE-OBJECT PROG2
 92;            SUBSTITUTE *PRINT-PRETTY* TENTH FFLOOR STRING-NOT-EQUAL
 93;            INVOKE-RESTART-INTERACTIVELY /= DO-SYMBOLS MAP-INTO CTYPECASE
 94;            MULTIPLE-VALUE-BIND FOURTH CAADR MOST-NEGATIVE-SHORT-FLOAT &BODY
 95;            BOOLE *TRACE-OUTPUT* LOAD-LOGICAL-PATHNAME-TRANSLATIONS
 96;            SHORT-FLOAT-NEGATIVE-EPSILON ACOSH ALPHA-CHAR-P SIMPLE-ARRAY
 97;            PACKAGE-NAME RANDOM APROPOS DEBUG HASH-TABLE-P OR INVOKE-DEBUGGER
 98;            PRINT-NOT-READABLE CHAR-INT MAKE-SYNONYM-STREAM
 99;            MAKE-DISPATCH-MACRO-CHARACTER SIMPLE-BIT-VECTOR-P COUNT FILL
100;            IGNORE-ERRORS LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT
101;            LOGICAL-PATHNAME-TRANSLATIONS DO-ALL-SYMBOLS REVERSE MAKUNBOUND SOME
102;            DECODE-UNIVERSAL-TIME SHORT-FLOAT-EPSILON COMPILER-MACRO-FUNCTION
103;            RETURN PATHNAME-VERSION SUBLIS FIND-IF *STANDARD-INPUT*
104;            MAKE-INSTANCE CLEAR-INPUT SINGLE-FLOAT-EPSILON MAKE-SYMBOL IMPORT
105;            *PRINT-GENSYM* LET CADDAR BIT-VECTOR NSTRING-UPCASE
106;            UPGRADED-ARRAY-ELEMENT-TYPE MULTIPLE-VALUE-LIST NUMERATOR =
107;            SIMPLE-VECTOR-P SCALE-FLOAT ARITHMETIC-ERROR-OPERANDS PROG*
108;            BOOLE-NAND UNTRACE INPUT-STREAM-P PSETF READTABLE METHOD-QUALIFIERS
109;            FILE-POSITION USE-PACKAGE SYMBOL-VALUE NEXT-METHOD-P SIMPLE-STRING
110;            GRAPHIC-CHAR-P STREAMP CDDAAR CALL-NEXT-METHOD
111;            MOST-NEGATIVE-DOUBLE-FLOAT FILE-AUTHOR WHEN TYPE-OF BIT-NOR CHAR>
112;            SINGLE-FLOAT ENSURE-GENERIC-FUNCTION PI *RANDOM-STATE* PSETQ EQ
113;            HASH-TABLE EVENP *PRINT-RIGHT-MARGIN* OPEN REQUIRE GENTEMP
114;            *READTABLE* MAKE-STRING-OUTPUT-STREAM CDAR LOGEQV DEFINE-CONDITION
115;            CLASS-OF SIMPLE-CONDITION-FORMAT-CONTROL STANDARD-CHAR PACKAGE-ERROR
116;            LOAD-TIME-VALUE PACKAGE 1- PROGV STORAGE-CONDITION <= FORMATTER
117;            FILE-WRITE-DATE BOOLE-NOR UPDATE-INSTANCE-FOR-REDEFINED-CLASS TAN
118;            END-OF-FILE IMAGPART BIT-VECTOR-P EQUAL FIND-CLASS DEFMACRO Y-OR-N-P
119;            REST PATHNAME-DEVICE FUNCTION-KEYWORDS SET-EXCLUSIVE-OR NAMESTRING
120;            HASH-TABLE-REHASH-SIZE GET-DECODED-TIME *COMPILE-PRINT*
121;            CELL-ERROR-NAME INTEGERP ABS FLOAT-DIGITS SIMPLE-VECTOR
122;            MOST-NEGATIVE-LONG-FLOAT FIND-RESTART IF REMF
123;            DEFINE-METHOD-COMBINATION SHADOWING-IMPORT COMPLEX GO
124;            WITH-HASH-TABLE-ITERATOR SET-PPRINT-DISPATCH CONCATENATED-STREAM
125;            TYPE-ERROR-DATUM SLOT-MAKUNBOUND LEAST-POSITIVE-SINGLE-FLOAT
126;            MAKE-INSTANCES-OBSOLETE SORT NSUBST PRINC-TO-STRING
127;            TYPE-ERROR-EXPECTED-TYPE VALUES-LIST YES-OR-NO-P FLOAT-RADIX SIGNUM
128;            READ-SEQUENCE *BREAK-ON-SIGNALS* MULTIPLE-VALUES-LIMIT CONCATENATE
129;            PPRINT-NEWLINE COPY-TREE &REST &ENVIRONMENT METHOD-COMBINATION-ERROR
130;            *GENSYM-COUNTER* STRUCTURE-CLASS ETYPECASE PARSE-ERROR
131;            STRING-DOWNCASE * MAP SUBST-IF *DEBUG-IO* STRING-LEFT-TRIM SYMBOL
132;            LONG-FLOAT-NEGATIVE-EPSILON PAIRLIS STRINGP LOOP LOGIOR VECTORP
133;            BROADCAST-STREAM WITH-SLOTS CATCH MAKE-RANDOM-STATE FORMAT COPY-SEQ
134;            STRING-LESSP APPLY REM CALL-METHOD IGNORE CONSP SYMBOLP
135;            *PRINT-LENGTH* READ-DELIMITED-LIST SBIT READER-ERROR RESTART-CASE
136;            PPRINT-EXIT-IF-LIST-EXHAUSTED FUNCTION-LAMBDA-EXPRESSION SIXTH FIND
137;            SYMBOL-FUNCTION LOGNOT TRANSLATE-PATHNAME VALUES MACHINE-INSTANCE
138;            STRING-UPCASE CADADR PEEK-CHAR *PRINT-READABLY* RESTART-BIND ASSOC
139;            INTERACTIVE-STREAM-P SINH CDDAR UNBOUND-SLOT STRING> GCD PACKAGEP
140;            UPPER-CASE-P TRUNCATE RENAME-FILE CADAAR BOOLE-IOR
141;            INITIALIZE-INSTANCE MAKE-STRING STANDARD-CHAR-P &AUX NSUBSTITUTE-IF
142;            DECLARE CDDR CLOSE ARRAY-DISPLACEMENT WRITE INTEGER CHAR>= VARIABLE
143;            MERGE-PATHNAMES WITH-SIMPLE-RESTART BYTE-SIZE ASH COMPILE IGNORABLE
144;            NOTEVERY MISMATCH INVALID-METHOD-ERROR FORCE-OUTPUT
145;            REMOVE-DUPLICATES UNSIGNED-BYTE MAKE-METHOD RESTART-NAME BOOLE-AND
146;            FINISH-OUTPUT UNWIND-PROTECT BOOLE-EQV *PRINT-CASE* WITH-ACCESSORS
147;            *PRINT-ARRAY* SVREF ARRAY-DIMENSIONS - METHOD DEFVAR SEVENTH
148;            MOST-POSITIVE-DOUBLE-FLOAT REMOVE-METHOD PATHNAME-TYPE TIME BOUNDP
149;            LAMBDA-PARAMETERS-LIMIT ROTATEF LONG-SITE-NAME LOCALLY
150;            DIVISION-BY-ZERO SLOT-BOUNDP SIMPLE-CONDITION BOTH-CASE-P
151;            GET-MACRO-CHARACTER LIST-ALL-PACKAGES STRUCTURE-OBJECT MAKE-LIST
152;            SIMPLE-CONDITION-FORMAT-ARGUMENTS BOOLE-ORC1 MAKE-HASH-TABLE
153;            FIND-IF-NOT COPY-LIST CEILING GETHASH BYTE
154;            CONCATENATED-STREAM-STREAMS DELETE-IF *QUERY-IO* PUSH
155;            FLOATING-POINT-OVERFLOW ROOM TYPEP FRESH-LINE PRINT REMOVE NREVERSE
156;            MAPHASH DO-EXTERNAL-SYMBOLS ECHO-STREAM-OUTPUT-STREAM COND NTH LISTP
157;            FLOAT ARRAYP SHARED-INITIALIZE ASSOC-IF EQUALP ALLOCATE-INSTANCE BIT
158;            BOOLE-ANDC2 HOST-NAMESTRING CONS BASE-STRING
159;            ARITHMETIC-ERROR-OPERATION NSUBSTITUTE-IF-NOT RANDOM-STATE-P
160;            NSUBST-IF-NOT READ-LINE READ-CHAR TERPRI MAKE-BROADCAST-STREAM
161;            SUBSETP MULTIPLE-VALUE-CALL MAKE-LOAD-FORM STRING-EQUAL
162;            VECTOR-PUSH-EXTEND MAKE-STRING-INPUT-STREAM TREE-EQUAL CAADDR GET
163;            EXPT CONTINUE LEAST-POSITIVE-LONG-FLOAT TAGBODY STRING-NOT-GREATERP
164;            OUTPUT-STREAM-P BIT-XOR CLEAR-OUTPUT RASSOC-IF-NOT
165;            REINITIALIZE-INSTANCE SXHASH SIMPLE-TYPE-ERROR
166;            LEAST-POSITIVE-SHORT-FLOAT INVOKE-RESTART RESTART EXPORT QUOTE
167;            ADD-METHOD PACKAGE-USE-LIST COPY-STRUCTURE TYPE-ERROR
168;            PARSE-NAMESTRING PATHNAME-HOST READ-PRESERVING-WHITESPACE CASE
169;            ARRAY-TOTAL-SIZE INSPECT LIST* COMPUTE-RESTARTS DEFCONSTANT
170;            DENOMINATOR PROCLAIM MACHINE-VERSION LONG-FLOAT CDADDR CAR READ
171;            MAKE-TWO-WAY-STREAM GENERIC-FUNCTION DEFSETF LABELS ATAN
172;            ARRAY-ELEMENT-TYPE PACKAGE-SHADOWING-SYMBOLS COUNT-IF-NOT
173;            ARITHMETIC-ERROR MOST-POSITIVE-SHORT-FLOAT CDDADR LDB
174;            HASH-TABLE-TEST *DEFAULT-PATHNAME-DEFAULTS* LAMBDA
175;            LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT MACRO-FUNCTION
176;            WRITE-TO-STRING REPLACE REMOVE-IF SUBST-IF-NOT ARRAY-RANK MAX INLINE
177;            LOGXOR INTERNAL-TIME-UNITS-PER-SECOND NTH-VALUE
178;            DOUBLE-FLOAT-NEGATIVE-EPSILON COSH SCHAR NINTERSECTION SATISFIES
179;            REDUCE ECASE INTERN CDAAR LOGNOR *** INTERSECTION SPEED STRING>=
180;            DECLARATION *LOAD-VERBOSE* *PRINT-LINES* LEAST-POSITIVE-DOUBLE-FLOAT
181;            RATIONAL UNBOUND-VARIABLE CHAR-UPCASE FILL-POINTER SLEEP PRIN1 1+
182;            COMPLEMENT INTEGER-DECODE-FLOAT EVERY RENAME-PACKAGE
183;            GET-INTERNAL-RUN-TIME UNEXPORT STREAM-EXTERNAL-FORMAT
184;            ARRAY-IN-BOUNDS-P WITH-PACKAGE-ITERATOR LISP-IMPLEMENTATION-VERSION
185;            CAADAR DOTIMES CIS ENSURE-DIRECTORIES-EXIST CHAR-NAME MUFFLE-WARNING
186;            *DEBUGGER-HOOK* FIRST ASINH CONSTANTP DOUBLE-FLOAT
187;            *READ-DEFAULT-FLOAT-FORMAT* DEFCLASS STEP METHOD-COMBINATION
188;            WITH-CONDITION-RESTARTS PROVIDE *STANDARD-OUTPUT* MACHINE-TYPE NINTH
189;            SQRT COS LOGANDC1 PACKAGE-NICKNAMES FUNCTIONP NO-NEXT-METHOD MAPC
190;            CHARACTER CDDDR NOTINLINE MAKE-CONCATENATED-STREAM REAL CDAAAR
191;            GET-SETF-EXPANSION SLOT-EXISTS-P BLOCK WRITE-LINE CHANGE-CLASS SUBST
192;            WRITE-CHAR READTABLEP NTHCDR SOFTWARE-TYPE
193;            TWO-WAY-STREAM-INPUT-STREAM MAKE-PACKAGE ACONS
194;            LEAST-NEGATIVE-SHORT-FLOAT FLOATP CAAAAR MAPCAR LOGCOUNT ATOM
195;            FCEILING ARRAY-DIMENSION DECODE-FLOAT SERIOUS-CONDITION SYMBOL-NAME
196;            STRING-GREATERP SIGNAL *ERROR-OUTPUT* *COMPILE-FILE-TRUENAME*
197;            FILE-NAMESTRING *PRINT-MISER-WIDTH* UNINTERN GET-UNIVERSAL-TIME
198;            LIST-LENGTH CADR FIXNUM WITH-STANDARD-IO-SYNTAX WITH-OPEN-STREAM
199;            DESTRUCTURING-BIND *LOAD-TRUENAME* FROUND WITH-COMPILATION-UNIT
200;            EIGHTH SETF &KEY PROGN LAMBDA-LIST-KEYWORDS STYLE-WARNING
201;            &ALLOW-OTHER-KEYS CHAR= MACROEXPAND GET-OUTPUT-STREAM-STRING COERCE
202;            *READ-EVAL*)
203; 
204(nth-value 1 (dir (find-package 'cl)))
205; 978

天啦天啦天啦，这个common-lisp包里居然有978个可供外部访问的符号！好奇先生简直要疯了！

好奇先生想要对每一个符号使用describe，并且把所有的符号都输出到一个文件里，于是他写了一个函数。

 1;; print all symbols and doc strings in a file
 2(defun dir-package (package)
 3  "List all external symbols in a package and their doc strings in a file"
 4  (let ((sorted-names (sort (dir package) #'string<))
 5        (fn (format nil "~a.md" package)))
 6    (with-open-stream (s (open fn :direction :output :if-exists :supersede))
 7      ;; header line
 8      (format s "# ~a external symbols~%~%~%" package)
 9      ;; list all external symbols     
10      (let ((index 1))
11        (dolist (name sorted-names)
12          (format s "~d. [~A](#~A)~%" index name name)
13          (incf index)))
14      (format s "~%~%")
15      ;; describe all external symbols
16      (dolist (name sorted-names)
17        (format s "##  `~a`~%~%" name)
18        (format s "```lisp~%")
19        (describe name s)
20        (format s "```~%")))))

这下好了，好奇先生有一个markdown文件，里面包含了所有的符号和他们的文档字符串。好奇先生对这个文件简直是爱不释手。

 1# CL external symbols
 2
 3
 41. [&ALLOW-OTHER-KEYS](#&ALLOW-OTHER-KEYS)
 52. [&AUX](#&AUX)
 63. [&BODY](#&BODY)
 74. [&ENVIRONMENT](#&ENVIRONMENT)
 85. [&KEY](#&KEY)
 96. [&OPTIONAL](#&OPTIONAL)
107. [&REST](#&REST)
118. [&WHOLE](#&WHOLE)
129. [*](#*)
1310. [**](#**)
1411. [***](#***)
1512. [*BREAK-ON-SIGNALS*](#*BREAK-ON-SIGNALS*)
1613. [*COMPILE-FILE-PATHNAME*](#*COMPILE-FILE-PATHNAME*)
1714. [*COMPILE-FILE-TRUENAME*](#*COMPILE-FILE-TRUENAME*)
1815. [*COMPILE-PRINT*](#*COMPILE-PRINT*)
1916. [*COMPILE-VERBOSE*](#*COMPILE-VERBOSE*)
2017. [*DEBUG-IO*](#*DEBUG-IO*)
2118. [*DEBUGGER-HOOK*](#*DEBUGGER-HOOK*)
2219. [*DEFAULT-PATHNAME-DEFAULTS*](#*DEFAULT-PATHNAME-DEFAULTS*)
2320. [*ERROR-OUTPUT*](#*ERROR-OUTPUT*)
2421. [*FEATURES*](#*FEATURES*)
2522. [*GENSYM-COUNTER*](#*GENSYM-COUNTER*)
2623. [*LOAD-PATHNAME*](#*LOAD-PATHNAME*)
2724. [*LOAD-PRINT*](#*LOAD-PRINT*)
2825. [*LOAD-TRUENAME*](#*LOAD-TRUENAME*)
2926. [*LOAD-VERBOSE*](#*LOAD-VERBOSE*)
3027. [*MACROEXPAND-HOOK*](#*MACROEXPAND-HOOK*)
3128. [*MODULES*](#*MODULES*)
3229. [*PACKAGE*](#*PACKAGE*)
3330. [*PRINT-ARRAY*](#*PRINT-ARRAY*)
3431. [*PRINT-BASE*](#*PRINT-BASE*)
3532. [*PRINT-CASE*](#*PRINT-CASE*)
3633. [*PRINT-CIRCLE*](#*PRINT-CIRCLE*)
3734. [*PRINT-ESCAPE*](#*PRINT-ESCAPE*)
3835. [*PRINT-GENSYM*](#*PRINT-GENSYM*)
39
40...
41
42##  `YES-OR-NO-P`
43
44COMMON-LISP:YES-OR-NO-P
45  [symbol]
46
47YES-OR-NO-P names a compiled function:
48  Lambda-list: (&OPTIONAL FORMAT-STRING &REST ARGUMENTS)
49  Declared type: (FUNCTION
50                  (&OPTIONAL (OR STRING NULL FUNCTION) &REST T)
51                  (VALUES BOOLEAN &OPTIONAL))
52  Derived type: (FUNCTION (&OPTIONAL T &REST T)
53                 (VALUES BOOLEAN &OPTIONAL))
54  Documentation:
55    YES-OR-NO-P is similar to Y-OR-N-P, except that it clears the
56       input buffer, beeps, and uses READ-LINE to get the strings
57       YES or NO.
58  Source file: SYS:SRC;CODE;QUERY.LISP
59
60##  `ZEROP`
61
62COMMON-LISP:ZEROP
63  [symbol]
64
65ZEROP names a compiled function:
66  Lambda-list: (NUMBER)
67  Declared type: (FUNCTION (NUMBER) (VALUES BOOLEAN &OPTIONAL))
68  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
69  Documentation:
70    Is this number zero?
71  Known attributes: foldable, flushable, unsafely-flushable, movable
72  Source file: SYS:SRC;CODE;NUMBERS.LISP

这个文件实在太长了，只能每个人都产生了在自己电脑上查看。

好奇先生的部分好奇心暂时得到完全的满足，他有一整套工具对自己的Lisp系统进行探索。真是太棒了！

总结

包是Lisp中的一个重要概念，它可以帮助我们组织符号。
一个包可以包含很多符号，我们可以通过do-external-symbols来遍历一个包中的所有符号。
一个符号可以有文档字符串，我们可以通过describe来查看一个符号的文档字符串。
对于Lisp的学习，应该尽快建立REPL工具，然后用Lisp来探索Lisp。