爱上 Common Lisp, 或精明程序员的秘密武器

有两个示例可选地使用了 LispWorks Common Lisp⁴ 附带的 CAPI 用户界面工具包, 并且可以在免费的个人版上运行. 第一个 CAPI 应用程序是 Knowledge Graph Navigator⁵, 第二个 CAPI 示例是 Knowledge Graph Creator⁶. 这两个示例都构建了用于处理知识图谱和语义网的实用工具. 我扩展了 Plot Library 章节, 使其可以生成 PNG 图形文件, 或者如果你使用的是 LispWorks 的免费个人版, 你也可以将绘图输出定向到交互式程序中的新窗口. 我增加了一个新章节, 关于使用 py4cl 库将 Python 库和应用程序代码嵌入到 Common Lisp 系统中. 我提供了新的示例, 用于在 Common Lisp 应用程序中嵌入 spaCy 和 TensorFlow 应用程序. 在早期版本中, 我使用了一个 Web 服务接口来包装使用 spaCy 和 TensorFlow 的 Python 代码. 我保留了那一章, 将其从 “Using Python Deep Learning Models In Common Lisp” 重命名为 “Using Python Deep Learning Models In Common Lisp With a Web Services Interface”. 此版本的新章节是 “Using the PY4CL Library to Embed Python in Common Lisp”.

添加了两个章节:

• 一个完整的应用程序, 用于处理文本以生成知识图谱数据 (目标是开源的 Neo4j 图数据库, 并且还支持 RDF 语义网/链接数据).
• 一个用于访问最先进的 spaCy 自然语言处理 (NLP) 库以及最先进的深度学习模型的库. 这些模型通过使用 spaCy, PyTorch 和 TensorFlow 等 Python 库的轻量级 Python 包装器实现. 这些示例取代了先前版本中的一个简单的混合 Java 和 Common Lisp 示例.

我在全书中适当增加了文本和解释, 并删除了 CouchDB 示例. 我对本书代码的打包方式做了较大改动. 我通过将示例作为多个 Quicklisp 库或应用程序提供, 重新组织了 GitHub 上的示例代码. 我现在对所有我的 Common Lisp 代码都这样做, 这使得编写可以组合成更大应用程序的较小库变得更容易. 在我自己的工作流程中, 我还喜欢使用 Makefile 目标来构建可以在其他计算机上运行而无需安装 Lisp 开发环境的独立应用程序. 请遵循前言末尾关于配置 Quicklisp 的说明, 以便轻松构建和使用本书的示例软件.

为什么选择 Common Lisp? Common Lisp 不是一门旧语言吗? 现在还有很多人使用 Common Lisp 吗? 我相信使用像 Common Lisp, Clojure, Racket 和 Scheme 这样的 Lisp 语言都是敏捷软件开发中有用的秘密武器. 如果你在像 Java 企业版 (JEE) 这样的重量级平台上进行开发, 那么交互式开发过程和实时生产更新会让你感觉耳目一新. 是的, Common Lisp 是一门旧语言, 但随着时间的推移, 它带来了稳定性和极其优秀的编译器技术. 不同的 Common Lisp 系统在处理线程等方面也存在一些不一致性, 但只要稍加了解, 你就可以选择支持你需求的 Common Lisp 系统.

亲爱的读者, 我花时间写这本书是为了帮助你. 我根据知识共享 “署名-相同方式共享, 禁止修改, 非商业性使用” 许可协议发布本书, 并将最低购买价格设为 5.00 美元, 以便让最多的读者能够接触到它. 根据此许可协议, 你可以与你的朋友和同事分享本书的 PDF 版本, 我鼓励你这样做. 如果你在网上找到这本书 (或者别人送给你), 并且你觉得它有价值, 那么请考虑做以下其中一项来支持我未来的写作工作, 并支持本书的未来更新:

• 在 leanpub.com/lovinglisp/⁷ 购买本书的副本, 或在 https://leanpub.com/u/markwatson%5Bfn:8%5D 购买我的任何其他 leanpub 书籍.
• 聘请我作为顾问⁸.

我喜欢写作, 你的支持帮助我为我的书籍编写新版本和更新, 并开发新的书籍项目. 谢谢你!

本书的第四版于 2017 年 5 月发布, 主要变化如下:

• 添加了一个名为 KGCreator 的示例应用程序, 该程序处理文本数据以自动生成知识图谱数据. 此示例应用程序支持 Neo4j 图数据库以及语义网/链接数据系统. 主要变化如下:
• 添加了一个反向传播神经网络示例.
• 添加了一个使用基于 Java 的 Armed Bear Common Lisp 和流行的 DeepLearning4j 库的深度学习示例.
• 添加了一个启发式搜索示例.
• 使用 CLML 库添加了两个机器学习示例 (K-Means 聚类和 SVM 分类).
• 对先前文本进行了一些编辑.

第三版于 2014 年 10 月发布. 2014 版的主要变化如下:

• 我重写了 Common Lisp Basics 章节.
• 我在关于使用 QuickLisp 的章节中添加了内容.

第二版于 2013 年发布, 源自我在我的网站上发布的版本, 我将本书的制作移至 leanpub.com⁹.

我要感谢 Jans Aasman¹⁰ 作为本书第四版的技术编辑所做的贡献. Jans 是 Franz.com¹¹ 的 CEO, 该公司销售 Allegro Common Lisp¹² 以及用于语义网和链接数据应用的工具. 我要感谢以下人士为本书先前版本的改进提出了建议: Sam Steingold, Andrew Philpot, Kenny Tilton, Mathew Villeneuve, Eli Draluk, Erik Winkels, Adam Shimali, 和 Paolo Amoroso. 我还要感谢几位指出本书中印刷错误并提出具体建议的人: Martin Lightheart, Tong-Kiat Tan, Rainer Joswig, Gerold Rupprecht, 和 David Cortesi. 我要感谢以下 Reddit /r/lisp 读者指出了第五版中的错误: arnulfslayer, rpiirp, 和 itmuckel. 我要感谢 Ted Briscoe 指出了第 6 版中 spacy web client 示例的一个问题. 我要感谢 Paul Graham 创造了 “秘密武器” (The Secret Weapon) 这个短语 (在他出色的论文 “Beating the Averages” 中), 用来讨论 Lisp 的优势, 并允许我重用他的短语. 我尤其要感谢我的妻子 Carol Watson 为编辑本书所做的出色工作.

这些说明假定使用 SBCL. 有关 LispWorks, Franz Common Lisp 和 Clozure Common List 的评论, 请参见本节末尾. 我假设你已经按照 lisp-lang.org/learn/getting-started¹³ 的说明安装了 SBCL 和 Quicklisp. 这些说明还会指导你安装用于 Emacs 的 Slime 扩展. 我同时使用 Emacs + Slime 和带有 Common Lisp 插件的 VSCode 来编辑 Common Lisp. 如果你喜欢 VSCode, 我推荐 Yasuhiro Matsumoto 的 Lisp 插件用于语法高亮. 对于 Emacs 和 VSCode, 我通常在终端窗口中运行一个单独的 REPL, 而不运行编辑器集成的 REPL. 我想我在使用在 shell 中运行的单独 REPL 方面是少数派. 我大约从 1982 年开始使用 Common Lisp, 而 Quicklisp 是我 Common Lisp 开发中最具革命性的变化 (甚至比获得硬件 Lisp Machine 和 Macintosh 上 Coral Common Lisp 的可用性更具革命性). 亲爱的读者, 我要请你相信我, 并采纳我从 Quicklisp 的创建者和维护者 Zach Beane¹⁴ 那里采纳的以下建议:

• 如果文件 ~/.config/common-lisp/source-registry.conf.d/projects.conf 不存在于你的系统中, 请创建它.
• 假设你已将本书的代码库 (loving-common-lisp) 克隆到你的主目录中 (如果你有克隆 git 仓库的特定位置, 请相应调整以下内容), 编辑此配置文件, 使其看起来像这样:

(:tree
 (:home "loving-common-lisp/src/")
 )

这将使得 loving-common-lisp/src/ 的子目录可以通过 Quicklisp 加载. 例如, 子目录 loving-common-lisp/src/spacy_client 包含一个名为 spacy 的包, 现在可以在你系统上的任何目录中使用以下命令访问它:

主要的示例库和应用程序将位于它们自己的包中. 本书中所有简短代码片段的函数和数据定义都在包 loving-snippets 中, 位于子目录 loving-common-lisp/src/loving_snippets. 每当你学习本书中的简短示例时, 我都假定你已经打开了一个 SBCL (或其他 Common Lisp) REPL 并加载了这个包:

$ sbcl * (ql:quickload "spacy_web_client")

在我的一个 Linux 笔记本电脑上, 出于我尚未发现的原因, 使用 ~/.config/common-lisp/source-registry.conf.d/projects.conf 来设置 Quicklisp 查找包的根目录不起作用. 如果碰巧这对你也不起作用, 你可以将示例书包的符号文件链接设置到你的 ~/.quicklisp/local-projects 目录. 这是 Quicklisp 存储你安装的库的本地副本的目录. 例如:

$ cd ~/.quicklisp/local-projects $ ln -s loving-common-lisp/src/loving_snippets . $ ln -s loving-common-lisp/src/kgcreator . $ ln -s loving-common-lisp/src/kbnlp . etc.

希望你不需要费心做这个变通方法. 虽然本书中大多数较长的示例都是 Quicklisp 项目, 但书中也有许多非常简短的代码片段, 位于子目录 src/code_snippets_for_book 中, 还有一些未配置为 Quicklisp 项目的简短程序示例在 src/loving_snippets 子目录中:

$ ls code_snippets_for_book
closure1.lisp           nested.lisp               read-test-1.lisp
readline-test.lisp      do1.lisp                  read-from-string-test.lisp
read-test-2.lisp        recursion1.lisp
Marks-MacBook:src $ ls loving_snippets
HTMLstream.lisp         astar_search.lisp         macro1.lisp
Hopfield_neural_network.lisp backprop_neural_network.lisp macro2.lisp README.md
ambda1.lisp             mongo_news.lisp

打包为 Quicklisp 项目的较长示例在 src 目录中是:

• fasttag: 我的词性标注器
• solr_examples: 开源 Solr 搜索引擎的客户端
• categorize_summarize: 我的用于文本分类和生成摘要的 NLP 代码
• coref_web_client: 基于 spaCy 的 Web 服务的客户端, 用于执行指代消解 (即, 将文本中的代词替换为其所指的名词)
• hunchentoot_examples: Web 服务和 Web 客户端的示例
• spacy_web_client: 使用最先进的 NLP 深度学习模型的通用 Web 服务的客户端
• clml_examples: 使用 Common List 机器学习库的示例
• kbnlp: 我的 NLP 代码
• myutils: 本书中其他几个示例库中使用的杂项函数
• webscrape: 如何抓取网站的演示
• clsql_examples: 展示如何使用 CLSQL 库访问关系数据库的示例
• entities_dbpedia: 使用公共 DbPedia (来自 WikiPedia 的数据) 公共 Web 接口获取有关人物, 公司, 地点等信息.
• kgcreator: 我的用于处理文本, 提取实体以及为知识图谱生成数据的应用程序 (支持 Neo4J 和 RDF 语义网/链接数据应用程序)
• kgn: 应用程序 Knowledge Graph Navigator¹⁵
• plotlib: 一个非常简单的绘图库, 可将绘图写入 PNG 图形文件

我在本书中使用了 SBCL 实现的 Common Lisp. Franz, LispWorks, Clozure Common Lisp 等提供了许多优秀的 Common Lisp 实现. 如果你在将示例应用于你选择的 Common Lisp 实现时遇到很大困难, 并且进行 Web 搜索没有找到解决方案, 你可以通过我的网站 markwatson.com¹⁶ 联系我. 可能不具可移植性的示例是为我的 KGCreator 示例创建独立可执行文件以及使用 Common Lisp Machine Learning 库的示例.

为什么书名叫 “爱上 Common Lisp”? 简单! 我使用 Lisp 将近 40 年了, 很少能找到编程语言和手头的编程工作之间更好的匹配. 然而, 我并不是 Lisp 的狂热粉丝. 我经常使用 Python 进行深度学习. 我喜欢 Ruby, Java 和 Javascript 用于服务器端编程, 在我为 SAIC 和 Disney 工作于任天堂视频游戏和虚拟现实系统的几年里, 我发现 C++ 是一个不错的选择, 因为有严格的运行时性能要求. 对于某些工作, 我发现逻辑编程范式很有用: 我也喜欢 Prolog 语言. 无论如何, 我热爱用 Lisp 编程, 特别是行业标准的 Common Lisp. 十多年前, 当我写本书的第二版时, 我几乎完全为一个医疗保健公司的人工智能项目和商业产品开发使用 Common Lisp. 在编写本书第三版时, 我并未在专业上使用 Common Lisp, 但自从 Quicklisp Common Lisp 包管理器发布以来, 我发现自己更喜欢使用 Common Lisp 来做一些小型副项目. 我在第三版的示例代码中全面使用了 Quicklisp, 以便你可以轻松安装所需的库. 对于本书的第四版和第五版, 我添加了更多使用神经网络和深度学习的示例. 在这个新的第六版中, 我添加了一个使用 CAPI 进行用户界面的完整应用程序. 作为程序员, 我们都 (希望) 享受运用我们的经验和智慧来解决有趣的问题. 我和妻子最近看了一个两晚 7 小时的 PBS 特别节目 “Joseph Campbell, and the Power of Myths”. Campbell 是一位将近 40 年的大学教授, 他说他总是建议他的学生 “追随自己的幸福” (follow their bliss), 不要满足于那些并非他们真正想做的工作和职业. 话虽如此, 我总是觉得当一份工作需要使用 Java, Python 或 Lisp 之外的其他语言时, 即使我可能会从中获得很多乐趣, 我也没有追随自己的幸福. 本书的目标是向你介绍我最喜欢的编程语言之一, Common Lisp. 我假设你已经知道如何用另一种语言编程, 但如果你是一个完全的初学者, 只要付出一些努力, 你仍然可以掌握本书中的材料. 我鼓励你付出这种努力.

网络上有几种免费的 Common Lisp 编译器和运行时工具可用:

• CLISP – 遵循 GNU GPL 许可, 可用于 Windows, Macintosh 和 Linux/Unix
• Clozure Common Lisp (CCL) – 开源, 对 Mac OS X 和 Linux 支持良好
• CMU Common Lisp – 开源实现
• SBCL – 源自 CMU Common Lisp
• ECL – 使用单独的 C/C++ 编译器进行编译
• ABCL – 用于 JVM 的 Armed Bear Common Lisp

还有一些优秀的商业 Common Lisp 产品:

• LispWorks – 高质量且价格合理的系统, 适用于 Windows 和 Linux. 分发编译后的应用程序无需付费 lispworks.com.
• Allegro Common Lisp - 高质量, 强大的支持, 成本较高. franz.com
• MCL – Macintosh Common Lisp. 我在 1980 年代末期使用这个 Lisp 环境. MCL 非常好, 以至于我送掉了我的 Xerox 1108 Lisp Machine, 转而使用 Mac 和 MCL 进行开发工作. 现在是开源的, 但只能在旧版 MacOS 上运行.

我目前 (主要) 使用 SBCL, CCL 和 LispWorks. SBCL 编译器生成的代码速度非常快, 编译器警告在发现代码中的潜在问题方面非常有价值. 喜欢 CCL 是因为它编译速度快, 因此通常更适合开发. 在本书的学习过程中, 我将假设你正在使用 SBCL 或 CCL. 对于最后一章的示例, 你将需要 LispWorks, 免费的个人版对于试验示例应用程序和 CAPI 用户界面库来说已经足够了.

这是一个陷阱问题! Lisp 与 Java 的相似性略高于 C++, 因为它们都有自动内存管理, 所以我们先比较 Lisp 和 Java. 在 Java 中, 变量是强类型的, 而在 Common Lisp 中, 值是强类型的. 例如, 考虑以下 Java 代码:

Float x = new Float(3.14f);
String s = "the cat ran" ;
Object any_object = null;
any_object = s;
x = s; // illegal: generates a
// compilation error

这里, 在 Java 中, 变量是强类型的, 所以类型为 Float 的变量 x 不能合法地赋给一个字符串值: 第 5 行的代码会产生编译错误. Lisp 代码可以将一个值赋给一个变量, 然后再赋给一个不同类型的另一个值. Java 和 Lisp 都提供自动内存管理. 在这两种语言中, 你都可以创建新的数据结构, 而不必担心在数据不再使用时 (或者更准确地说, 不再被引用时) 释放内存. Common Lisp 是一种 ANSI 标准语言. 不同 Common Lisp 实现之间以及不同平台上的可移植性非常好. 我使用过 Clozure Common Lisp, SBCL, Allegro Lisp (来自 Franz Inc), LispWorks 和 CLISP, 它们在 Windows, Mac OS X 和 Linux 上都运行良好. 作为 Common Lisp 开发者, 你将在工具和平台方面拥有极大的灵活性. ANSI Common Lisp 是第一个成为 ANSI 标准语言的面向对象语言. Common Lisp 对象系统 (CLOS) 可能是面向对象编程的最佳平台. 在 C++ 程序中, 一个常见的影响程序效率的 bug 是忘记释放不再使用的内存. 在虚拟内存系统中, 程序内存使用量增加的影响通常只是系统性能下降, 但如果所有可用的虚拟内存耗尽, 则可能导致系统崩溃或故障. 更糟糕的 C++ 错误类型是释放内存后又尝试使用它. 你能说 “程序崩溃” 吗? C 程序也存在同样类型的内存相关错误. 由于计算机处理能力通常远比软件开发成本便宜, 因此放弃几个百分点的运行时效率, 让编程环境的运行时库为你管理内存几乎总是值得的. 像 Lisp, Ruby, Python 和 Java 这样的语言据说会执行自动垃圾回收. 我写过六本关于 Java 的书, 我曾被引述说, 对我而言, 用 Java 编程的效率大约是用 C++ 编程的两倍 (就我的时间而言). 我基于在 SAIC, PacBell, Angel Studios, Nintendo 和 Disney 的项目上大约十年的 C++ 经验得出这个结论. 我发现 Common Lisp 和其他 Lisp 语言 (如 Clojure 和 Scheme) 的效率大约是 Java 的两倍 (同样, 就我的时间而言). 这是正确的: 我声称在使用 Common Lisp 与 C++ 相比, 我的编程生产力提高了四倍. 我所说的编程生产力是什么意思? 很简单: 对于给定的工作, 我需要多长时间来设计, 编码, 调试以及以后维护给定任务的软件.

我们很快就会看到 Lisp 不仅仅是一种语言; 它也是一个编程环境和运行时环境. 本书的开头介绍了 Lisp 编程的基础知识. 在后面的章节中, 我们将开发有趣且非平凡的 Common Lisp 程序, 我认为这些程序在其他语言和编程环境中会更难实现. 在 Lisp 环境中编程的一大优势是你可以建立一个环境, 并以交互方式编写新代码并小块地测试新代码. 我们将在关于自然语言处理的章节中介绍使用大量数据的编程, 但让我分享一个我在 Lisp 中效率高得多的通用用例: 我过去的大部分 Lisp 编程工作是为我的公司 www.knowledgebooks.com 编写商业自然语言处理 (NLP) 程序. 我的 Lisp NLP 代码使用了大量的内存驻留数据; 例如: 用于不同类型单词的哈希表, 用于文本分类的哈希表, 200,000 个地名专有名词 (城市, 县, 河流等), 以及大约 40,000 个不同国籍的常见名字和姓氏. 如果我用 C++ 编写我的 NLP 产品, 我可能会使用关系数据库来存储这些数据, 因为如果我每次运行 C++ 程序的测试时都将所有这些数据读入内存, 那么每次运行程序测试我都要等待 30 秒. 当我开始在任何 Common Lisp 环境中工作时, 我确实需要一次性将语言数据加载到内存中, 但是之后我可以连续几个小时进行编码/测试/编码/测试…, 而无需重新加载我的程序需要运行的数据的启动开销. 由于 Lisp 开发的交互性, 我可以在追踪错误和编写新代码时测试小段代码. 这是个人偏好, 但我发现稳定的 Common Lisp 语言和迭代式 Lisp 编程环境的结合比其他语言和编程环境的生产力要高得多.

当我们启动 SBCL 时, 我们会看到一条介绍性消息, 然后是一个输入提示符. 我们将从一个简短的教程开始, 引导你完成使用 SBCL repl (其他 Common LISP 系统非常相似) 的会话. repl 是一个交互式控制台, 你可以在其中键入表达式并查看评估这些表达式的结果. 表达式可以是一个粘贴到 repl 中的大块代码, 使用 load 函数将 Lisp 代码加载到 repl 中, 调用函数来测试它们等等. 假设你的系统上已安装 SBCL, 通过运行 SBCL 程序来启动 SBCL:

% sbcl
(running SBCL from: /Users/markw/sbcl)
This is SBCL 2.0.2, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.

SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses. See the CREDITS and COPYING files in the
distribution for more information.

* (defvar x 1.0)

X
* x

1.0
* (+ x 1)

2.0
* x

1.0
* (setq x (+ x 1))

2.0
* x

2.0
* (setq x "the dog chased the cat")

"the dog chased the cat"
* x

"the dog chased the cat"
* (quit)
Bye.

我们在第 11 行通过定义一个新变量 x 开始. 注意 defvar 宏的值是定义的符号. Lisp 读取器打印 X 为大写, 因为符号通常转换为大写 (我们稍后会看例外). 在 Lisp 中, 变量可以引用任何数据类型. 我们首先将浮点值赋给变量 x, 在第 17 行使用 + 函数将 1 加到 x, 在第 23 行和 29 行使用 setq 函数更改 x 的值, 先改为另一个浮点值, 最后将 x 设置为字符串值. 你会注意到一件事: 函数名总是先出现, 然后是函数的参数. 此外, 括号用于分隔表达式. 我 1976 年学习 Lisp 编程时, 我的教授半开玩笑地告诉我们 Lisp 是 “Lots-of Irritating Superfluous Parenthesis” (许多恼人的多余括号) 的缩写. 当你刚开始学习 Lisp 编程时, 这可能有点道理, 但你会很快习惯括号, 特别是如果你使用像 Emacs 这样的编辑器, 它可以自动为你缩进 Lisp 代码, 并在你键入每个右括号时高亮显示对应的左括号. 许多其他编辑器也支持 Lisp 编码, 但我个人使用 Emacs 或有时使用 VScode (带有 Common Lisp 插件) 来编辑 Lisp 代码. 在继续下一章之前, 请花点时间在你的计算机上安装 SBCL, 并尝试在 Lisp 监听器中输入一些表达式. 如果遇到错误或想退出, 请尝试使用 quit 函数:

* (+ 1 2 3 4)

10
* (quit)
Bye.

如果你遇到错误, 可以输入 help 来获取处理错误的选项. 当我遇到错误并且很清楚是什么原因导致错误时, 我通常只输入 :a 来中止错误). 正如我们在引言中讨论的, 有许多不同的 Lisp 编程环境可供你选择. 我推荐一套免费工具: Emacs, Quicklisp, slime 和 SBCL. Emacs 是一款优秀的文本编辑器, 可扩展性强, 能很好地配合多种编程语言和文档类型 (例如 HTML 和 XML). Slime 是一个 Emacs 扩展包, 极大地便利了 Lisp 开发. SBCL 是一个健壮的 Common Lisp 编译器和运行时系统, 常用于生产环境. 我们将在后面的章节中介绍 Quicklisp 包管理器以及如何使用 Quicklisp 来设置 Slime 和 Emacs. 在本书中, 我不会花太多时间介绍 Emacs 作为文本编辑器的使用, 因为你可以通过复制本书文本中的大多数示例代码片段并将其粘贴到 SBCL repl 中, 或者直接将本书示例源文件加载到 repl 中来尝试它们. 如果你已经使用 Emacs, 我建议你尽早设置 Slime 并开始用它进行开发. 如果你还不是 Emacs 用户, 并且不介意花精力学习 Emacs, 那么首先在网上搜索 Emacs 教程. 话虽如此, 你可以轻松地使用你喜欢的任何文本编辑器和 SBCL repl 来使用本书中的示例代码. 我不使用 vi 或 vim 编辑器, 但如果 vi 是你编辑文本的首选武器, 那么在网上搜索 “common lisp vi vim repl” 应该能让你开始使用 vi 或 vim 进行 Common Lisp 代码开发. 如果你还不是 Emacs 或 vi 用户, 那么推荐使用 VSCode 搭配 Common Lisp 插件. 在这里, 我们将假设在 Windows, Unix, Linux 或 Mac OS X 下, 你将使用一个命令窗口运行 SBCL, 并使用一个可以编辑纯文本文件的单独编辑器.

在阅读上一节时, 你 (希望!) 已经玩过了 SBCL 交互式 repl. 如果你还没玩过 repl, 我不会太挑剔, 只是想说, 如果你不边读边玩示例, 你就无法从本书中获得全部好处. 你是否注意到在 SBCL repl 中退格键不起作用? 解决这个问题的方法是安装 GNU rlwrap 实用程序. 在 OS X 上, 假设你已经安装了 homebrew¹⁹, 使用以下命令安装 rlwrap:

brew install rlwrap

如果你正在运行 Ubuntu Linux, 使用以下命令安装 rlwrap:

sudo apt-get install rlwrap

然后你可以为 bash 或 zsh 创建一个别名, 使用类似以下的方式来定义一个命令 rsbcl:

alias rsbcl='rlwrap sbcl'

这很好, 只需要记住, 如果你不需要 rlwrap 命令行编辑功能就运行 sbcl, 如果你需要命令行编辑功能就运行 rsbcl. 话虽如此, 我发现我总是想用命令行编辑功能运行 SBCL, 所以我在我的电脑上重新定义了 sbcl, 使用:

-> ~ which sbcl
/Users/markw/sbcl/sbcl
-> ~ alias sbcl='rlwrap /Users/markw/sbcl/sbcl'

这个别名在我的笔记本电脑和服务器上是不同的, 因为我通常不会将 SBCL 安装在默认安装目录中. 对于我的每台电脑, 我都会在我的 .zshrc 文件 (如果我运行 zsh) 或我的 .bashrc 文件 (如果我运行 bash) 中添加一个适当的别名.

虽然我们在本书中将使用 SBCL, 但任何 Common Lisp 环境都可以. 在前面的部分中, 我们看到了顶层 Lisp 提示符, 以及如何键入任何将被求值的表达式:

* 1
1
* 3.14159
3.14159
* "the dog bit the cat"
"the dog bit the cat"
* (defun my-add-one (x)
    (+ x 1))
MY-ADD-ONE
* (my-add-one -10)
-9

注意, 当我们在第 7 行和第 8 行定义函数 my-add-one 时, 我们将定义分成了两行, 在第 8 行你看不到 SBCL 的 “*” 提示符 – 这让你知道你还没有输入一个完整的表达式. 顶层 Lisp 求值器会计算括号, 并在右括号的数量等于左括号的数量且表达式在括号匹配时完成时, 认为一个形式是完整的. 我倾向于在脑海中计数, 每遇到一个左括号加一, 每遇到一个右括号减一 – 当我回到零时, 表达式就完成了. 当我们求值一个数字 (或一个变量) 时, 没有括号, 所以当我们敲击新行 (或回车) 时, 求值就会进行. Lisp 读取器默认会尝试求值你输入的任何形式. 有一个读取器宏 ‘ 可以阻止表达式的求值. 你可以使用 ‘ 字符或 quote:

* (+ 1 2)
3
* '(+ 1 2)
(+ 1 2)
* (quote (+ 1 2))
(+ 1 2)
*

Lisp 支持全局变量和局部变量. 可以使用 defvar 声明全局变量:

* (defvar *x* "cat")
*X*n
* *x*
"cat"
* (setq *x* "dog")
"dog"
* *x*
"dog"
* (setq *x* 3.14159)
3.14159
* *x*
3.14159

使用 defvar 定义全局变量时需要注意一点: 声明的全局变量是动态作用域的. 我们稍后会讨论动态作用域与词法作用域, 但现在提醒一下: 如果你定义了一个全局变量, 请避免在函数内部重新定义同名变量. Lisp 程序员通常使用一种全局变量命名约定, 即以 * 字符开头和结尾的动态作用域全局变量. 如果你遵循这个命名约定, 并且也不在局部变量名中使用 * 字符, 你就不会遇到麻烦. 为了方便起见, 在本书的简短示例中, 我并不总是遵循这个约定. Lisp 变量没有类型. 相反, 赋给变量的值具有类型. 在最后一个例子中, 变量 x 被设置为字符串, 然后是浮点数. Lisp 类型支持继承, 可以被认为是一个以类型 t 为顶点的层次树. (实际上, 类型层次结构是一个 DAG, 但我们现在可以忽略它.) Common Lisp 还有一个强大的面向对象编程设施, 即 Common Lisp 对象系统 (CLOS), 我们将在后面的章节中讨论. 以下是部分类型列表 (注意缩进表示是前一个类型的子类型):

t [top level type (all other types are a sub-type)]
sequence
list
array
vector
string
number
float
rational
integer
ratio
complex
character
symbol
structure
function
hash-table

我们可以使用 typep 函数来测试任何变量或表达式的值的类型, 或者使用 type-of 来获取任何值的类型信息):

* (setq x '(1 2 3))
(1 2 3)
* (typep x 'list)
T
* (typep x 'sequence)
T
* (typep x 'number)
NIL
* (typep (+ 1 2 3) 'number)
T
* (type-of 3.14159)
single-float
* (type-of "the dog ran quickly")
(simple-array character (19))
* (type-of 100193)
(integer 0 4611686018427387903)

所有 ANSI 标准 Common Lisp 实现的顶层监听器都有一个有用的特性, 即它将 * 设置为最后求值的表达式的值. 例如:

* (+ 1 2 3 4 5)
15
* *
15
* (setq x *)
15
* x
15

所有 Common Lisp 环境都将 * 设置为最后求值的表达式的值. 这个例子可能有点令人困惑, 因为 * 也是 SBCL repl 中指示你可以输入新表达式进行求值的提示符字符. 例如, 在第 3 行, 第一个 * 字符是 repl 提示符, 第二个 * 是我们输入的, 用于查看我们输入的前一个表达式的值. 通常, 当你交互式地测试新代码时, 你会调用一个你刚刚编写的带有测试参数的函数; 保存中间结果以便以后测试很有用. 正是这种创建复杂数据结构然后用使用或更改这些数据结构的代码进行实验的能力, 使得 Lisp 编程环境如此高效. Common Lisp 是一种词法作用域语言, 这意味着变量声明和函数定义可以嵌套, 并且可以在嵌套的 let 形式中使用相同的变量名; 当使用一个变量时, 会在当前的 let 形式中搜索该变量的定义, 如果找不到, 则搜索下一个外部的 let 形式. 当然, 这种对变量正确声明的搜索是在编译时完成的, 因此不需要额外的运行时开销. 我们可以在彼此内部以及 let 表达式内部嵌套 defun 特殊形式, 但这会全局定义嵌套函数. 我们使用特殊形式 flet 和 labels 在作用域环境中定义函数. 在 labels 特殊形式内部定义的函数可以是递归的, 而在 flet 特殊形式内部定义的函数不能是递归的. 考虑文件 nested.lisp 中的以下示例 (所有示例文件都在 src 目录中):

(flet ((add-one (x)
         (+ x 1))
       (add-two (x)
         (+ x 2)))
  (format t "redefined variables: ~A ~A~%" (add-one 100) (add-two 100)))

(let ((a 3.14))
  (defun test2 (x)
    (print x))
  (test2 a))

(test2 50)

(let ((x 1)
      (y 2))
  ;; define a test function nested inside a let statement:
  (flet ((test (a b)
           (let ((z (+ a b)))
             ;; define a helper function nested inside a let/function/let:
             (flet ((nested-function (a)
                      (+ a a)))
               (nested-function z)))))
    ;; call nested function 'test':
    (format t "test result is ~A~%" (test x y))))

(let ((z 10))
  (labels ((test-recursion (a)
             (format t "test-recursion ~A~%" (+ a z))
             (if (> a 0)
                 (test-recursion (- a 1)))))
    (test-recursion 5)))

我们在第 1-5 行定义了一个顶层 flet 特殊形式, 它定义了两个嵌套函数 add-one 和 add-two, 然后在 flet 特殊形式的主体中调用每个嵌套函数. 多年来, 我在 let 表达式中使用嵌套的 defun 特殊形式来定义局部函数, 你会在后面的一些示例中看到这种用法. 然而, 在 defun 特殊形式内部定义的函数具有全局可见性, 因此它们并没有隐藏在它们被定义的局部上下文中. 第 7-12 行中嵌套的 defun 示例表明函数 test2 在当前包内具有全局可见性. 在 flet 特殊形式内部定义的函数可以访问包含 flet (也适用于 labels) 的外部作用域中定义的变量. 我们在第 14-24 行看到这一点, 其中在 let 表达式中定义的局部变量 x 和 y 在 flet 内部定义的函数 nested-function 中可见. 第 26-31 行的最后一个示例显示了一个在 labels 特殊形式内部定义的递归函数. 假设我们在 src 目录中启动了 SBCL, 那么我们可以使用 Lisp 的 load 函数来求值子目录 code_snippets_for_book 中文件 nested.lisp 的内容, 使用 load 函数:

* (load "./code_snippets_for_book/nested.lisp")
redefined variables: 101 102
3.14
50 test result is 6
test-recursion 15
test-recursion 14
test-recursion 13
test-recursion 12
test-recursion 11
test-recursion 10
T
*

函数 load 在成功加载文件后返回 t (打印为大写 T). 我们将在后面的章节中频繁使用 Common Lisp 向量和数组, 但这里也会简要介绍它们. 单维数组也称为向量. 尽管通常有更高效的函数来处理向量, 但我们只看处理任何类型数组 (包括向量) 的通用函数. Common Lisp 支持同名但接受不同参数类型的函数; 我们将在后面关于 CLOS 的章节中详细讨论这一点. 我们将首先定义三个向量 v1, v2 和 v3:

* (setq v1 (make-array '(3)))
#(NIL NIL NIL)
* (setq v2 (make-array '(4) :initial-element "lisp is good"))
#("lisp is good" "lisp is good" "lisp is good" "lisp is good")
* (setq v3 #(1 2 3 4 "cat" '(99 100)))
#(1 2 3 4 "cat" '(99 100))

在第 1 行, 我们定义了一个一维数组 (或向量), 包含三个元素. 在第 3 行, 我们指定了赋给数组 v2 每个元素的默认值. 在第 5 行, 我使用了指定数组字面值的形式, 使用特殊字符 #. 函数 aref 可用于访问数组中的任何元素:

* (aref v3 3)
4
* (aref v3 5)
'(99 100)
*

注意数组的索引是基于零的; 也就是说, 索引从零开始表示序列的第一个元素. 还要注意数组元素可以是任何 Lisp 数据类型. 到目前为止, 我们已经使用了特殊操作符 setq 来设置变量的值. Common Lisp 有一个 setq 的通用版本叫做 setf, 它可以设置列表, 数组, 哈希表等中的任何值. 你可以在所有情况下使用 setf 代替 setq, 但反之则不行. 这里有一个简单的例子:

* v1
#(NIL NIL NIL)
* (setf (aref v1 1) "this is a test")
"this is a test"
* v1
#(NIL "this is a test" NIL)
*

在编写新代码或进行快速编程实验时, 通常最容易 (即最快编程) 使用列表来构建有趣的数据结构. 然而, 随着程序的成熟, 通常会修改它们以使用更高效 (在运行时) 的数据结构, 如数组和哈希表.

我们将在 Common Lisp Packages 章节中更详细地讨论符号. 现在, 你只需要理解符号可以是引用变量的名称. 例如:

> (defvar *cat* "bowser")
*CAT*
* *cat*
"bowser"
* (defvar *l* (list *cat*))
*L*
* *l*
("bowser")
*

请注意, 第一个 defvar 返回定义的符号作为其值. 符号几乎总是转换为大写. 这个 “大写规则” 的一个例外是当我们使用竖线字符定义可能包含空格的符号时:

* (defvar |a symbol with Space Characters| 3.14159)
|a symbol with Space Characters|
* |a symbol with Space Characters|
3.14159
*

列表是 Common Lisp 的基本数据结构. 在本节中, 我们将介绍一些更常用的列表操作函数. 本节描述的所有函数都有一个共同点: 它们不修改它们的参数. 在 Lisp 中, 一个 cons 单元是一个包含两个指针的数据结构. 通常, cons 单元中的第一个指针指向列表的第一个元素, 第二个指针指向表示原始列表其余部分开头的另一个 cons 单元. 函数 cons 接受两个参数, 并将它们存储在一个新的 cons 数据结构的两个指针中. 例如:

* (cons 1 2)
(1 . 2)
* (cons 1 '(2 3 4))
(1 2 3 4)
*

第一个形式求值为一个 cons 数据结构, 而第二个形式求值为一个也是正常列表的 cons 数据结构. 不同之处在于, 在第二种情况下, 新创建的 cons 数据结构的第二个指针指向另一个 cons 单元. 首先, 我们将声明两个全局变量 l1 和 l2, 我们将在示例中使用它们. 列表 l1 包含五个元素, 列表 l2 包含四个元素:

* (defvar l1 '(1 2 (3) 4 (5 6)))
L1
* (length l1)
5
* (defvar l2 '(the "dog" calculated 3.14159))
L2
* l1
(1 2 (3) 4 (5 6))
* l2
(THE "dog" CALCULATED 3.14159)
>

你也可以使用函数 list 来创建一个新列表; 传递给函数 list 的参数是创建列表的元素:

* (list 1 2 3 'cat "dog")
(1 2 3 CAT "dog")
*

函数 car 返回列表的第一个元素, 函数 cdr 返回一个移除了第一个元素的列表 (但不修改其参数):

* (car l1)
1
* (cdr l1)
(2 (3) 4 (5 6))
*

使用 car 和 cdr 调用的组合可以提取列表中的任何元素:

* (car (cdr l1))
2
* (cadr l1)
2
*

注意我们可以将 car 和 cdr 的调用组合成一个单一的函数调用, 在本例中是函数 cadr. Common Lisp 定义了所有形式为 cXXr, cXXXr 和 cXXXXr 的函数, 其中 X 可以是 a 或 d. 假设我们想从嵌套列表 l1 中提取值 5. 通过使用 car 和 cdr 的组合进行一些实验可以完成任务:

* l1
(1 2 (3) 4 (5 6))
* (cadr l1)
2
* (caddr l1)
(3)
(car (caddr l1))
3
* (caar (last l1))
5
* (caar (cddddr l1))
5
*

函数 last 返回列表的最后一个 cdr (即, 列表中的最后一个元素, 包含在一个列表中):

 * (last l1)
((5 6))
*

Common list 提供了 car 和 cdr 的替代函数, 你可能会发现它们更具可读性: first, second, third, fourth 和 rest. 以下是一些示例:

 * (defvar *x* '(1 2 3 4 5))
*X*
 * (first *x*)
1
 * (rest *x*)
(2 3 4 5)
 * (second *x*)
2
 * (third *x*)
3
 * (fourth *x*)
4

函数 nth 接受两个参数: 一个顶层列表元素的索引和一个列表. 第一个索引参数是基于零的:

 * l1
(1 2 (3) 4 (5 6))
 * (nth 0 l1)
1
 * (nth 1 l1)
2
 * (nth 2 l1)
(3)
*

函数 cons 将一个元素添加到列表的开头, 并返回新列表作为其值 (它不修改其参数). 添加到列表开头的元素可以是任何 Lisp 数据类型, 包括另一个列表:

 * (cons 'first l1)
(FIRST 1 2 (3) 4 (5 6))
 * (cons '(1 2 3) '(11 22 33))
((1 2 3) 11 22 33)
*

函数 append 接受两个列表作为参数, 并返回这两个列表连接在一起的值:

 * l1
(1 2 (3) 4 (5 6))
 * l2
('THE "dog" 'CALCULATED 3.14159)
 * (append l1 l2)
(1 2 (3) 4 (5 6) THE "dog" CALCULATED 3.14159)
 * (append '(first) l1)
(FIRST 1 2 (3) 4 (5 6))
*

初学 Lisp 程序员常犯的一个错误是不理解列表中的共享结构. 考虑以下示例, 我们通过重用列表 x 的三个副本来生成列表 y:

 * (setq x '(0 0 0 0))
(0 0 0 0)
 * (setq y (list x x x))
((0 0 0 0) (0 0 0 0) (0 0 0 0))
 * (setf (nth 2 (nth 1 y)) 'x)
X
 * x
(0 0 X 0)
 * y
((0 0 X 0) (0 0 X 0) (0 0 X 0))
 * (setq z '((0 0 0 0) (0 0 0 0) (0 0 0 0)))
((0 0 0 0) (0 0 0 0) (0 0 0 0))
 * (setf (nth 2 (nth 1 z)) 'x)
X
 * z
((0 0 0 0) (0 0 X 0) (0 0 0 0))
*

当我们更改变量 x 引用的共享结构时, 该更改会反映在列表 y 中三次. 当我们创建存储在变量 z 中的列表时, 我们没有使用共享结构.

使用列表很容易, 但访问列表元素所花费的时间与列表的长度成正比. 数组和向量在运行时比长列表更有效, 因为列表元素保存在必须搜索的链表上. 访问短列表的任何元素都很快, 但对于包含数千个元素的序列, 使用向量和数组更快. 默认情况下, 数组和向量的元素可以是任何 Lisp 数据类型. 创建数组时有选项可以告诉 Common Lisp 编译器给定的数组或向量将只包含单一数据类型 (例如, 浮点数), 但我们在本书中不会使用这些选项. 向量是数组的一种特殊化; 向量是只有一维的数组. 为了效率, 有些函数只对向量进行操作, 但由于数组函数也适用于向量, 我们将专注于数组. 在下一节中, 我们将介绍作为向量特殊化的字符字符串. 我们可以使用通用的 make-sequence 函数来制作一个单维数组 (即向量). 重启 sbcl 并尝试:

 * (defvar x (make-sequence 'vector 5 :initial-element 0))
X
 * x
#(0 0 0 0 0)
*

在这个例子中, 请注意向量的打印格式, 它看起来像一个列表, 前面有一个 # 字符. 如上一节所示, 我们使用函数 make-array 来创建数组:

 * (defvar y (make-array '(2 3) :initial-element 1))
Y
 * y
#2A((1 1 1) (1 1 1))
>

注意数组的打印格式: 它看起来像一个列表, 前面有一个 # 字符和维数整数. 除了使用 make-sequence 创建向量之外, 我们可以将整数作为 make-array 的第一个参数传递, 而不是维度值列表. 我们还可以通过使用函数 vector 并提供向量内容作为参数来创建向量:

 * (make-array 10)
#(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
 * (vector 1 2 3 'cat)
#(1 2 3 CAT)
*

函数 aref 用于访问序列元素. 第一个参数是一个数组, 其余参数是数组索引. 例如:

 * x
#(0 0 0 0 0)
 * (aref x 2)
0
 * (setf (aref x 2) "parrot")
"parrot"
 * x
#(0 0 "parrot" 0 0)
 * (aref x 2)
"parrot"
 * y
#2A((1 1 1) (1 1 1))
 * (setf (aref y 1 2) 3.14159)
3.14159
 * y
#2A((1 1 1) (1 1 3.14159))
*

很可能你最初的 Lisp 程序就会涉及到字符字符串的使用. 在本节中, 我们将涵盖基础知识: 创建字符串, 连接字符串以创建新字符串, 字符串中的子字符串, 以及从较长字符串中提取子字符串. 我们将在这里介绍的字符串函数不修改它们的参数; 相反, 它们返回新的字符串作为值. 为了效率, Common Lisp 确实包含了修改其参数的破坏性字符串函数, 但我们在这里不会讨论这些破坏性函数. 我们之前看到字符串是一种向量类型, 而向量又是一种数组类型 (而数组又是一种序列类型). 对 Common Lisp 类型系统的全面介绍超出了本教程介绍 Common Lisp 的范围; Guy Steele 的 “Common Lisp, The Language” 对 Common Lisp 类型有很好的处理, 该书有印刷版并且可以在网上免费获得. 许多用于处理字符串的内置函数实际上更通用, 因为它们是为类型序列定义的. Common Lisp Hyperspec 是另一个你可以在网上找到的很棒的免费资源. 我建议你下载 Guy Steele 的优秀参考书的 HTML 版本和 Common Lisp Hyperspec, 并将两者都保存在你的计算机上. 如果你继续使用 Common Lisp, 最终你会想要阅读 Steele 的整本书并将 Hyperspec 用作参考. 以下文本是从 Common Lisp repl 的输入和输出中捕获的. 首先, 我们将声明两个全局变量 s1 和 space, 它们包含字符串值:

 * (defvar s1 "the cat ran up the tree")
S1
 * (defvar space " ")
SPACE
*

字符串最常见的操作之一是将两个或多个字符串连接成一个新字符串:

 * (concatenate 'string s1 space "up the tree")
"the cat ran up the tree up the tree"
*

注意函数 concatenate 的第一个参数是函数应返回的序列类型; 在本例中, 我们想要一个字符串. 另一个常见的字符串操作是搜索子字符串:

 * (search "ran" s1)
8
 * (search "zzzz" s1)
NIL
*

如果未找到搜索字符串 (函数 search 的第一个参数), 函数 search 返回 nil, 否则 search 返回第二个参数字符串中的索引. 函数 search 接受几个可选的关键字参数 (有关关键字参数的讨论, 请参见下一章):

(search search-string a-longer-string :from-end :test
                                      :test-not :key
                                      :start1 :start2
                                      :end1 :end2)

在我们的讨论中, 我们将只使用关键字参数 :start2 来指定第二个参数字符串中的起始搜索索引, 以及 :from-end 标志来指定搜索应从第二个参数字符串的末尾开始并向字符串的开头反向进行:

 * (search " " s1)
3
 * (search " " s1 :start2 5)
7
 * (search " " s1 :from-end t)
18
*

序列函数 subseq 可用于字符串以从较长字符串中提取子字符串:

 * (subseq s1 8)
"ran up the tree"
>

在这里, 第二个参数指定起始索引; 从起始索引到字符串末尾的子字符串被返回. 一个可选的第三个索引参数指定了你想要提取的最后一个字符索引加一:

 * (subseq s1 8 11)
"ran"
*

从字符串的开头或结尾移除空白 (或其他) 字符通常很有用:

 * (string-trim '(#\space #\z #\a) " a boy said pez")
"boy said pe"
*

字符 #\\space 是空格字符. 其他常见的被修剪的字符是 #\\tab 和 #\\newline. 还有用于将字符串转换为大写或小写的实用函数:

 * (string-upcase "The dog bit the cat.")
"THE DOG BIT THE CAT."
 * (string-downcase "The boy said WOW!")
"the boy said wow!"
>

我们尚未讨论变量的相等性. 函数 eq 在两个变量引用内存中相同数据时返回 true. 函数 eql 在参数引用内存中相同数据, 或者它们是相等的数字或字符时返回 true. 函数 equal 更宽松: 它在两个变量求值后打印相同时返回 true. 更正式地说, 函数 equal 在 car 和 cdr 递归地彼此相等时返回 true. 一个例子将使这更清晰:

 * (defvar x '(1 2 3))
X
 * (defvar y '(1 2 3))
Y
 * (eql x y)
NIL
 * (equal x y)
T
 * x
(1 2 3)
 * y
(1 2 3)
*

对于字符串, 函数 string= 比使用函数 equal 略微高效:

 * (eql "cat" "cat")
NIL
 * (equal "cat" "cat")
T
 * (string= "cat" "cat")
T
*

Common Lisp 字符串是字符序列. 函数 char 用于从字符串中提取单个字符:

 * s1
"the cat ran up the tree"
 * (char s1 0)
#\t
 * (char s1 1)
#\h
*

哈希表是非常有用的数据类型. 虽然使用列表和 assoc 函数确实可以达到同样的效果, 但如果列表包含许多元素, 哈希表比列表效率高得多. 例如:

 * (defvar x '((1 2) ("animal" "dog")))
X
 * (assoc 1 x)
(1 2)
 * (assoc "animal" x)
NIL
 * (assoc "animal" x :test #'equal)
("animal" "dog")
*

函数 assoc 的第二个参数是一个由 cons 单元组成的列表. 函数 assoc 搜索一个子列表 (在第二个参数中), 其 car (即第一个元素) 等于函数 assoc 的第一个参数. 这个例子中可能令人惊讶的是 assoc 似乎适用于整数作为第一个参数, 但不适用于字符串. 原因在于默认情况下相等性测试是用 eql 完成的, eql 测试两个变量是否引用相同的内存位置, 或者如果它们是数字或字符是否相同. 在最后一次调用 assoc 时, 我们使用了 “:test #’equal” 来让 assoc 使用函数 equal 来测试相等性. 使用列表和 assoc 的问题在于它们对于大型列表效率非常低. 我们将看到使用哈希表编码并不更困难. 哈希表存储键和值对之间的关联, 很像我们上一个使用 assoc 函数的例子. 默认情况下, 哈希表使用 eql 来测试查找键匹配时的相等性. 我们将使用哈希表复制前面的例子:

 * (defvar h (make-hash-table))
H
 * (setf (gethash 1 h) 2)
2
 * (setf (gethash "animal" h) "dog")
"dog"
 * (gethash 1 h)
2 ;
T
 * (gethash "animal" h)
NIL ;
NIL
*

注意 gethash 返回多个值: 第一个值是匹配作为第一个参数传递给函数 gethash 的键的值, 第二个返回的值如果找到键则为 true, 否则为 nil. 如果哈希值为 nil, 则第二个返回的值可能很有用. 由于我们还没有看到如何处理函数的多个返回值, 我们将在此处进行介绍 (处理多个返回值的方法有很多, 我们只介绍其中一种):

 * (multiple-value-setq (a b) (gethash 1 h))
2
 * a
2
 * b
T
*

假设变量 a 和 b 已经声明, 变量 a 将被设置为从 gethash 返回的第一个值, 变量 b 将被设置为第二个返回的值. 如果我们使用符号作为哈希表键, 那么使用 eql 测试哈希表键的相等性是可以的:

 * (setf (gethash 'bb h) 'aa)
AA
 * (gethash 'bb h)
AA ;
T
*

然而, 我们看到 eql 不会匹配具有字符字符串值的键. 函数 make-hash-table 有可选的键参数, 其中之一允许我们使用字符串作为哈希键值:

(make-hash-table &key :test :size :rehash-size :rehash-threshold)

在这里, 我们只对第一个可选键参数 :test 感兴趣, 它允许我们在匹配哈希表键时使用函数 equal 来测试相等性. 例如:

 * (defvar h2 (make-hash-table :test #'equal))
H2
 * (setf (gethash "animal" h2) "dog")
"dog"
 * (setf (gethash "parrot" h2) "Brady")
"Brady"
 * (gethash "parrot" h2)
"Brady" ;
T
*

能够枚举哈希表中的所有键值对通常很有用. 这里有一个简单的例子, 首先定义一个函数 my-print, 它接受两个参数, 一个键和一个值. 然后我们可以使用 maphash 函数来调用我们的新函数 my-print, 并将哈希表中的每个键值对传递给它:

 * (defun my-print (a-key a-value)
(format t "key: ~A value: ~A~%" a-key a-value))
MY-PRINT
 * (maphash #'my-print h2)
key: parrot value: Brady
key: animal value: dog
NIL
*

函数 my-print 应用于哈希表中的每个键/值对. 这里还有一些我们演示的其他有用的哈希表函数:

 * (hash-table-count h2)
2
 * (remhash "animal" h2)
T
 * (hash-table-count h2)
1
 * (clrhash h2)
#S(HASH-TABLE EQUAL)
 * (hash-table-count h2)
0
*

函数 hash-table-count 返回哈希表中的键值对数量. 函数 remhash 可用于从哈希表中删除单个键值对. 函数 clrhash 通过删除哈希表中的所有键值对来清空哈希表.

有趣的是, clrhash 和 remhash 是我们目前看到的第一个修改其任何参数的 Common Lisp 函数, 除了作为宏而非函数的 setq 和 setf. 我们已经看到如何在 Lisp repl 监听器中键入任意 Lisp 表达式, 然后它们会被求值. 我们将在 Input and Output 章节中看到 Lisp 函数 read 求值列表 (或形式), 实际上 Lisp repl 使用函数 read. 在本节中, 我们将使用函数 eval 在程序内部求值任意 Lisp 表达式. 作为一个简单的例子:

 * (defvar x '(+ 1 2 3 4 5))
X
 * x
(+ 1 2 3 4 5)
 * (eval x)
15
*

使用函数 eval, 我们可以构建包含 Lisp 代码的列表, 并在我们自己的程序内部求值生成的代码. 我们得到了 “数据即代码” 的效果. 一个经典的 Lisp 程序, OPS5 专家系统工具, 将 Lisp 代码片段存储在网络数据结构中, 并使用函数 eval 执行存储在网络中的 Lisp 代码. 警告: 在非编译代码中使用 eval 可能效率低下. 为了效率, OPS5 程序包含了自己的 eval 版本, 该版本只解释网络中使用的 Lisp 子集.

我通常使用 Emacs, 但我们也将简要讨论编辑器 vi. 如果你使用 vi (例如, 输入 “vi nested.lisp”), 你首先应该做的是配置 vi, 以便在键入右括号时指示匹配的左括号; 你可以通过在 vi 运行时键入 “:set sm” 来完成此操作. 如果你选择学习 Emacs, 请在你的 .emacs 文件中 (如果你在 Windows 上运行, 则在你的主目录中的 _emacs 文件中) 输入以下内容:

(set-default 'auto-mode-alist
             (append '(("\\.lisp$" . lisp-mode)
                       ("\\.lsp$" . lisp-mode)
                       ("\\.cl$" . lisp-mode))
                     auto-mode-alist))

现在, 每当你打开扩展名为 “lisp”, “lsp” 或 “cl” (表示 “Common Lisp”) 的文件时, Emacs 将自动使用 Lisp 编辑模式. 我建议使用关键字 “Emacs tutorial” 在网上搜索以学习如何使用基本的 Emacs 编辑命令 - 我们在这里不会重复这些信息. 我使用免费软件工具进行我的专业 Lisp 编程: Emacs, SBCL, Clozure Common Lisp 和 Clojure. 我将在 Quicklisp 章节的最后部分向你展示如何配置 Emacs 和 Slime.

当你在 Lisp repl 监听器中输入形式 (或表达式) 时, 你偶尔会犯错误并抛出错误. 以下是一个例子, 其中我没有显示输入 help 时错误抛出时的所有输出:

 * (defun my-add-one (x) (+ x 1))

MY-ADD-ONE
 * (my-add-one 10)

11
 * (my-add-one 3.14159)

4.14159
 * (my-add-one "cat")

debugger invoked on a SIMPLE-TYPE-ERROR: Argument X is not a NUMBER: "cat"

Type HELP for debugger help, or (SB-EXT:EXIT) to exit from SBCL.

restarts (invokable by number or by possibly-abbreviated name):
0: [ABORT] Exit debugger, returning to top level.

(SB-KERNEL:TWO-ARG-+ "cat" 1)
0] help

调试提示符是方括号, 其中的数字指示当前的控制堆栈级别, 如果你递归地进入了调试器, 则指示你递归的深度. … 进出调试器: TOPLEVEL, TOP 退出调试器并返回到顶层 REPL RESTART 调用编号所示的重启 (如果未给出则提示). ERROR 打印错误条件和重启情况. … 检查帧: BACKTRACE [n] 显示堆栈向下 n 帧. LIST-LOCALS, L 列出当前帧中的局部变量. PRINT, P 显示当前帧的函数调用. SOURCE [n] 显示帧的源形式以及 n 级封闭形式. 单步执行: START 如果存在 CONTINUE 重启则选择它并开始单步执行. 单步执行仅影响使用高 DEBUG 优化质量编译的代码. 有关详细信息, 请参见用户手册. STEP 单步进入当前形式. NEXT 单步跳过当前形式. OUT 暂时停止单步执行, 但当进入的最顶层帧返回时恢复执行. STOP 停止单步执行. …

0] list-locals
SB-DEBUG::ARG-0 = "cat"
SB-DEBUG::ARG-1 = 1

0] backtrace 2

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {1002AC32F3}>
0: (SB-KERNEL:TWO-ARG-+ "cat" 1)
1: (MY-ADD-ONE "cat")
0] :0
*

在这里, 我首先使用回溯命令 :bt 来打印导致错误的函数调用序列. 如果很明显错误在我正在处理的代码中的位置, 那么我就不费心使用回溯命令了. 然后我使用中止命令 :a 恢复到顶层 Lisp 监听器 (即回到大于号提示符). 有时, 你必须多次键入 :a 才能完全恢复到顶层大于号提示符.

像 Java 和 Python 等其他语言一样, Common Lisp 提供垃圾回收 (GC) 或自动内存管理. 简单来说, GC 发生在 Lisp 环境中释放不再能被任何全局变量 (或函数闭包, 我们将在下一章介绍) 访问的内存时. 如果一个全局变量 *variable-1* 首先被设置为一个列表, 然后如果我们稍后将 *variable-1* 设置为, 例如 nil, 并且如果原始列表中引用的数据没有被任何其他可访问的数据引用, 那么这个现在未使用的数据就受 GC 处理. 在实践中, Lisp 数据的内存是按时间顺序分批分配的, 短暂或分代垃圾回收器回收近期内存分配的频率远高于已分配较长时间的内存.

当你开始为大型项目使用 Common Lisp 时, 你可能需要在开始工作时加载许多文件到你的 Lisp 环境中. 大多数 Common Lisp 实现都有一个名为 defsystem 的函数, 其工作方式有点像 Unix 的 make 实用程序. 虽然我强烈推荐 defsystem 用于大型多人项目, 但我通常在我自己工作时使用更简单的方案: 我在每个我工作的项目的顶层目录中放置一个文件 loadit.lisp. 对于任何项目, 其 loadit.lisp 文件会加载所有源文件并初始化项目所需的任何全局数据. 本书的最后两章提供了配置为与 Quicklisp 一起工作的示例应用程序, 我们将在下一章中学习 Quicklisp. 另一个好技巧是创建一个包含所有项目的所有代码和数据的 Lisp 镜像. 在 NLP 章节的第一部分有一个这样的例子. 在这个例子中, 加载我的 NLP (自然语言处理) 库的代码和数据需要几分钟时间, 所以当我在使用它时, 我希望能够快速加载 SBCL Lisp 镜像. 所有 Common Lisp 实现都有一个用于转储包含代码和数据的工作镜像的机制.

进行 Common Lisp 开发有两种主要风格. 面向对象编程得到了很好的支持 (请参阅关于 CLOS 的章节), 函数式编程也是如此. 简而言之, 函数式编程意味着我们应该编写没有副作用的函数. 首先让我给你一个带有副作用的非函数式例子:

(defun non-functional-example (car)
  (set-color car "red"))

这个使用 CLOS 的例子是非函数式的, 因为我们修改了函数参数的值. 像 Lisp Clojure 语言和 Haskell 语言这样的函数式语言不鼓励你修改函数的参数. 使用 Common Lisp, 你应该决定你喜欢哪种方法. 函数式编程意味着我们避免在函数内部维护状态, 并将数据视为不可变的 (即, 一旦创建对象, 就永远不会修改它). 我们可以修改最后一个例子, 使其成为函数式的: 在函数内部创建一个新的汽车对象, 复制作为对象传递的汽车的属性, 将新汽车对象的颜色更改为 “red”, 并返回新的汽车实例作为函数的值. 函数式编程可以防止许多类型的编程错误, 使单元测试更简单, 并使为现代多核 CPU 编程更容易, 因为只读对象本质上是线程安全的. Java 语言的现代最佳实践也倾向于使用不可变数据对象和函数式方法.

• Quicklisp

几十年来, 在开发 Lisp 系统时, 管理包和库是一个手动过程. 我过去常常将特定版本库的源代码打包作为我的 Common Lisp 项目的一部分. 早期的包管理系统 mk-defsystem 和 ASDF 非常有用, 但我并没有完全放弃将第三方库源代码与我的项目一起保存的做法, 直到 Zach Beane 创建了 Quicklisp 包系统²⁰. 你需要安装 Quicklisp 才能使用本书后面的许多示例, 所以请花点时间按照 Quicklisp 网站上的说明立即安装它.

我们将在后面的网络编程章节中需要 Common Lisp Hunchentoot 库, 所以我们现在将使用 Quicklisp 安装它, 作为开始使用 Quicklisp 的示例. 我们已经知道我们想要的包名, 但作为发现包的一个例子, 让我们开始使用 Quicklisp 搜索包名中包含 “hunchentoot” 的所有包:

 * (ql:system-apropos "hunchentoot")
#<SYSTEM clack-handler-hunchentoot / clack-20131111-git / quicklisp 2013-11-11>
#<SYSTEM hunchentoot / hunchentoot-1.2.21 / quicklisp 2013-11-11>
#<SYSTEM hunchentoot-auth / hunchentoot-auth-20101107-git / quicklisp 2013-11-11>
#<SYSTEM hunchentoot-cgi / hunchentoot-cgi-20121125-git / quicklisp 2013-11-11>
#<SYSTEM hunchentoot-dev / hunchentoot-1.2.21 / quicklisp 2013-11-11>
#<SYSTEM hunchentoot-single-signon / hunchentoot-single-signon-20131111-git / quickl\
isp 2013-11-11>
#<SYSTEM hunchentoot-test / hunchentoot-1.2.21 / quicklisp 2013-11-11>
#<SYSTEM hunchentoot-vhost / hunchentoot-vhost-20110418-git / quicklisp 2013-11-11>

我们想要第 3 行看到的基础包, 我们可以按照以下示例安装基础包:

 * (ql:quickload :hunchentoot)
To load "hunchentoot":
Load 1 ASDF system:
hunchentoot
; Loading "hunchentoot"
.......
(:HUNCHENTOOT)

在第 1 行, 我使用符号 :hunchentoot 来引用包名, 但使用字符串 “hunchentoot” 也可以. 第一次你使用 ql:quickload 加载一个库时, 你可能会看到额外的打印输出, 并且加载时间会更长, 因为源代码会从网上下载并缓存在本地目录 ~/.quicklisp/local-projects 中. 在本书的其余大部分内容中, 当我通过调用 ql:quickload 函数安装或使用包时, 我不会显示此函数在 repl 列表中的输出. 现在, 我们可以使用非常有用的 Common Lisp 函数 apropos 来查看刚刚安装的内容:

 * (apropos "hunchentoot")

HUNCHENTOOT::*CLOSE-HUNCHENTOOT-STREAM * (bound)
HUNCHENTOOT:*HUNCHENTOOT-DEFAULT-EXTERNAL-FORMAT * (bound)
HUNCHENTOOT::*HUNCHENTOOT-STREAM*
HUNCHENTOOT:*HUNCHENTOOT-VERSION * (bound)
HUNCHENTOOT:HUNCHENTOOT-CONDITION
HUNCHENTOOT:HUNCHENTOOT-ERROR (fbound)
HUNCHENTOOT::HUNCHENTOOT-OPERATION-NOT-IMPLEMENTED-OPERATION (fbound)
HUNCHENTOOT::HUNCHENTOOT-SIMPLE-ERROR
HUNCHENTOOT::HUNCHENTOOT-SIMPLE-WARNING
HUNCHENTOOT::HUNCHENTOOT-WARN (fbound)
HUNCHENTOOT:HUNCHENTOOT-WARNING
HUNCHENTOOT-ASD:*HUNCHENTOOT-VERSION * (bound)
HUNCHENTOOT-ASD::HUNCHENTOOT
:HUNCHENTOOT (bound)
:HUNCHENTOOT-ASD (bound)
:HUNCHENTOOT-DEV (bound)
:HUNCHENTOOT-NO-SSL (bound)
:HUNCHENTOOT-TEST (bound)
:HUNCHENTOOT-VERSION (bound)
*

只要你正在考虑现在工具箱中新增的 Quicklisp 工具, 你就应该安装你在学习本书其余部分时需要的大部分包和库. 我将展示加载更多库所需的语句, 而不显示每个包加载时在 repl 中打印的输出:

(ql:quickload "clsql")
(ql:quickload "clsql-postgresql")
(ql:quickload "clsql-mysql")
(ql:quickload "clsql-sqlite3")
(ql:quickload :drakma)
(ql:quickload :hunchentoot)
(ql:quickload :cl-json)
(ql:quickload "clouchdb") ;; for CouchDB access
(ql:quickload "sqlite")

你需要先在系统上安装 Postgres 和 MySQL 客户端开发库, 才能使 clsql-postgresql 和 clsql-mysql 安装工作. 如果你不太可能将 Common Lisp 用于关系数据库, 那么你可以跳过安装 Postgres 和 MySQL 的工作. Knowledge Graph Navigator 章节中的示例使用 SQLite 数据库进行缓存. 你不需要为 sqlite 包安装任何额外的依赖项.

我假设你的系统上已经安装了 Emacs. 在 repl 中你可以设置 Slime 包, 它允许 Emacs 连接到正在运行的 Lisp 环境:

(ql:quickload "quicklisp-slime-helper")

注意 repl 中的输出. 在我的系统上, 输出包含以下内容:

[package quicklisp-slime-helper]
slime-helper.el installed in "/Users/markw/quicklisp/slime-helper.el"

To use, add this to your ~/.emacs:

(load (expand-file-name "~/quicklisp/slime-helper.el"))
;; Replace "sbcl" with the path to your implementation
(setq inferior-lisp-program "sbcl")

如果你安装了 rlwrap 并定义了运行 SBCL 的别名, 请确保将 inferior lisp 程序设置为 SBCL 可执行文件的绝对路径; 在我的系统上, 我在我的 .emacs 文件中设置了以下内容:

(setq inferior-lisp-program "/Users/markw/sbcl/sbcl")

我不会介绍如何使用 Emacs 和 Slime, 网上有很多好的教程可供你阅读. 在后面的章节中, 我们将编写库和应用程序作为 Quicklisp 项目, 以便你能够加载自己的库, 从而更容易编写可以组合成更大应用程序的小型库.

定义匿名函数通常很有用. 我们可以使用 lambda 定义一个匿名函数; 例如, 让我们看一下示例文件 src/lambda1.lisp. 但首先, 我们将介绍 Common Lisp 函数 funcall, 它接受一个或多个参数; 第一个参数是一个函数, 任何剩余的参数都传递给绑定到第一个参数的函数. 例如:

 * (funcall 'print 'cat)
CAT
CAT
 * (funcall '+ 1 2)
3
 * (funcall #'- 2 3)
-1
*

在这里的前两个对 funcall 的调用中, 我们只是引用了我们想要调用的函数名. 在第三个例子中, 我们使用了一个更好的表示法, 通过 #’ 来引用. 我们使用 #’ 字符来引用一个函数名. 考虑以下 repl 列表, 我们将看一下使用 ‘ 和使用 #’ 引用符号的主要区别:

$ ccl
Clozure Common Lisp Version 1.12 DarwinX8664
? 'barfoo531
BARFOO531
? (apropos "barfoo")
BARFOO531
? #'bar987
> Error: Undefined function: BAR987

在第三行, 我们创建了一个新的符号 BARFOO531, 它是 interned 的, 正如你从查看包含字符串 “barfoo” 的所有 interned 符号所看到的那样. 第 7 行抛出一个错误, 因为 #’ 不会 intern 一个新符号. 以下是示例文件 src/lambda1.lisp:

(defun test ()
  (let ((my-func
          (lambda (x) (+ x 1))))
    (funcall my-func 1)))

在这里, 我们使用 lambda 定义了一个函数, 并将局部变量 my-func 的值设置为该匿名函数的值. 以下是函数 test 的输出:

 * (test)
2

*

将函数用作数据的能力非常有用. 现在, 我们来看一个简单的例子:

 * (defvar f1 #'(lambda (x) (+ x 1)))

F1
 * (funcall f1 100)

101
 * (funcall #'print 100)

100
100

请注意, 第二次调用函数 testfn 打印了 “100” 两次: 第一次是调用函数 print 的副作用, 第二次是 testfn 的返回值 (函数 print 将其打印的内容作为其值返回).

稍后, 我们将看到如何使用特殊的 Common Lisp 宏来编程重复循环. 在本节中, 我们将使用递归来编码简单的循环, 并作为一种有效的方式来解决各种可以用递归自然表达的问题. 像往常一样, 本节的示例程序可以在 src 目录中找到. 在文件 src/recursion1.lisp 中, 我们看到了我们的第一个递归示例:

;; a simple loop using recursion

(defun recursion1 (value)
  (format t "entering recursion1(~A)~%" value)
  (if (< value 5)
      (recursion1 (1+ value))))

这个例子很简单, 但对于讨论几点很有用. 首先, 注意函数 recursion1 只有在输入参数 “value” 小于 5 时才以其自身输入参数加一的值调用自身. 这个测试阻止了函数进入无限循环. 以下是一些示例输出:

 * (load "recursion1.lisp")
;; Loading file recursion1.lisp ...
;; Loading of file recursion1.lisp is finished.
T
 * (recursion1 0)
entering recursion1(0)
entering recursion1(1)
entering recursion1(2)
entering recursion1(3)
entering recursion1(4)
entering recursion1(5)
NIL
 * (recursion1 -3)
entering recursion1(-3)
entering recursion1(-2)
entering recursion1(-1)
entering recursion1(0)
entering recursion1(1)
entering recursion1(2)
entering recursion1(3)
entering recursion1(4)
entering recursion1(5)
NIL
 * (recursion1 20)
entering recursion1(20)
NIL
*

为什么第 24 行的调用没有通过递归循环? 因为输入参数不小于 5, 所以没有发生递归.

我们已经看到函数可以接受其他函数作为参数, 并返回新函数作为值. 引用外部词法作用域变量的函数称为闭包. 示例文件 src/closure1.lisp 包含一个简单的例子:

(let* ((fortunes
         '("You will become a great Lisp Programmer"
           "The force will not be with you"
           "Take time for meditation"))
       (len (length fortunes))
       (index 0))
  (defun fortune ()
    (let ((new-fortune (nth index fortunes)))
      (setq index (1+ index))
      (if (>= index len) (setq index 0))
      new-fortune)))

在这里, 函数 fortune 是在一个 let 形式内部定义的. 因为局部变量 fortunes 在函数 fortune 内部被引用, 所以变量 fortunes 在 let 形式求值后仍然存在. 理解这一点很重要, 通常在 let 形式内部定义的局部变量会 “超出作用域” 并且在 let 形式求值后不能再被引用. 然而, 在这个例子中, 除了调用函数 fortune 之外, 没有办法访问变量 fortunes 的内容. 至少, 闭包是隐藏变量的好方法. 以下是加载 src/closure1.lisp 文件并多次调用函数 fortune 的一些输出:

 * (load "closure1.lisp")
;; Loading file closure1.lisp ...
;; Loading of file closure1.lisp is finished.
T
 * (fortune)
"You will become a great Lisp Programmer"
 * (fortune)
"The force will not be with you"
 * (fortune)
"Take time for meditation"
 * (fortune)
"You will become a great Lisp Programmer"
*

在 Lisp 语言中, 我们常说代码即数据. 函数 eval 可以用来执行存储为 Lisp 数据的代码. 让我们看一个例子:

$ ccl
Clozure Common Lisp Version 1.12 DarwinX8664
? '(+ 1 2.2)
(+ 1 2.2)
? (eval '(+ 1 2.2))
3.2
? (eval '(defun foo2 (x) (+ x x)))
FOO2
? (foo2 4)
8

亲爱的读者, 你多久会想使用 eval 取决于你. 在我使用 Lisp 语言的四十年里, 我对 eval 的主要用途是修改 Ops5 生产系统编程语言²¹ 的标准版本, 以支持像多个数据世界以及派生新数据世界和移除它们的动作. Ops5 通过在一组产生式规则 (也称为 “专家系统”) 中找到共同表达式并将它们分解到一个网络 (如果你想查找的话, 是一个 Rete 网络), 其中规则中的共同表达式存储在一个地方. eval 在 Ops5 中被大量使用, 我用它来扩展 Ops5.

文件 src/macro1.lisp 包含一个简单的宏和一个使用该宏的函数. 这个宏的例子有点刻意为之, 因为它本可以只是一个函数定义, 但它确实展示了创建和使用宏的过程. 我们使用 gensym 函数来定义一个新的唯一符号来引用一个临时变量:

;; first simple macro example:

(defmacro double-list (a-list)
  (let ((ret (gensym)))
    `(let ((,ret nil))
       (dolist (x ,a-list)
         (setq ,ret (append ,ret (list x x))))
       ,ret)))

;; use the macro:

(defun test (x)
  (double-list x))

在第 5 行开头看到的反引号字符用于以特殊方式引用列表: 列表中的任何内容在宏展开期间都不会被求值, 除非它紧跟在一个逗号字符之后. 在本例中, 我们指定 ,a-list 是因为我们希望 宏参数 a-list 的值被替换到特殊引用的列表中. 我们将在下一章详细介绍 dolist, 但现在只要理解 dolist 用于迭代列表的顶层元素就足够了, 例如:

 * (dolist (x '("the" "cat" "bit" "the" "rat"))
(print x))
"the"
"cat"
"bit"
"the"
"rat"
NIL
*

请注意, 示例宏 double-list 本身使用了宏 dolist. 以函数可以嵌套的方式嵌套宏是很常见的. 回到我们在文件 src/macro1.lisp 中的宏示例, 我们将尝试使用宏 double-list 的函数 test:

* (load "macro1.lisp")
;; Loading file macro1.lisp ...
;; Loading of file macro1.lisp is finished.
T
* (test '(1 2 3))
(1 1 2 2 3 3)
*

另一个类似的例子在文件 src/macro2.lisp 中:

;; another macro example that uses ,@:

(defmacro double-args (&rest args)
  `(let ((ret nil))
     (dolist (x ,@args)
       (setq ret (append ret (list x x))))
     ret))

;; use the macro:

(defun test (&rest x)
  (double-args x))

在这里, 拼接运算符 ,@ 用于在宏 double-args 中替换列表 args.

函数 macroexpand-1 用于将带有参数的宏转换为新的 Lisp 表达式. 例如:

 * (defmacro double (a-number)
(list '+ a-number a-number))
DOUBLE
 * (macroexpand-1 '(double n))
(+ N N) ;
T
*

编写宏是扩展 Lisp 语言的有效方法, 因为你可以控制传递给 Common Lisp 编译器的代码. 在两个宏示例文件中, 当定义函数 test 时, 宏展开在编译器处理代码之前完成. 我们将在下一章看到 Common Lisp 中包含的几个有用的宏. 我们只是 “浅尝辄止” 地了解了宏; 鼓励感兴趣的读者使用例如 “Common Lisp macros” 在网上搜索. 我特别推荐两本书深入探讨 Common Lisp 宏: Paul Graham 的 “On Lisp” 和 Doug Hoyte 的 “Let Over Lambda”. 两者都是深入的书籍, 会改变你体验软件开发的方式. 一个好的学习计划是花一年时间吸收 “On Lisp”, 然后再 tackling “Let Over Lambda”.

我们在上一章看到了 dolist 的一个快速示例. dolist 宏的参数是:

(dolist (a-variable a-list [optional-result-value]) ...body... )

通常, dolist 宏返回 nil 作为其值, 但我们可以添加第三个可选参数, 该参数将作为生成表达式的值返回; 例如:

 * (dolist (a '(1 2) 'done) (print a))
1
2
DONE
 * (dolist (a '(1 2)) (print a))
1
2
NIL
*

dolist 宏的第一个参数是一个局部词法作用域变量. 一旦由 dolist 宏生成的代码执行完毕, 该变量就未定义了.

当你需要一个带有整数循环索引的循环时, 使用 dotimes 宏. dotimes 宏的参数是:

(dotimes (an-index-variable max-index-plus-one [optional-result-value])
  ...body... )

通常, dotimes 宏返回 nil 作为其值, 但我们可以添加一个第三个可选参数, 该参数将作为生成表达式的值返回; 例如:

 * (dotimes (i 3 "all-done-with-test-dotimes-loop") (print i))

0
1
2
"all-done-with-test-dotimes-loop"
*

与 dolist 宏一样, 你通常会在 dotimes 宏内部使用 let 形式来声明额外的临时 (词法) 变量.

do 宏比 dotimes 或 dolist 更通用, 但使用起来更复杂. 以下是使用 do 循环宏的一般形式:

(do ((variable-1 variable-1-init-value variable-1-update-expression)
     (variable-2 variable-2-init-value variable-2-update-expression)
     .
     .
     (variable-N variable-N-init-value variable-N-update-expression))
    (loop-termination-test loop-return-value)
 optional-variable-declarations
 expressions-to-be-executed-inside-the-loop)

有一个类似的宏 do*, 它类似于 let*, 因为循环变量的值可以依赖于先前声明的循环变量的值. 作为一个简单的例子, 这里有一个打印 0 到 3 整数的循环. 这个例子在文件 src/do1.lisp 中:

;; example do macro use
(do ((i 0 (1+ i)))
    ((> i 3) "value-of-do-loop")
  (print i))

在这个例子中, 我们只声明了一个循环变量, 所以我们本可以使用更简单的 dotimes 宏. 这里我们加载文件 src/do1.lisp:

 * (load "do1.lisp")
;; Loading file do1.lisp ...
0
1
2
3
;; Loading of file do1.lisp is finished.
T
*

你会注意到我们没有看到 do 循环的返回值 (即字符串 “value-of-do-loop”), 因为我们正在求值的顶层形式是对函数 load 的调用; 我们确实看到了 load 的返回值打印出来. 如果我们手动在 Lisp 监听器中键入这个示例循环, 那么你会看到最终值 value-of-do-loop 被打印出来.

我们之前使用 dolist 来迭代列表中的元素. 为了效率, 我们通常会使用向量 (一维数组), 我们可以使用 loop 来类似地处理向量:

(loop for td across testdata
      do
         (print td))))

其中 testdata 是一个一维数组 (向量), 在 do 块内部, 局部变量 td 被赋给向量中的每个元素.

• Common Lisp 包系统

在后面的章节中, 我们将看到两个定义为 Quicklisp 项目的完整应用程序: 关于 Knowledge Graph Creator 的章节和关于 Knowledge Graph Navigator 的章节. 另一个设置 Quicklib 项目的示例可以在 Plotting Data 章节中看到. 虽然这些后面的章节提供了将你自己的项目打包到包中的实际示例, 但这里的内容将为你提供你应该了解的一般背景信息. 在我们目前看到的简单示例中, 所有新创建的 Lisp 符号都已放置在默认包中. 你始终可以通过求值表达式 package 来检查当前包:

> *package*
#<PACKAGE COMMON-LISP-USER>
>

正如我们将在以下示例中使用的, 包 :cl 是 :common-lisp-user 的别名. 我们将定义一个新包 :my-new-package 以及包内的两个函数 foo1 和 foo2. 在此包外部, 假设它已加载, 我们可以使用 my-new-package:foo2 访问 foo2. foo1 未导出, 因此无法以这种方式访问. 但是, 如果我们想使用在另一个包中定义的符号, 我们可以始终以包名和两个冒号字符开头符号名, 因此我们可以使用 my-new-package::foo1. 使用 :: 允许我们访问未显式导出的符号. 当我在第 22 行离开包 :my-new-package 并返回到包 :cl 时, 尝试访问 my-new-package:foo1 会注意到抛出一个错误. 在第 3 行, 我们为包 :my-new-package 定义了别名 :p1, 并在第 44 行使用了这个别名. 以下示例的主要目的是我们在一个包中定义了两个函数, 但只导出了其中一个函数. 默认情况下, 另一个函数在新包外部不可见.

 * (defpackage "MY-NEW-PACKAGE"
(:use :cl)
(:nicknames "P1")
(:export :FOO2))

#<PACKAGE "MY-NEW-PACKAGE">
 * (in-package my-new-package)

#<PACKAGE "MY-NEW-PACKAGE">
 * (defun foo1 () "foo1")

FOO1
 * (defun foo2 () "foo2")

FOO2
 * (foo1)

"foo1"
 * (foo2)

"foo2"
 * (in-package :cl)

#<PACKAGE "COMMON-LISP">
 * (my-new-package:foo2)

"foo2"
 * (my-new-package:foo1)

debugger invoked on a SB-INT:SIMPLE-READER-PACKAGE-ERROR in thread
#<THREAD "main thread" RUNNING {1001F1ECE3}>:
The symbol "FOO1" is not external in the MY-NEW-PACKAGE package.

Stream: #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDIN* {100001C343}>

Type HELP for debugger help, or (SB-EXT:EXIT) to exit from SBCL.

restarts (invokable by number or by possibly-abbreviated name):
0: [CONTINUE] Use symbol anyway.
1: [ABORT ] Exit debugger, returning to top level.

 * 1

 * (p1:foo2)

"foo2"

由于我们在 defpackage 表达式中指定了一个昵称, Common Lisp 允许在调用从包 :my-new-package 导出的函数 foo2 时使用该昵称 (在本例中是 P1). 在最后一个例子的末尾附近, 我们切换回默认包 COMMON-LISP-USER, 所以我们必须在第 42 行指定函数 foo2 的包名. 那么第 28 行的错误是怎么回事, my-new-package:foo1 未定义, 因为函数 foo1 未导出 (见第 4 行)? 事实证明, 你可以通过使用 :: 而不是单个 : 来轻松使用未从包导出的符号. 在这里, 它将被定义为: (my-new-package::foo1). 当你编写非常大的 Common Lisp 程序时, 将程序分解成不同的模块并将每个模块及其所有必需的数据放在不同的命名空间中 (通过创建新包) 是很有用的. 请记住, 所有符号, 包括变量, 生成的符号, CLOS 方法, 函数和宏都在某个包中. 对于小型包, 我有时会在文件顶部放置一个 defpackage 表达式, 紧随其后的是一个 in-package 表达式以切换到新包. 在一般情况下, 请像我在后面的 Knowledge Graph Creator 和 Knowledge Graph Navigator 章节中那样正确使用单独的 project 和 asdf 文件.

函数 read 用于读取一个 Lisp 表达式. 函数 read 在读取一个表达式后停止读取, 并忽略换行符. 我们将看一个使用示例 Lisp 程序 (在文件 read-test-1.lisp 中) 读取文件 test.dat 的简单示例. 这两个文件都可以在随本书附带的目录 src/code_snippets_for_book 中找到. 在 src 目录中启动你的 Lisp 程序. 文件 test.dat 的内容是:

1 2 3
4 "the cat bit the rat"
read with-open-file

在函数 read-test-1 中, 我们使用宏 with-open-file 从文件中读取. 要向文件写入 (我们稍后会做), 我们可以使用关键字参数 :direction :output. 宏 with-open-file 的第一个参数是一个绑定到新创建的输入流 (或者如果我们正在写入文件, 则为输出流) 的符号; 然后可以在调用任何需要流参数的函数时使用此符号. 请注意, 我们用三个参数调用函数 read: 一个输入流, 一个标志指示如果出现 I/O 错误 (例如, 到达文件末尾) 是否应抛出错误, 第三个参数是如果到达文件 (或流) 末尾时函数 read 应返回的值. 当使用这三个参数调用 read 时, 要么返回文件 test.dat 中的下一个表达式, 要么在到达文件末尾时返回 nil 值. 如果我们确实到达了文件末尾, 局部变量 x 将被赋为 nil 值, 函数 return 将跳出 dotimes 循环. 使用宏 with-open-file 而不是使用 open 函数 (我们不会介绍) 的一个巨大优势是, 当离开由 with-open-file 宏生成的代码时, 文件流会自动关闭. 文件 read-test-1.lisp 的内容是:

(defun read-test-1 ()
  "read a maximum of 1000 expressions from the file 'test.dat'"
  (with-open-file
      (input-stream "test.dat" :direction :input)
    (dotimes (i 1000)
      (let ((x (read input-stream nil nil)))
        (if (null x) (return)) ;; break out of the 'dotimes' loop
        (format t "next expression in file: ~S~%" x)))))

以下是你加载文件 read-test-1.lisp 并执行表达式 (read-test-1) 时将看到的输出:

 * (load "read-test-1.lisp")
;; Loading file read-test-1.lisp ...
;; Loading of file read-test-1.lisp is finished.
T
 * (read-test-1)
next expression in file: 1
next expression in file: 2
next expression in file: 3
next expression in file: 4
next expression in file: "the cat bit the rat"
NIL

注意: 字符串 “the cat bit the rat” 作为字符串打印 (带有引号), 因为我们在调用函数 format 的格式字符串中使用了 ~S 而不是 ~A. 在最后一个例子中, 我们将文件名作为字符串传递给宏 with-open-file. 这通常在所有操作系统上都不可移植. 相反, 我们可以创建一个路径名对象并传递它. 函数 pathname 可以接受八个不同的关键字参数, 但我们只在示例文件 read-test-2.lisp (在 src 目录中) 中使用最常见的两个. 以下列表仅显示了此示例与上一个示例之间的差异:

(let ((a-path-name
        (make-pathname :directory "testdata"
                       :name "test.dat")))
  (with-open-file
      (input-stream a-path-name :direction :input)

在这里, 我们指定了我们想要使用子目录 testdata 中的文件 test.dat. 注意: 我几乎从不使用路径名. 相反, 我使用字符串指定文件, 并使用字符 / 作为目录分隔符. 我发现这对于使用所有 Common Lisp 实现的 Macintosh, Windows 和 Linux 操作系统来说是可移植的. 文件 readline-test.lisp 与文件 read-test-1.lisp 相同, 只是我们调用函数 readline 而不是函数 read, 并且我们更改了输出格式消息以指示已读取整行文本:

(defun readline-test ()
  "read a maximum of 1000 expressions from the file 'test.dat'"
  (with-open-file
      (input-stream "test.dat" :direction :input)
    (dotimes (i 1000)
      (let ((x (read-line input-stream nil nil)))
        (if (null x) (return)) ;; break out of the 'dotimes' loop
        (format t "next line in file: ~S~%" x)))))

当我们执行表达式 (readline-test) 时, 请注意输入文件第二行中包含的字符串的引号字符已被转义:

 * (load "readline-test.lisp")
;; Loading file readline-test.lisp ...
;; Loading of file readline-test.lisp is finished.
T
 * (readline-test)
next line in file: "1 2 3"
next line in file: "4 \"the cat bit the rat\""
NIL
*

我们还可以从字符串的内容创建输入流. 文件 read-from-string-test.lisp 与示例文件 read-test-1.lisp 非常相似, 只是我们使用了宏 with-input-from-string (注意我是如何在测试字符串内部转义引号字符的):

(defun read-from-string-test ()
  "read a maximum of 1000 expressions from a string"
  (let ((str "1 2 \"My parrot is named Brady.\" (11 22)"))
    (with-input-from-string
        (input-stream str)
      (dotimes (i 1000)
        (let ((x (read input-stream nil nil)))
          (if (null x) (return)) ;; break out of the 'dotimes' loop
          (format t "next expression in string: ~S~%" x))))))

当我们加载文件 read-from-string-test.lisp 时, 我们会看到以下输出:

 * (load "read-from-string-test.lisp")
;; Loading file read-from-string-test.lisp ...
;; Loading of file read-from-string-test.lisp is finished.
T
 * (read-from-string-test)
next expression in string: 1
next expression in string: 2
next expression in string: "My parrot is named Brady."
next expression in string: (11 22)
NIL
*

我们已经看到了流抽象如何有助于在各种流数据上允许相同的操作. 在下一节中, 我们将看到这种通用性也适用于 Lisp 打印函数.

本节中我们将介绍的所有打印函数都接受一个可选的最后一个参数, 即输出流. 例外的是 format 函数, 它可以接受一个流值作为其第一个参数 (或 t 表示 *standard-output*, 或 nil 值表示 format 应返回一个字符串值). 以下是指定可选流参数的示例:

 * (print "testing")

"testing"
"testing"
 * (print "testing" *standard-output*)

"testing"
"testing"
*

函数 print 打印 Lisp 对象, 以便可以使用函数 read 将它们读回. 相应的函数 princ 用于打印供 “人类消费”. 例如:

 * (print "testing")

"testing"
"testing"
 * (princ "testing")
testing
"testing"
*

print 和 princ 都返回它们的第一个参数作为它们的返回值, 正如你在前面的输出中看到的那样. 注意 princ 也不打印换行符, 所以 princ 经常与 terpri 一起使用 (它也接受一个可选的流参数). 我们在这本书中也看到了许多使用 format 函数的例子. 以下是 format 的不同用法, 通过为其第一个参数指定 nil 值来构建字符串:

 * (let ((l1 '(1 2))
(x 3.14159))
(format nil "~A~A" l1 x))
"(1 2)3.14159"
*

我们还没有看到写入文件的例子. 在这里, 我们将使用 with-open-file 宏以及选项来写入文件并删除任何同名的现有文件:

(with-open-file (out-stream "test1.dat"
                            :direction :output
                            :if-exists :supersede)
  (print "the cat ran down the road" out-stream)
  (format out-stream "1 + 2 is: ~A~%" (+ 1 2))
  (princ "Stoking!!" out-stream)
  (terpri out-stream))

以下是求值此表达式的结果 (即, 在 src 目录中新创建的文件 test1.dat 的内容):

% cat test1.dat

"the cat ran down the road" 1 + 2 is: 3
Stoking!!

请注意, print 在打印其参数之前会生成一个换行符.

这里的示例都包含在目录 src/plotlib 中, 并打包为可加载的 Quicklisp 库. 这个库将在后面的章节中使用. 当我在我的 macOS 笔记本电脑上工作时, 我会将输出的图形文件在预览应用程序中保持打开状态, 每当我在 REPL 中重新运行生成图形的程序时, 激活预览应用程序窗口会刷新图形显示.

以下列表显示了文件 plotlib.lisp, 它是 vecto Common Lisp 绘图库的一个简单包装器. 请注意, 我只实现了我后续示例中需要的 vecto 功能的包装器, 因此以下代码并非特别通用, 但应该足够容易为你扩展以满足你项目的特定需求.

两个文件 src/plotlib/plotlib.asd src/plotlib/package.lisp 配置了该库. 文件 package.lisp 定义了所需的库 vecto 并列出了从该库公共导出的函数:

(defpackage #:plotlib
  (:use #:cl #:vecto)
  (:export save-png plot-fill-rect plot-frame-rect
           plot-size-rect plot-line plot-string plot-string-bold
           pen-width))

要运行此库提供的测试函数, 你需要加载该库并在导出的函数名前加上包名 plotlib:, 如此示例所示:

(ql:quickload "plotlib")
(plotlib::test-plotlib "test-plotlib.png")

除了 package.lisp 文件, 我们还使用扩展名为 .asd 的文件:

(asdf:defsystem #:plotlib
  :description "Describe plotlib here"
  :author "mark.watson@gmail.com"
  :license "Apache 2"
  :depends-on (#:vecto)
  :components ((:file "package")
               (:file "plotlib")))

如果你指定了一个尚未下载到你计算机上的依赖项, Quicklisp 将为你安装该依赖项.

• Common Lisp 对象系统 - CLOS

CLOS 是第一个 ANSI 标准化的面向对象编程设施. 虽然我在我的 Common Lisp 程序中不像使用 Java 和 Smalltalk 时那样经常使用类和对象, 但很难想象一个没有定义和使用至少几个 CLOS 类的任何规模的 Common Lisp 程序. 本章的示例程序位于文件 src/loving_snippets/HTMLstream.lisp 中. 大约十年前, 我在一个为我的商业自然语言处理产品自动生成演示网页的演示中使用了这个 CLOS 类. 我们将从反向的方式开始讨论 CLOS, 首先看一个使用 HTMLstream 类的简短测试函数. 一旦我们看到如何使用这个示例 CLOS 类, 我们将通过详细讨论 HTMLstream 类的实现来介绍 CLOS 的一小部分内容, 最后在本章末尾看到一些更多的 CLOS 编程技术. 本书仅提供对 CLOS 的简要介绍; 鼓励感兴趣的读者在网上搜索 “CLOS tutorial”. 定义用于实现 CLOS 的宏和函数是 Common Lisp 的标准部分. Common Lisp 支持泛型函数, 即具有相同名称但通过不同参数类型区分的不同函数.

文件 src/loving_snippets/HTMLstream.lisp 在文件末尾包含一个简短的测试程序:

(defun test (&aux x)
  (setq x (make-instance 'HTMLstream))
  (set-header x "test page")
  (add-element x "test text - this could be any element")
  (add-table
   x
   '(("<b>Key phrase</b>" "<b>Ranking value</b>")
     ("this is a test" 3.3)))
  (get-html-string x))

泛型函数 make-instance 接受以下参数:

make-instance class-name &rest initial-arguments &key ...

函数 test 中使用了四个泛型函数:

• set-header - 需要初始化类并定义页面标题
• add-element - 用于插入定义任何类型 HTML 元素的字符串
• add-table - 接受一个列表的列表, 并使用列表数据构造一个 HTML 表格
• get-html-string - 关闭流并返回所有生成的 HTML 数据作为字符串

在函数 test 中首先要注意的是, 调用这些泛型函数中的每一个的第一个参数都是类 HTMLstream 的一个实例. 你也可以自由地定义一个函数, 例如, add-element, 它不接受类 HTMLstream 的实例作为第一个函数参数, 对 add-element 的调用将被正确地路由到正确的函数定义. 我们将看到宏 defmethod 的作用类似于 defun, 不同之处在于它还允许我们定义许多具有相同函数名的方法 (即类的函数), 这些方法通过不同的参数类型和可能不同的参数数量来区分.

类 HTMLstream 非常简单, 将作为 CLOS 编程的一个合理介绍. 稍后我们将看到使用多重继承的更复杂的类示例. 尽管如此, 这是一个很好的例子, 因为代码简单, 作者经常使用这个类 (一些证明它有用!). 本节中列出的代码片段都包含在文件 src/loving_snippets/HTMLstream.lisp 中. 我们使用宏 defclass 开始定义一个新类, 它接受以下参数:

defclass class-name list-of-super-classes
list-of-slot-specifications class-specifications

HTMLstream 的类定义相当简单:

(defclass HTMLstream ()
  ((out :accessor out))
  (:documentation "Provide HTML generation services"))

在这里, 类名是 HTMLstream, 超类列表是一个空列表 (), slot 规范列表只包含一个名为 out 的 slot 的规范, 并且只有一个类规范: 一个文档字符串. Slot 类似于 Java 和 Smalltalk 等语言中的实例变量. 大多数 CLOS 类至少继承自一个超类, 但我们将在下一节中看到继承的例子. 只有一个 slot (或实例变量), 我们定义了一个与其 slot 名称同名的访问器变量. 这是我个人的偏好, 即将读/写访问器变量命名为与其 slot 名称相同. 方法 set-header 初始化此类的实例内部使用的字符串输出流. 此方法使用方便的宏 with-accessors, 它将一组局部变量绑定到一个或多个类 slot 访问器. 我们将列出整个方法, 然后讨论它:

(defmethod set-header ((ho HTMLstream) title)
  (with-accessors
        ((out out))
      ho
    (setf out (make-string-output-stream))
    (princ "<HTML><head><title>" out)
    (princ title out)
    (princ "</title></head><BODY>" out)
    (terpri out)))

关于 defmethod 首先要注意的有趣之处是参数列表: 有两个参数 ho 和 title, 但我们将参数 ho 约束为类 HTMLstream 的成员或 HTMLstream 的子类. 现在, 既然我们将类 HTMLstream 的实例传递给这个泛型函数 (或方法 – 我交替使用术语 “泛型函数” 和 “方法”), 我们希望能够访问为此类定义的 slot, 这似乎是合理的. 方便的宏 with-accessors 正是我们需要的, 用于在此类的泛型函数 (或方法) 内部获取对 slot 的读写访问权限. 在术语 ((out out)) 中, 第一个 out 是绑定到此类实例 ho 的名为 out 的 slot 值的局部变量. 在 with-accessors 宏内部, 我们现在可以使用 setf 将 slot 值设置为新的字符串输出流. 注意: 我们在本书中尚未介绍 Common Lisp 类型 string-output-stream, 但我们将在下一页解释其用法. 当对方法 set-header (带有 HTMLstream 实例和字符串标题的参数) 的调用完成时, 该实例的 slot 被设置为一个新的 string-output-stream, 并且 HTML 头部信息被写入新创建的字符串输出流. 注意: 这个字符串输出流现在可供在 set-header 之后调用的任何类方法使用. 在文件 src/loving_snippets/HTMLstream.lisp 中定义了几个方法, 但我们将只看其中的四个: add-H1, add-element, add-table 和 get-html-string. 其余方法与 add-H1 非常相似, 读者可以阅读源代码中的代码. 与方法 set-header 一样, 方法 add-H1 使用宏 with-accessors 来访问流输出流 slot 作为局部变量 out. 在 add-H1 中, 我们使用我们在 Input and Output 章节中讨论过的函数 princ 将 HTML 文本写入字符串输出流:

(defmethod add-H1 ((ho HTMLstream) some-text)
  (with-accessors
        ((out out))
      ho
    (princ "<H1>" out)
    (princ some-text out)
    (princ "</H1>" out)
    (terpri out)))

方法 add-element 与 add-H1 非常相似, 不同之处在于作为第二个参数传递的字符串 element 直接写入流输出流 slot:

(defmethod add-element ((ho HTMLstream) element)
  (with-accessors
        ((out out))
      ho
    (princ element out)
    (terpri out)))

方法 add-table 将一个列表的列表转换为 HTML 表格. Common Lisp 函数 princ-to-string 是一个有用的实用函数, 用于将任何变量的值写入字符串. 函数 string-left-trim 和 string-right-trim 是字符串实用函数, 它们接受两个参数: 一个字符列表和一个字符串, 并分别从字符串的左侧或右侧移除这些字符. 注意: 另一个接受相同参数的类似函数是 string-trim, 它从字符串的前面 (左) 和后面 (右) 移除字符. 这三个函数都不修改第二个字符串参数; 它们返回一个新的字符串值. 以下是 add-table 方法的定义:

(defmethod add-table ((ho HTMLstream) table-data)
  (with-accessors
        ((out out))
      ho
    (princ "<TABLE BORDER=\"1\" WIDTH=\"100\%\">" out)
    (dolist (d table-data)
      (terpri out)
      (princ " <TR>" out)
      (terpri out)
      (dolist (w d)
        (princ " <TD>" out)
        (let ((str (princ-to-string w)))
          (setq str (string-left-trim '(#\() str))
          (setq str (string-right-trim '(#\)) str))
          (princ str out))
        (princ "</TD>" out)
        (terpri out))
      (princ " </TR>" out)
      (terpri out))
    (princ "</TABLE>" out)
    (terpri out)))

方法 get-html-string 通过使用函数 get-output-stream-string 获取存储在字符串输出流 slot 中的字符串:

(defmethod get-html-string ((ho HTMLstream))
  (with-accessors
        ((out out))
      ho
    (princ "</BODY></HTML>" out)
    (terpri out)
    (get-output-stream-string out)))

CLOS 是一个用于面向对象编程的丰富框架, 提供了 Java, Ruby 和 Smalltalk 等语言中功能的超集. 在这个简短的生成 HTML 的 CLOS 示例中, 我仅仅触及了皮毛. 在本书后面的内容中, 每当你看到对 make-instance 的调用时, 这就表明我们正在使用 CLOS, 即使我没有特别提到 CLOS.

你可能会从我自己的代码中注意到, 我使用 Common Lisp defstruct 宏来定义数据结构的频率高于我使用 CLOS. 用于创建 CLOS 类的 defclass 宏要灵活得多, 但对于简单的数据结构, 我发现使用 defstruct 更简洁. 在最简单的情况下, defstruct 可以只是新类型的名称, 后跟 slot 名称. 对于像 my-slot-1 这样的每个 slot, 会自动生成访问器函数. 这里有一个简单的例子:

$ ccl
Clozure Common Lisp Version 1.12 DarwinX8664
? (defstruct struct1 s1 s2)
STRUCT1
? (make-struct1 :s1 1 :s2 2)
#S(STRUCT1 :S1 1 :S2 2)
? (struct1-s1 (make-struct1 :s1 1 :s2 2))
1

我们在第 3 行定义了一个名为 struct1 的结构体, 它有两个 slot 名称 s1 和 s2, 在第 5 行展示了自动生成的构造函数 make-struct1 的用法, 在第 7 行展示了两个自动生成的访问器函数之一 struct1-s1. 访问器函数的名称由结构体名称和 slot 名称构成.

Edi Weitz 的 Drakma 库²⁵ 支持通过 HTTP 请求获取数据. 正如你在 Drakma 文档中看到的, 你可以使用此库进行经过身份验证的 HTTP 请求 (即允许你访问需要登录的网站), 支持 HTTP GET 和 PUT 操作, 以及处理 cookie. 我们将使用的顶层 API 是 drakma:http-request, 它返回多个值. 在以下示例中, 我只想要前三个值, 并忽略其他值, 如获 取的原始 URI 和 IO 流对象. 我们使用内置的 Common Lisp 宏 multiple-value-setq:

* (ql:quickload :drakma)
* (multiple-value-setq
      (data http-response-code headers)
    (drakma:http-request "http://baidu.com"))

我手动格式化了我在上一个 repl 列表中输入的最后一个语句, 并且我将继续在本书的其余部分手动编辑 repl 列表, 使它们更易于阅读. 以下显示了绑定到变量 data, http-response-code 和 headers 的一些数据:

* data

"<!DOCTYPE html>
<html>
<head>
<title>Mark Watson: Consultant and Author</title>

http-response-code 的值是 200, 这意味着没有错误:

 * http-response-code

200

HTTP 响应头在许多应用程序中都很有用; 用于获取我的网站主页的头信息是:

* headers

((:SERVER . "nginx/1.1.19")
 (:DATE . "Fri, 05 Jul 2013 15:18:27 GMT")
 (:CONTENT-TYPE . "text/html; charset=utf-8")
 (:TRANSFER-ENCODING . "chunked")
 (:CONNECTION . "close")
 (:SET-COOKIE
  .
  "ring-session=cec5d7ba-e4da-4bf4-b05e-aff670e0dd10;Path=/"))

我们将在本书后面的几个示例中使用 Drakma. 在下一节中, 我们将使用 Hunchentoot 编写一个 web 应用程序, 并使用 Drakma 客户端对其进行测试.

Edi Weitz 的 Hunchentoot 项目²⁶ 是一个用于编写 Web 应用程序和 Web 服务的灵活库. 在本节中, 我们还将使用 Edi 的 CL-WHO 库从 Lisp 代码生成 HTML. 在本节的示例代码中, 第一次快速加载 Hunchentoot 时, 它将被安装:

(ql:quickload "hunchentoot")

在本节的 Hunchentoot 示例中, 我将只使用 easy handler 框架²⁷. 在你试验了本节中的示例后, 我将让你阅读有关使用自定义 acceptors²⁸ 的文档. 以下代码适用于 SBCL 的多线程安装和单线程安装 (例如, OS X 上 SBCL 的某些默认安装):

(ql:quickload :hunchentoot)
(ql:quickload :cl-who)

(in-package :cl-user)
(defpackage hdemo
  (:use :cl
   :cl-who
        :hunchentoot))
(in-package :hdemo)

(defvar *h * (make-instance 'easy-acceptor :port 3000))

;; define a handler with the arbitrary name my-greetings:

(define-easy-handler (my-greetings :uri "/hello") (name)
  (setf (hunchentoot:content-type*) "text/html")
  (with-html-output-to-string (*standard-output * nil :prologue t)
    (:html
     (:head (:title "hunchentoot test"))
     (:body
      (:h1 "hunchentoot form demo")
      (:form
       :method :post
       (:input :type :text
               :name "name"
               :value name)
       (:input :type :submit :value "Submit your name"))
      (:p "Hello " (str name))))))

(hunchentoot:start *h*)

在第 5 行到第 9 行, 我们创建并使用了一个新包, 其中包括对在 Lisp 代码 (CL-WHO) 和 Hunchentoot 库中生成 HTML 的支持. 在第 11 行, 我们创建了一个 easy acceptor 的实例, 监听端口 3000, 它为提供 HTTP 服务提供了有用的默认行为. Hunchentoot 宏 define-easy-handler 用于在第 15 行到第 28 行定义一个 HTTP 请求处理程序, 并将其添加到 easy acceptor 实例中. 第一个参数, 本例中的 my-greetings, 是一个任意名称, 关键字 :uri 参数提供了一个 URL 模式, easy acceptor 服务器对象使用该模式将请求路由到此处理程序. 例如, 当你在你的计算机上运行此示例时, 此 URL 路由模式将处理如下请求:

http://localhost:3000/hello

在第 17 行到第 28 行, 我们使用 CL-WHO 库为网页生成 HTML. 你可能猜到了, :html 生成网页的外部 <html></html> 标签. 第 19 行将生成如下 HTML:

<head>
  <title>hunchentoot test</title>
</head>

第 22 行到第 27 行生成一个 HTML 输入表单, 第 28 行显示用户在输入字段中输入文本并单击提交按钮时生成的任何值. 注意 easy handler 定义中第 1 行参数 name 的定义. 如果未定义参数 name, 则将在第 28 行将 nil 值显示为空字符串. 你应该运行这个例子, 并在 web 浏览器中访问生成的网页, 输入文本, 提交等. 你也可以使用我们上一节看到的 Drakma 库来获取生成的页面 HTML. 以下是使用 Drakma 客户端库访问最后一个例子的代码片段:

* (drakma:http-request "http://127.0.0.1:3000/hello?name=Mark")

"Hello Mark"
200
((:CONTENT-LENGTH . "10")
 (:DATE . "Fri, 05 Jul 2013 15:57:22 GMT")
 (:SERVER . "Hunchentoot 1.2.18")
 (:CONNECTION . "Close")
 (:CONTENT-TYPE . "text/plain; charset=utf-8"))
#<PURI:URI http://127.0.0.1:3000/hello?name=Mark>
#<FLEXI-STREAMS:FLEXI-IO-STREAM {10095654A3}>
T
"OK"

我们将在下一节同时使用 Drackma 和 Hunchentoot.

构建现代分布式系统的一种合理方法是编写 REST Web 服务, 为客户端应用程序提供 JSON 数据. 这些客户端应用程序可能是用 Javascript 编写的富 Web 应用程序, 其他 Web 服务, 以及在智能手机上运行的应用程序, 它们从远程 Web 服务获取和保存数据. 我们将使用 cl-json Quicklisp 包将 Lisp 数据编码为表示 JSON 编码数据的字符串. 这里有一个快速示例:

* (ql:quickload :cl-json)
* (defvar y (list (list '(cat . "the cat ran") '(dog . 101)) 1 2 3 4 5))

Y
* y

(((CAT . "the cat ran") (DOG . 101)) 1 2 3 4 5)
* (json:encode-json-to-string y)
"[{\"cat\":\"the cat ran\",\"dog\":101},1,2,3,4,5]"

以下列表显示了文件 src/web-hunchentoot-json.lisp 的内容:

(ql:quickload :hunchentoot)
(ql:quickload :cl-json)

(defvar *h * (make-instance 'hunchentoot:easy-acceptor :port 3000))

;; define a handler with the name animal:

(hunchentoot:define-easy-handler (animal :uri "/animal") (name)
  (print name)
  (setf (hunchentoot:content-type*) "text/plain")
  (cond
    ((string-equal name "cat")
     (json:encode-json-to-string
      (list
       (list
        '(average_weight . 10)
        '(friendly . nil))
       "A cat can live indoors or outdoors.")))
    ((string-equal name "dog")
     (json:encode-json-to-string
      (list
       (list
        '(average_weight . 40)
        '(friendly . t))
       "A dog is a loyal creature, much valued by humans.")))
    (t
     (json:encode-json-to-string
      (list
       ()
       "unknown type of animal")))))

(hunchentoot:start *h*)

这个例子与上一节的 Web 应用程序例子非常相似. 不同之处在于此应用程序不打算在网页上查看, 因为它返回 JSON 数据作为 HTTP 响应. 第 8 行的 easy handler 定义指定了一个处理程序参数 name. 在第 12 行和 19 行, 我们检查参数 name 的值是否为 “cat” 或 “dog”, 如果是, 我们返回这些动物的相应 JSON 示例数据. 如果没有匹配项, 则从第 26 行开始的默认 cond 子句返回一个警告字符串作为 JSON 编码的字符串. 在运行此测试服务时, 在一个 repl 中, 你可以在另一个 repl 中使用 Drakma 库来测试它 (下一个列表中未显示所有输出):

* (ql:quickload :drakma)
* (drakma:http-request "http://127.0.0.1:3000/animal?name=dog")

"[{\"average_weight\":40,
\"friendly\":true},
\"A dog is a loyal creature, much valued by humans.\"]"
200
* (drakma:http-request "http://127.0.0.1:3000/animal?name=cat")

"[{\"average_weight\":10,
\"friendly\":null},
\"A cat can live indoors or outdoors.\"]"
200

你可以使用 cl-json 库将包含 JSON 数据的字符串解码为 Lisp 数据:

* (ql:quickload :cl-json)
To load "cl-json":
Load 1 ASDF system:
cl-json
                                        ; Loading "cl-json"
.
(:CL-JSON)
* (cl-json:decode-json-from-string
   (drakma:http-request "http://127.0.0.1:3000/animal?name=dog"))

(((:AVERAGE--WEIGHT . 40) (:FRIENDLY . T))
 "A dog is a loyal creature, much valued by humans.")

对于我的大部分工作, REST Web 服务是 “只读” 的, 意思是客户端不修改服务器上的状态. 然而, 有些用例客户端应用程序可能想要这样做; 例如, 让客户端向上一个例子中添加新的动物.

(defparameter *animal-hash * (make-hash-table))

;; handle HTTP POST requests:
(hunchentoot:define-easy-handler (some-handler :uri "/add") (json-data)
  (setf (hunchentoot:content-type*) "text/plain")
  (let* ((data-string (hunchentoot:raw-post-data :force-text t))
         (data (cl-json:decode-json-from-string json-data))
         ;; assume that the name of the animal is a hashed value:
         (animal-name (gethash "name" data)))
    (setf (gethash animal-name *animal-hash*) data))
  "OK")

在第 4 行, 我们定义了一个带有处理程序参数 json-data 的附加 easy handler. 这个数据假定是一个编码 JSON 数据的字符串, 在第 6 行和第 7 行被解码为 Lisp 数据. 我们将数据保存到全局变量 animal-hash. 在这个例子中, 我们将客户端发送的数据存储在一个内存中的哈希表中. 在实际应用程序中, 新数据可能会存储在数据库中.

你已经学习了编写 Web 服务和编写客户端使用 Web 服务的基础知识. 稍后, 我们将通过编写 Common Lisp 客户端来使用用 Python 编写的 Web 服务: 我们将包装重新训练的深度学习模型并从 Common Lisp 访问它们.

如果你还没有 Azure 帐户, 则需要设置一个. 我经常使用 Bing 搜索 API 进行研究, 但我每月花费从未超过一美元左右, 通常我根本收不到账单. 对于个人使用来说, 这是一项非常便宜的服务. 你首先访问网页 https://azure.microsoft.com/en-us/try/cognitive-services/%5Bfn:33%5D 并注册一个访问密钥. 搜索 API 的注册目前在此网页表单的第四个选项卡中. 当你导航到搜索 API 选项卡时, 选择 Bing 搜索 API v7 选项. 你将获得一个 API 密钥, 你需要将其存储在一个环境变量中, 你很快就会需要它:

export BING_SEARCH_V7_SUBSCRIPTION_KEY=1e97834341d2291191c772b7371ad5b7

那不是我真正的订阅密钥! 你还需要将 Bing 搜索 API 设置为环境变量:

export BING_SEARCH_V7_ENDPOINT=https://api.cognitive.microsoft.com/bing/v7.0/search

我通常更喜欢使用在单独进程中运行的 curl 命令, 而不是使用纯 Common Lisp HTTP 客户端库. curl 实用程序处理所有可能的身份验证模式, 处理头信息, 多种格式的响应数据等. 我们将 curl 的输出捕获到一个字符串中, 然后由 JSON 库处理该字符串. 访问 Bing 搜索 API 只需要很少的 Common Lisp 代码. 函数 websearch 进行通用的 Web 搜索查询. 函数 get-wikidata-uri 通过在查询中添加 “site:wikidata.org” 并仅返回原始搜索词的 WikiData URI 来使用 websearch 函数. 我们稍后会看到几个例子. 我将列出整个库并附带注释:

(in-package #:bing)

(defun get-wikidata-uri (query)
  (let ((sr (websearch (concatenate 'string "site:wikidata.org " query))))
    (cadar sr)))

(defun websearch (query)
  (let* ((key (uiop:getenv "BING_SEARCH_V7_SUBSCRIPTION_KEY"))
         (endpoint (uiop:getenv "BING_SEARCH_V7_ENDPOINT"))
         (command
           (concatenate
            'string
            "curl -v -X GET \"" endpoint "?q="
            (drakma:url-encode query :utf-8)
            "&mkt=en-US&limit=4\""
            " -H \"Ocp-Apim-Subscription-Key: " key "\""))
         (response
           (uiop:run-program command :output :string)))
    (with-input-from-string
        (s response)
      (let* ((json-as-list (json:decode-json s))
             (values (cdadr (cddr (nth 2 json-as-list)))))
        (mapcar #'(lambda (x)
                    (let ((name (assoc :name x))
                          (display-uri (assoc :display-url x))
                          (snippet (assoc :snippet x)))
                      (list (cdr name) (cdr display-uri) (cdr snippet))))
                values)))))

我们在第 8-9 行获取 Bing 访问密钥和搜索 API 端点. 第 10-16 行创建对 curl* 命令行实用程序的完整调用. 我们生成一个进程来运行 **curl 并将字符串输出捕获到第 17-18 行的变量 response 中. 你可能想添加一些打印语句来查看变量 command 和 response 的典型值. 响应数据是编码在字符串中的 JSON 数据, 第 19-28 行使用简单的代码解析出我们想要的值. 以下 repl 列表显示了此库的用法:

$ sbcl
This is SBCL 2.0.2, an implementation of ANSI Common Lisp.
 * (ql:quickload "bing")
To load "bing":
Load 1 ASDF system:
bing
; Loading "bing"
..............
("bing")
 * (bing:get-wikidata-uri "Sedona Arizona")
"https://www.wikidata.org/wiki/Q80041"
 * (bing:websearch "Berlin")
(("Berlin - Wikipedia" "https://en.wikipedia.org/wiki/Berlin"
"Berlin (/ brln /; German: [blin] (listen)) is the capital and largest cit\
y of Germany by both area and population. Its 3,769,495 (2019) inhabitants make it t\
he most populous city proper of the European Union. The city is one of Germany's 16 \
federal states.")
("THE 15 BEST Things to Do in Berlin - 2020 (with Photos ..."
"https://www.tripadvisor.com/Attractions-g187323-Activities-Berlin.html"
"Book your tickets online for the top things to do in Berlin, Germany on Tripadvis\
or: See 571,599 traveler reviews and photos of Berlin tourist attractions. Find what\
to do today, this weekend, or in August. We have reviews of the best places to see \
in Berlin. Visit top-rated & must-see attractions.")
("Berlin - Official Website of the City of Berlin, Capital ..."
"https://www.berlin.de/en"
"Official Website of Berlin: Information about the Administration, Events, Culture\
, Tourism, Hotels and Hotel Booking, Entertainment, Tickets, Public Transport, Polit\
ical System, Local Authorities and Business in Berlin.")
("Berlin | History, Map, Population, Attractions, & Facts ..."
"https://www.britannica.com/place/Berlin"
"Berlin is situated about 112 miles (180 km) south of the Baltic Sea, 118 miles (1\
90 km) north of the Czech-German border, 110 miles (177 km) east of the former inner\
-German border, and 55 miles (89 km) west of Poland. It lies in the wide glacial val\
ley of the Spree River, which runs through the centre of the city.")
("Berlin travel | Germany - Lonely Planet"
"https://www.lonelyplanet.com/germany/berlin"
"Welcome to Berlin Berlin's combo of glamour and grit is bound to mesmerise all th\
ose keen to explore its vibrant culture, cutting-edge architecture, fabulous food, i\
ntense parties and tangible history.")
("Berlin 2020: Best of Berlin, Germany Tourism - Tripadvisor"
"https://www.tripadvisor.com/Tourism-g187323"
"Berlin is an edgy city, from its fashion to its architecture to its charged polit\
ical history. The Berlin Wall is a sobering reminder of the hyper-charged postwar at\
mosphere, and yet the graffiti art that now covers its remnants has become symbolic \
of social progress.")
("Berlin 2020: Best of Berlin, OH Tourism - Tripadvisor"
"https://www.tripadvisor.com/Tourism-g50087-Berlin_Ohio-Vacations.html"
"Berlin Tourism: Tripadvisor has 11,137 reviews of Berlin Hotels, Attractions, and\
Restaurants making it your best Berlin resource.")
("Berlin (band) - Wikipedia" "https://en.wikipedia.org/wiki/Berlin_(band)"
"Berlin is the alias for vocalist Terri Nunn, as well as the American new wave ban\
d she fronts, having been originally formed in Orange County, California. The band g\
ained mainstream-commercial success with singles including \" Sex (I'm A...) \", \" \
No More Words \" and the chart-topping \" Take My Breath Away \" from the 1986 film \
Top Gun.")
("Berlin's official travel website - visitBerlin.de"
"https://www.visitberlin.de/en"
"Berlin's way to a metropolis 100 Years of Greater Berlin In 1920, modern Berlin w\
as born at one fell swoop. 8 cities, 59 rural communities and 27 manor districts uni\
te to form \"Greater Berlin\""))
*

多年来, 我一直使用 Bing 搜索 API. 它们是我应用程序构建工具包的标准组成部分.

你可以查看 Azure 站点上广泛的 Congitive Services³⁰. 可用的 API 包括: 语言检测, 语音识别, 用于对象识别的视觉库, Web 搜索以及数据中的异常检测. 除了使用自动化的 Web 抓取来获取我的个人研究数据外, 我经常使用自动化的 Web 搜索. 我发现微软的 Azure Bing 搜索 API 是最方便使用的, 我喜欢为我使用的服务付费.

你学习了访问关系数据库的基础知识. 当我设计用于处理数据的新系统时, 我喜欢将我的 Common Lisp 代码视为纯函数式的: 我的 Lisp 函数接受它们不修改的参数并返回结果. 我喜欢避免副作用, 即改变全局状态. 当我确实需要处理可变状态 (或数据) 时, 我更倾向于将可变状态存储在外部数据库中. 当我使用 Haskell 函数式编程语言时, 我也使用同样的方法.

以下关于 MongoDB 的讨论仅基于我的个人经验, 因此我不会涵盖所有用例. 我曾将 MongoDB 用于:

• 小型 MongoDB 节点集群, 用于分析社交媒体数据, 主要是文本挖掘和情感分析. 在所有情况下, 对于每个应用程序, 我都使用一个写主节点运行 MongoDB (即, 我向这个节点写入数据但不用于读取) 和多个只读从节点. 每个从节点将与通常执行单个分析任务的服务器在同一台服务器上运行.
• 用于网络广告的多个非常大的独立集群. 面临的问题包括试图在数据中心之间保持某种程度的一致性. 在每个数据中心内都使用了副本集.
• 运行单个 MongoDB 节点实例, 用于低容量数据收集和分析.

MongoDB 的优势之一是它非常 “开发者友好”, 因为它支持即席文档模式和交互式查询. 我提到 MongoDB 允许你选择一致性 vs. 可用性 vs. 效率. 当你执行 MongoDB 写入时, 你可以指定构成 “成功写入” 的一些粒度, 要求在客户端收到写入成功的确认之前, 在特定数量的节点上执行写入. 这个要求会给每个写操作增加开销, 如果某些节点不可用, 则可能导致写入失败. MongoDB 在线文档³⁴ 非常好. 你不必为了体验以下 Common Lisp 和 MongoDB 示例而阅读它, 但如果你在体验了这些示例后发现 MongoDB 很适合你的需求, 那么你应该阅读文档. 我通常自己安装 MongoDB, 但有时使用托管服务很方便. 有几个备受好评的服务, 我使用过 MongoHQ³⁵. 目前没有官方的 Common Lisp 支持访问 MongoDB, 但 Alfons Haffmans 的 cl-mongo³⁶ 项目是一个有用的项目, 它将允许我们编写 Common Lisp 客户端应用程序并访问 MongoDB 的大部分功能. 文件 src/mongo_news.lisp 包含接下来三个会话中使用的示例代码.

Lucene 项目是使用最广泛的 Apache Foundation 项目之一. Lucene 是一个用于预处理和索引文本以及搜索文本的灵活库. 我个人在很多项目中使用过 Lucene, 很难数清有多少个. Apache Solr 项目³⁹ 为 Lucene 文本索引器和搜索引擎添加了网络接口. Solr 还为 Lucene 添加了其他实用功能:

• Lucene 是一个嵌入到你的程序中的库, 而 Solr 是一个完整的系统.
• Solr 为预处理和索引文本提供了良好的默认设置, 还为管理结构化数据提供了丰富的支持.
• 提供使用 HTTP 和 REST 的 XML 和 JSON API.
• 支持分面搜索, 地理空间搜索, 并提供用于在搜索结果的周围文本中高亮显示搜索词的实用程序.
• 如果你的系统用户数量增长到非常大, Solr 支持通过复制进行扩展.

我希望你会发现以下各节中的 Common Lisp 示例 Solr 客户端代码有助于你将 Solr 作为使用 Common Lisp 编写的大型系统的一部分.

Solr REST 接口文档⁴¹ 记录了如何使用 HTTP GET 请求执行搜索. 我们需要做的就是在 Common Lisp 中实现这一点, 你会发现这很容易. 假设你正在运行 Solr 并且示例数据已加载, 我们可以尝试搜索包含例如 “British” 一词的文档, 使用 URL http://localhost:8983/solr/select?q=British%5Bfn:48%5D. 这是一个 REST 请求 URL, 你可以使用 curl 或 wget 等实用程序来获取 XML 数据. 我在 web 浏览器中获取了数据, 如以下 Firefox web 浏览器屏幕截图所示 (我喜欢 Firefox 格式化和显示 XML 数据的方式):

返回的搜索结果中的属性需要一些解释. 我们索引了几个示例 XML 数据文件, 其中一个包含我们刚刚看到的作为搜索结果的以下 XML 元素:

<doc>
  <field name="id">GBP</field>
  <field name="name">One British Pound</field>
  <field name="manu">U.K.</field>
  <field name="manu_id_s">uk</field>
  <field name="cat">currency</field>
  <field name="features">Coins and notes</field>
  <field name="price_c">1,GBP</field>
  <field name="inStock">true</field>
</doc>

因此, 搜索结果具有与添加到 Solr 搜索索引的结构化 XML 数据相同的属性. Solr 索引结构化数据的能力仅仅是索引纯文本的超集. 例如, 如果我们正在索引新闻报道, 那么示例输入数据可能如下所示:

<doc>
  <field name="id">new_story_0001</field>
  <field name="title">Fishing Season Opens</field>
  <field name="text">Fishing season opens on Friday in Oak Creek.</field>
</doc>

对于这个例子, 返回此文档作为结果的搜索结果将返回属性 id, title 和 text, 以及这三个属性的值. 默认情况下, Solr Web 服务返回 XML 数据, 如上一个屏幕截图所示. 对于我们的示例, 我更喜欢使用 JSON, 所以我们将始终向所有 REST 调用添加一个请求参数 wt=json. 以下屏幕截图显示了以 JSON 序列化格式而不是 XML 格式返回的相同数据, 使用 Chrome Web 浏览器 (我喜欢 Chrome 使用 JSONView Chrome 浏览器扩展程序格式化和显示 JSON 数据的方式):

你可以稍后阅读完整的 JSON REST Solr 文档, 但对于我们在此处的使用, 我们将使用以下搜索模式:

• http://localhost:8983/solr/select?q=British+One&wt=json - 搜索包含单词 “British” 或 “one” 中任一词的文档. 请注意, 在 URI 中, “+” 字符用于编码空格字符. 如果你想要一个 “+” 字符, 你需要用 “%2B” 对其进行编码, 空格字符编码为 “%20”. 默认的 Solr 搜索选项是搜索词的 OR, 这与例如 Google 搜索不同.
• http://localhost:8983/solr/select?q=British+AND+one&wt=json - 搜索同时包含单词 “British” 和 “one” 的文档. 纯文本中的搜索词是 “British AND one”.

Solr 有许多我们在此处未使用的有用功能, 例如支持分面搜索 (在先前的搜索结果中向下钻取), 地理位置搜索以及按属性查找索引文档. 在我向你展示的示例中, 所有文本字段都被索引, 但 Solr 可选地允许你精细控制索引, 拼写校正, 词干提取等. Solr 是一个用于存储, 索引和搜索数据的非常有能力的工具. 我见过 Solr 在项目中有效地用作关系数据库或其他 NoSQL 数据存储 (如 CouchDB 或 MongoDB) 的替代品. 修改或删除 Solr 中数据的开销较高, 因此对于涉及频繁修改存储数据的应用程序, Solr 可能不是一个好的选择.

使用比 Common Lisp 更方便的语言来访问 MongoDB. 说实话, 我最喜欢的是 Ruby 和 Clojure. 话虽如此, 对于 Common Lisp 的优势具有吸引力的应用程序来说, 了解你的 Common Lisp 应用程序可以很好地与 MongoDB 配合使用是件好事. 我是一个多语言程序员: 我喜欢为任何特定的工作使用最好的编程语言. 当我们设计和构建使用多种编程语言的系统时, 有几种共享数据的选项:

• 使用外部函数接口从一个进程内部调用另一种语言.
• 使用服务架构并使用 REST 或 SOAP 发送请求.
• 使用共享数据存储, 如关系数据库, MongoDB, CouchDB 和 Solr.

希望本章和上一章能为你提供最后一种选项所需的大部分内容.

我将 NLP 示例代码重新打包成一个长文件. 代码过去分散在 18 个源文件中. 应从 src/kbnlp 目录加载代码:

% loving-common-lisp git:(master) > cd src/kbnlp
% src/kbnlp git:(master) > sbcl
 * (ql:quickload "kbnlp")

"Startng to load data...."
"....done loading data."
*

这也加载了 src/fasttag 和 src/categorize_summarize 中的项目. 不幸的是, 使用 SBCL 加载所需的语言数据大约需要一分钟, 所以我建议创建一个可以重新加载的 Lisp 镜像, 以避免加载数据所需的时间:

 * (sb-ext:save-lisp-and-die "nlp-image" :purify t)
[undoing binding stack and other enclosing state... done]
[saving current Lisp image into nlp-image:
writing 5280 bytes from the read-only space at 0x0x20000000
writing 3088 bytes from the static space at 0x0x20100000
writing 80052224 bytes from the dynamic space at 0x0x1000000000
done]
% src git:(master) > ls -lh nlp-image
-rw-r--r-- 1 markw staff 76M Jul 13 12:49 nlp-image

在这个 repl 列表的第 1 行, 我使用 SBCL 内置函数 save-lisp-and-die 来创建 Lisp 镜像文件. 每当设置你的工作环境需要一段时间时, 使用 save-lisp-and-die 是一个很好的技巧. 为下次在 Common Lisp 项目上工作时保存 Lisp 镜像让人想起在 Smalltalk 中工作, 在 Smalltalk 中你的工作保存在会话之间的镜像文件中. 注意: 我经常使用 Clozure-CL (CCL) 而不是 SBCL 来开发我的 NLP 库, 因为 CCL 加载我的数据文件比 CCL 快得多. 你现在可以使用你刚刚创建的 Lisp 镜像启动 SBCL, 其中预加载了 NLP 库和数据:

% src git:(master) > sbcl --core nlp-image
 * (in-package :kbnlp)

#<PACKAGE "KBNLP">
 * (defvar
*x*
(make-text-object
"President Bob Smith talked to Congress about the economy and taxes"))

*X*

 * *X*

#S(TEXT
:URL ""
:TITLE ""
:SUMMARY "<no summary>"
:CATEGORY-TAGS (("news_politics.txt" 0.01648)
("news_economy.txt" 0.01601))
:KEY-WORDS NIL
:KEY-PHRASES NIL
:HUMAN-NAMES ("President Bob Smith")
:PLACE-NAMES NIL
:TEXT #("President" "Bob" "Smith" "talked" "to" "Congress" "about" "the"
"economy" "and" "taxes")
:TAGS #("NNP" "NNP" "NNP" "VBD" "TO" "NNP" "IN" "DT" "NN" "CC" "NNS")
:STEMS #("presid" "bob" "smith" "talk" "to" "congress" "about" "the"
"economi" "and" "tax"))
*

在文件 src/knowledgebooks_nlp.lisp 的末尾注释中有一些测试代码, 它处理更多的文本, 以便也生成摘要; 如果你将测试代码加载到你的 repl 中, 你会看到一些输出:

(:SUMMARY
 "Often those amendments are an effort to change government policy
by adding or subtracting money for carrying it out. The initial
surge in foreclosures in 2007 and 2008 was tied to subprime
mortgages issued during the housing boom to people with shaky
credit. 2 trillion in annual appropriations bills for funding
most government programs — usually low profile legislation that
typically dominates the work of the House in June and July.
Bill Clinton said that banking in Europe is a good business.
These days homeowners who got fixed rate prime mortgages because
they had good credit cannot make their payments because they are
out of work. The question is whether or not the US dollar remains
the world s reserve currency if not the US economy will face
a depression."
 :CATEGORY-TAGS (("news_politics.txt" 0.38268)
                 ("news_economy.txt" 0.31182)
                 ("news_war.txt" 0.20174))
 :HUMAN-NAMES ("President Bill Clinton")
 :PLACE-NAMES ("Florida"))

顶层函数 make-text-object 接受一个必需的参数, 该参数可以是一个包含文本的字符串, 也可以是一个字符串数组, 其中每个字符串是一个单词或标点符号. 函数 make-text-object 有两个可选的关键字参数: 找到文本的 URL 和标题.

(defun make-text-object (words &key (url "") (title ""))
  (if (typep words 'string) (setq words (words-from-string words)))
  (let* ((txt-obj (make-text :text words :url url :title title)))
    (setf (text-tags txt-obj) (part-of-speech-tagger words))
    (setf (text-stems txt-obj) (stem-text txt-obj))
    ;; note: we must find human and place names before calling
    ;; pronoun-resolution:
    (let ((names-places (find-names-places txt-obj)))
      (setf (text-human-names txt-obj) (car names-places))
      (setf (text-place-names txt-obj) (cadr names-places)))
    (setf (text-category-tags txt-obj)
          (mapcar
           #'(lambda (x)
               (list
                (car x)
                (/ (cadr x) 1000000.0)))
           (get-word-list-category (text-text txt-obj))))
    (setf (text-summary txt-obj) (summarize txt-obj))
    txt-obj))

在第 2 行, 我们检查此函数是否使用包含文本的字符串调用, 在这种情况下, 函数 words-from-string 用于将文本分词为字符串标记数组. 第 2 行定义了局部变量 txt-obj, 其值为一个新的文本对象, 只有三个 slot (属性) 被定义: text, url 和 title. 第 4 行使用函数 part-of-speech-tagger 将 slot text-tags 设置为词性标记. 我们在第 8 行使用函数 find-names-places 来获取人名和地名, 并将这些值存储在文本对象中. 在第 11 行到 17 行, 我们使用函数 get-word-list-category 来设置文本对象中的类别. 在第 18 行, 我们类似地使用函数 summarize 来计算文本的摘要并将其存储在文本对象中. 我们将在本章的其余部分讨论这些 NLP 辅助函数. 函数 make-text-object 返回一个定义如下的结构体:

(defstruct text
  url
  title
  summary
  category-tags
  key-words
  key-phrases
  human-names
  place-names
  text
  tags
  stems)

这个标注器是我 FastTag 开源项目的 Common Lisp 实现. 我基于 Eric Brill 的博士论文 (1995) 创建了这个项目. 他使用机器学习在带标注的文本上学习标注规则. 我使用了他生成的最常用的标注规则子集, 当他测试他的标注器时. 我用 Lisp (以及 Ruby, Java 和 Pascal) 手动编码了他的规则. 我的标注器准确性较低, 但速度很快 - 因此得名 FastTag. 如果你只需要词性标注 (而不需要上一节使用的摘要, 分类和顶层 API), 你可以加载:

(ql:quickload "fasttag")

你可以在函数 part-of-speech-tagger 中找到标注器的实现. 我们已经在上一节看到了标注器的示例输出:

:TEXT #("President" "Bob" "Smith" "talked" "to" "Congress" "about" "the"
        "economy" "and" "taxes")
:TAGS #("NNP" "NNP" "NNP" "VBD" "TO" "NNP" "IN" "DT" "NN" "CC" "NNS")

下表显示了标记的含义和一些示例词:

函数 part-of-speech-tagger 遍历所有输入词, 并初步分配词典中指定的最可能的词性. 然后应用 Brill 规则的一个子集. 规则作用于当前词和前一个词. 作为一个规则的 Common Lisp 实现示例, 查找被标记为普通名词但以 “ing” 结尾的词, 因此它们应该是动名词 (动词形式):

                                        ; rule 8: convert a common noun to a present
                                        ; participle verb (i.e., a gerand)
(if (equal (search "NN" r) 0)
    (let ((i (search "ing" w :from-end t)))
      (if (equal i (- (length w) 3))
          (setq r "VBG"))))

你可以在文件 src/linguistic_data/FastTagData.lisp 中找到词典数据. 这个文件是 Lisp 代码而不是纯数据 (回想起来, 纯数据会更好, 因为加载速度会更快), 看起来像这样:

(defvar lex-hash (make-hash-table :test #'equal :size 110000))
(setf (gethash "shakeup" lex-hash) (list "NN"))
(setf (gethash "Laurance" lex-hash) (list "NNP"))
(setf (gethash "expressing" lex-hash) (list "VBG"))
(setf (gethash "citybred" lex-hash) (list "JJ"))
(setf (gethash "negative" lex-hash) (list "JJ" "NN"))
(setf (gethash "investors" lex-hash) (list "NNS" "NNPS"))
(setf (gethash "founding" lex-hash) (list "NN" "VBG" "JJ"))

我使用一个小的 Ruby 脚本从词典数据自动生成此文件. 注意, 单词可以有多个可能的词性. 单词最常见的词性是词典中的第一个条目.

对文本进行分类的代码相当简单, 使用了一种通常称为 “词袋” (bag of words) 的技术. 我收集了几个不同类别的样本文本, 对于每个类别 (如政治, 体育等), 我计算了单词对支持某个类别贡献的证据或权重. 例如, 单词 “president” 对于类别 “politics” 具有很强的权重, 但对于类别 “sports” 则没有. 原因在于单词 “president” 在关于政治的文章和书籍中频繁出现. 包含每个类别词权重的数据文件是 src/data/cat-data-tables.lisp. 你可以查看这个文件; 这是其中的一小部分: 如果你只需要分类而不需要本章开发的其他库, 你可以只加载这个库并在文件 categorize_summarize.lisp 底部的注释中运行示例:

({lang=”lisp”,linenos=off} (ql:quickload “categorize_summarize”) (defvar x “President Bill Clinton <<2 pages text no shown>> “) (defvar words1 (myutils:words-from-string x)) (print words1) (setq cats1 (categorize_summarize:categorize words1)) (print cats1) (defvar sum1 (categorize_summarize:summarize words1 cats1)) (print sum1)

让我们看一下实现, 从为存储每个类别或主题的词频数据创建哈希表开始:

;;; Starting topic: news_economy.txt

(setf *h * (make-hash-table :test #'equal :size 1000))

(setf (gethash "news" *h*) 3915)
(setf (gethash "debt" *h*) 3826)
(setf (gethash "money" *h*) 1809)
(setf (gethash "work" *h*) 1779)
(setf (gethash "business" *h*) 1631)
(setf (gethash "tax" *h*) 1572)
(setf (gethash "poverty" *h*) 1512)

这个文件是由一个简单的 Ruby 脚本 (未包含在本书的示例代码中) 创建的, 该脚本处理子目录列表, 每个类别一个子目录. 以下列表显示了函数 get-word-list-category 的实现, 该函数计算输入文本的类别标签:

(defun get-word-list-category (words)
  (let ((x nil)
        (ss nil)
        (cat-hash nil)
        (word nil)
        (len (length words))
        (num-categories (length categoryHashtables))
        (category-score-accumulation-array
          (make-array num-categories :initial-element 0)))

    (defun list-sort (list-to-sort)
      ;;(pprint list-to-sort)
      (sort list-to-sort
            #'(lambda (list-element-1 list-element-2)
                (> (cadr list-element-1) (cadr list-element-2)))))

    (do ((k 0 (+ k 1)))
        ((equal k len))
      (setf word (string-downcase (aref words k)))
      (do ((i 0 (+ i 1)))
          ((equal i num-categories))
        (setf cat-hash (nth i categoryHashtables))
        (setf x (gethash word cat-hash))
        (if x
            (setf
             (aref category-score-accumulation-array i)
             (+ x (aref category-score-accumulation-array i))))))
    (setf ss '())
    (do ((i 0 (+ i 1)))
        ((equal i num-categories))
      (if (> (aref category-score-accumulation-array i) 0.01)
          (setf
           ss
           (cons
            (list
             (nth i categoryNames)
             (round ( * (aref category-score-accumulation-array i) 10)))
            ss))))
    (setf ss (list-sort ss))
    (let ((cutoff (/ (cadar ss) 2))
          (results-array '()))
      (dolist (hit ss)
        (if (> (cadr hit) cutoff)
            (setf results-array (cons hit results-array))))
      (reverse results-array))))

需要注意的一点是, 在这个列表的第 11 行到 15 行, 我定义了一个嵌套函数 list-sort, 它接受一个子列表的列表, 并根据子列表中的第二个值 (是一个数字) 对子列表进行排序. 我经常在 “内部” 函数仅在 “外部” 函数中使用时嵌套函数. 第 2 行到第 9 行定义了外部函数中使用的几个局部变量. 全局变量 categoryHashtables 是一个词权重得分哈希表的列表, 每个类别一个. 局部变量 category-score-accumulation-array 初始化为一个在每个元素中包含数字零的数组, 并将用于 “记录” 每个类别的得分. 得分最高的类别将是外部函数的返回值. 第 17 行到 27 行是两个嵌套循环. 外部循环遍历输入词数组中的每个词. 内部循环遍历类别数量. 逻辑很简单: 对于每个词, 检查它在每个类别的词权重得分哈希表中是否有权重得分, 如果有, 则增加匹配类别的得分. 局部变量 ss 在第 28 行设置为空列表, 在第 29 行到 38 行的循环中, 我复制了得分超过阈值 0.01 的类别及其得分. 我们在第 39 行使用内部函数对 ss 中的列表进行排序, 然后返回得分大于中位数类别得分的类别.

检测人名和地名的代码位于 src/kbnlp 中定义的包的顶层 API 代码中. 使用以下命令加载此包:

(ql:quickload "kbnlp")
(kbnlp:make-text-object "President Bill Clinton ran for president of the USA")

支持识别文本中人名和地名的函数位于 Common Lisp 包 kb nlp:: 中:

• find-names (words tags exclusion-list) – words 是文本中单词的字符串数组, tags 是词性标签 (来自 FastTag), exclusion-list 是你想要排除在人名部分之外的单词数组. 找到的名称列表记录了名称在单词数组中的起始和结束索引.
• not-in-list-find-names-helper (a-list start end) – 如果找到的名称尚未添加到用于保存文本中人名的列表中, 则返回 true.
• find-places (words exclusion-list) – 这与 find-names 类似, 但它查找地名. 找到的地名列表记录了地名在单词数组中的起始和结束索引.
• not-in-list-find-places-helper (a-list start end) – 如果找到的地名尚未添加到用于保存文本中地名的列表中, 则返回 true.
• build-list-find-name-helper (v indices) – 这将起始/结束单词索引列表转换为包含名称的字符串.
• find-names-places (txt-object) – 这是你的应用程序将调用的顶层函数. 它接受一个 defstruct text 对象作为输入, 并通过添加它在文本中找到的人名和地名来修改 defstruct text. 你在本章前面看到了这个例子.

我让你阅读代码, 只列出顶层函数:

(defun find-names-places (txt-object)
  (let* ((words (text-text txt-object))
         (tags (text-tags txt-object))
         (place-indices (find-places words nil))
         (name-indices (find-names words tags place-indices))
         (name-list
           (remove-duplicates
            (build-list-find-name-helper words name-indices) :test #'equal))
         (place-list
           (remove-duplicates
            (build-list-find-name-helper words place-indices) :test #'equal)))
    (let ((ret '()))
      (dolist (x name-list)
        (if (search " " x)
            (setq ret (cons x ret))))
      (setq name-list (reverse ret)))
    (list
     (remove-shorter-names name-list)
     (remove-shorter-names place-list))))

在第 2 行, 我们使用 slot 访问器 text-text 来获取文本对象的单词标记数组. 在第 3, 4 和 5 行, 我们对词性标签, 单词数组中的地名索引以及单词数组中的人名索引执行相同的操作. 在第 6 行到 11 行, 我们两次使用函数 build-list-find-name-helper 来根据单词数组中的索引构造人名和地名字符串. 我们还使用 Common Lisp 内置函数 remove-duplicates 来去除重复的名称. 在第 12 行到 16 行, 我们丢弃任何不包含空格的人名, 也就是说, 只保留至少包含两个单词标记的名称. 第 17 行到 19 行定义了函数的返回值: 使用函数 remove-shorter-names 两次来移除列表中相同名称的较短版本的人名和地名的列表的列表. 例如, 如果我们有两个名字 “Mr. John Smith” 和 “John Smith”, 那么我们会想从返回列表中删除较短的名字 “John Smith”.

用于文本摘要的代码位于目录 src/categorize_summarize 中, 可以使用以下命令加载:

({lang=”lisp”,linenos=off} (ql:quickload “categorize_summarize”)

摘要代码依赖于我们之前看到的分类代码. 文本摘要有很多应用. 例如, 如果你正在编写一个文档管理系统, 你肯定会想使用像 Solr 这样的工具来提供搜索功能. Solr 会在索引文档字段值的片段中返回高亮匹配项. 使用摘要, 当你向 Solr (或其他) 搜索索引添加文档时, 你可以创建一个包含文档摘要的新的未索引字段. 然后, 当你系统的用户看到搜索结果时, 他们将看到他们习惯于在 Google, Bing 或 DuckDuckGo 搜索结果中看到的高亮匹配片段类型, 并且他们将看到文档的摘要. 听起来不错? 要解决的问题是获取好的文本摘要, 并且使用的技术可能需要根据你试图摘要的文本类型进行修改. 摘要有两种基本技术: 一种是几乎每个人都使用的实用方法, 另一个是我认为到目前为止几乎没有实际应用的研究领域. 这些技术是句子提取和将文本抽象成更短的形式 (通过组合和改变句子). 我们将使用句子提取. 我们如何选择从文本中提取哪些句子作为摘要? 我在 1999 年的想法很简单. بما أنني عادةً ما أقوم بتصنيف النص في خط أنابيب معالجة البرمجة اللغوية العصبية الخاص بي ، فلماذا لا أستخدم الكلمات التي أعطت أقوى دليل لتصنيف النص ، والعثور على الجمل التي تحتوي على أكبر عدد من هذه الكلمات. كمثال ملموس ، إذا قمت بتصنيف النص على أنه "سياسة" ، فأنا أحدد الكلمات في النص مثل "رئيس" ، "كونغرس" ، "انتخاب" ، وما إلى ذلك التي أدت إلى تصنيف "السياسة" ، وأجد الجمل التي تحتوي على أكبر تجمعات لهذه الكلمات. 摘要是你可能需要根据你的应用程序进行试验的东西. 我的旧摘要代码包含了很多特殊情况, 注释掉的代码块等. 我试图尽可能缩短和简化我旧的摘要代码以用于本书的目的, 同时仍然保持有用的功能. 用于摘要文本的函数相当简单, 因为当顶层 NLP 库函数 make-text-object 调用函数 summarize 时, 输入文本已经被分类了. 回想一下本章开头的例子, 类别数据如下所示:

:CATEGORY-TAGS (("news_politics.txt" 0.38268)
                ("news_economy.txt" 0.31182)
                ("news_war.txt" 0.20174))

此类别数据保存在以下列表第 4 行的局部变量 cats 中.

(defun summarize (txt-obj)
  (let* ((words (text-text txt-obj))
         (num-words (length words))
         (cats (text-category-tags txt-obj))
         (sentence-count 0)
         best-sentences sentence (score 0))
    ;; loop over sentences:
    (dotimes (i num-words)
      (let ((word (svref words i)))
        (dolist (cat cats)
          (let* ((hash (gethash (car cat) categoryToHash))
                 (value (gethash word hash)))
            (if value
                (setq score (+ score ( * 0.01 value (cadr cat)))))))
        (push word sentence)
        (if (or (equal word ".") (equal word "!") (equal word ";"))
            (let ()
              (setq sentence (reverse sentence))
              (setq score (/ score (1+ (length sentence))))
              (setq sentence-count (1+ sentence-count))
              (format t "~%~A : ~A~%" sentence score)
              ;; process this sentence:
              (if (and
                   (> score 0.4)
                   (> (length sentence) 4)
                   (< (length sentence) 30))
                  (progn
                    (setq sentence
                          (reduce
                           #'(lambda (x y) (concatenate 'string x " " y))
                           (coerce sentence 'list)))
                    (push (list sentence score) best-sentences)))
              (setf sentence nil score 0)))))
    (setf
     best-sentences
     (sort
      best-sentences
      #'(lambda (x y) (> (cadr x) (cadr y)))))
    (if best-sentences
        (replace-all
         (reduce #'(lambda (x y) (concatenate 'string x " " y))
                 (mapcar #'(lambda (x) (car x)) best-sentences))
         " ." ".")
        "<no summary>")))

第 8 行到 33 行的嵌套循环看起来有点复杂, 所以让我们逐步分析它. 我们的目标是为输入文本中的每个单词标记计算一个重要性得分, 然后选择一些包含高分单词的句子. 外部循环遍历输入文本中的单词标记. 对于每个单词标记, 我们遍历类别列表, 在每个类别哈希中查找当前单词, 并增加当前单词标记的 得分. 我们还会查找句子结束符并保存句子. 第 16 行到 32 行的代码有点复杂, 我在这里构建句子及其得分, 并将得分高于阈值 0.01 的句子存储在列表 best-sentences 中. 在两个嵌套循环之后, 在第 34 行到 44 行, 我们简单地按得分对句子进行排序, 并选择 “最佳” 句子作为摘要. 提取的句子不再保持其原始顺序, 这可能会产生奇怪的效果, 但我喜欢首先看到最相关的句子.

文本挖掘通常指在非结构化文本中查找数据. 我们在本章中已经介绍了几种文本挖掘技术:

• 命名实体识别 - 本章介绍的 NLP 库可识别人名和地名实体. 我将其留作练习, 供你扩展此库以处理公司和产品名称. 你可以从收集文件 src/kbnlp/linguistic_data/names/names.companies 和 src/kbnlp/data/names/names.products 中的公司和产品名称开始, 并扩展库代码.
• 文本分类 - 你可以通过添加更多支持类别的加权词/术语来提高分类的准确性. 如果你已经在你构建的系统中使用 Java, 我推荐 Apache OpenNLP 库, 它比我在我的 Common Lisp NLP 库中使用的更简单的 “词袋” 方法更准确. 如果你使用 Python, 那么我建议你也尝试 NLTK 库.
• 文本摘要.

在下一章中, 我将介绍另一个 “以数据为中心” 的主题: 在网络上执行信息收集. 你可能会发现能够使用 NLP 从非结构化文本创建结构化数据之间存在一些协同作用.

维基百科是一个巨大的信息来源. 你可能知道, 你可以下载所有维基百科数据的转储⁴³, 无论是否包含版本信息和评论. 当我想要快速访问整个维基百科英文文章集时, 我选择第二个选项, 只获取当前页面, 没有评论或版本信息. 这是当前维基百科文章的直接下载链接⁴⁴. 这个 GZIP 文件中没有评论或用户页面. 数据量并不像你想象的那么大, 压缩后只有大约 9 GB, 未压缩时大约 42 GB. 要加载并运行一个例子, 试试:

(ql:quickload "dbpedia")
(dbpedia:dbpedia-lookup "berlin")

维基百科是一个很好的手头资源, 但我将在本节向你展示如何访问维基百科的语义网版本, 即 DBPedia⁴⁵, 使用 DBPedia 查询服务. 下面的代码列表显示了示例文件 dbpedia-lookup.lisp (位于目录 src/dbpedia 中) 的内容:

(ql:quickload :drakma)
(ql:quickload :babel)
(ql:quickload :s-xml)

;; utility from http://cl-cookbook.sourceforge.net/strings.html#manip:
(defun replace-all (string part replacement &key (test #'char=))
  "Returns a new string in which all the occurrences of the part
is replaced with replacement."
  (with-output-to-string (out)
    (loop with part-length = (length part)
          for old-pos = 0 then (+ pos part-length)
          for pos = (search part string
                            :start2 old-pos
                            :test test)
          do (write-string string out
                           :start old-pos
                           :end (or pos (length string)))
          when pos do (write-string replacement out)
            while pos)))

(defstruct dbpedia-data uri label description)

(defun dbpedia-lookup (search-string)
  (let* ((s-str (replace-all search-string " " "+"))
         (s-uri
           (concatenate
            'string
            "http://lookup.dbpedia.org/api/search.asmx/KeywordSearch?QueryString="
            s-str))
         (response-body nil)
         (response-status nil)
         (response-headers nil)
         (xml nil)
         ret)
    (multiple-value-setq
        (response-body response-status response-headers)
      (drakma:http-request
       s-uri
       :method :get
       :accept "application/xml"))
    ;; (print (list "raw response body as XML:" response-body))
    ;;(print (list ("status:" response-status "headers:" response-headers)))
    (setf xml
          (s-xml:parse-xml-string
           (babel:octets-to-string response-body)))
    (dolist (r (cdr xml))
      ;; assumption: data is returned in the order:
      ;; 1. label
      ;; 2. DBPedia URI for more information
      ;; 3. description
      (push
       (make-dbpedia-data
        :uri (cadr (nth 2 r))
        :label (cadr (nth 1 r))
        :description
        (string-trim
         '(#\Space #\NewLine #\Tab)
         (cadr (nth 3 r))))
       ret))
    (reverse ret)))

;; (dbpedia-lookup "berlin")