11-控制结构.texi

\input texinfo    @c -*- texinfo -*-
@c %**start of header
@setfilename 11-控制结构.info
@settitle 
@documentencoding UTF-8
@documentlanguage en
@c %**end of header

@finalout
@titlepage
@title 
@author zunrong
@end titlepage

@contents

@ifnottex
@node Top
@top 
@end ifnottex

@menu
* 11 控制结构::

@detailmenu
--- The Detailed Node Listing ---

11 控制结构

* 11.1 测序: 111 测序. 
* 11.2 条件: 112 条件. 
* 11.3 组合条件的构造: 113 组合条件的构造. 
* 11.4 模式匹配条件: 114 模式匹配条件. 
* 11.5 迭代: 115 迭代. 
* 11.6 生成器: 116 生成器. 
* 11.7 非本地出口: 117 非本地出口. 

11.4 模式匹配条件

* 11.4.1 pcase宏: 1141 pcase宏. 
* 11.4.2 扩展 pcase: 1142 扩展 pcase. 
* 11.4.3 反引号样式模式: 1143 反引号样式模式. 
* 11.4.4 解构 pcase模式: 1144 解构 pcase模式. 

11.7 非本地出口

* 11.7.1 显式非本地出口： catch和 throw: 1171 显式非本地出口： catch和 throw. 
* 11.7.2 示例 catch和 throw: 1172 示例 catch和 throw. 
* 11.7.3 错误: 1173 错误. 
* 11.7.4 清理非本地出口: 1174 清理非本地出口. 

@end detailmenu
@end menu

@node 11 控制结构
@chapter 11 控制结构

Lisp 程序由一组表达式或表单组成（请参阅表单种类）。我们通过将它们封装在控制结构中来控制这些表单的执行顺序。控制结构是特殊形式，它控制何时、是否或多少次执行它们所包含的表单。

最简单的执行顺序是顺序执行：首先形成 a，然后形成 b，依此类推。当您在函数体中或在 Lisp 代码文件的顶层连续编写多个表单时，就会发生这种情况——表单按照编写的顺序执行。我们称之为文本顺序。例如，如果函数体由 a 和 b 两种形式组成，则函数的求值首先求值 a，然后求值 b。计算 b 的结果成为函数的值。

显式控制结构使执行顺序成为可能，而不是顺序。

Emacs Lisp 提供了多种控制结构，包括其他种类的排序、条件、迭代和（受控）跳转——所有这些都将在下面讨论。内置控制结构是特殊形式，因为它们的子形式不一定要评估或不按顺序评估。您可以使用宏来定义自己的控制结构构造（请参阅宏）。

@menu
* 11.1 测序: 111 测序. 
* 11.2 条件: 112 条件. 
* 11.3 组合条件的构造: 113 组合条件的构造. 
* 11.4 模式匹配条件: 114 模式匹配条件. 
* 11.5 迭代: 115 迭代. 
* 11.6 生成器: 116 生成器. 
* 11.7 非本地出口: 117 非本地出口. 
@end menu

@node 111 测序
@section 11.1 测序

按表单出现的顺序评估表单是控制从一种表单传递到另一种表单的最常见方式。在某些情况下，例如在函数体中，这会自动发生。在其他地方，您必须使用控制结构结构来执行此操作：progn，Lisp 最简单的控制结构。

progn 特殊形式如下所示：

@lisp
(progn a b c …)
@end lisp

它说按顺序执行表格 a、b、c 等等。这些形式称为 progn 形式的主体。正文中最后一个形式的值成为整个 progn 的值。(progn) 返回零。

在 Lisp 的早期，progn 是连续执行两个或多个表单并使用最后一个的值的唯一方法。但是程序员发现他们经常需要在函数体中使用 progn，而（当时）只允许一种形式。因此，函数的主体被制作成隐式的 progn：允许使用多种形式，就像在实际 progn 的主体中一样。许多其他控制结构同样包含一个隐含的 progn。因此，progn 的使用量不如多年前。现在最常在 unwind-protect 中使用它，并且，或，或 if 的 then 部分。

@lisp
Special Form: progn forms… ¶
@end lisp

@lisp
(progn (print "The first form")
       (print "The second form")
       (print "The third form"))
     -| "The first form"
     -| "The second form"
     -| "The third form"
⇒ "The third form"
@end lisp

这种特殊形式以文本顺序评估所有形式，返回最终形式的结果。

另外两个构造同样评估一系列形式，但返回不同的值：

@lisp
Special Form: prog1 form1 forms… ¶
@end lisp

这种特殊的形式以文本顺序计算 form1 和所有的形式，返回 form1 的结果。

@lisp
(prog1 (print "The first form")
       (print "The second form")
       (print "The third form"))
     -| "The first form"
     -| "The second form"
     -| "The third form"
⇒ "The first form"
@end lisp


这是一种从变量 x 的列表中删除第一个元素，然后返回前一个元素的值的方法：

@lisp
(prog1 (car x) (setq x (cdr x)))
@end lisp


@lisp
Special Form: prog2 form1 form2 forms… ¶
@end lisp
这种特殊形式按文本顺序计算 form1、form2 和以下所有形式，并返回 form2 的结果。

@lisp
(prog2 (print "The first form")
       (print "The second form")
       (print "The third form"))
     -| "The first form"
     -| "The second form"
     -| "The third form"
⇒ "The second form"
@end lisp

@node 112 条件
@section 11.2 条件

条件控制结构在备选方案中进行选择。Emacs Lisp 有五种条件形式：if，这和其他语言很相似；  when 和 unless，它们是 if 的变体；  cond，这是一个广义的案例陈述；  和 pcase，它是 cond 的概括（参见 Pattern-Matching Conditional）。

@lisp
Special Form: if condition then-form else-forms… ¶
@end lisp

if 根据条件的值在 then-form 和 else-forms 之间进行选择。如果评估的条件不为 nil，则评估 then-form 并返回结果。否则，else-forms 将按文本顺序进行评估，并返回最后一个的值。（if 的 else 部分是隐式 progn 的一个示例。请参阅 Sequencing。）

如果 condition 的值为 nil，并且没有给出 else-forms，则 if 返回 nil。

if 是一种特殊形式，因为未选择的分支永远不会被评估——它被忽略。因此，在此示例中，不会打印 true ，因为从不调用 print：

@lisp
(if nil
    (print 'true)
  'very-false)
⇒ very-false
@end lisp

@lisp
Macro: when condition then-forms… ¶
@end lisp

这是 if 的一种变体，其中没有 else-forms，并且可能有几个 then-forms。尤其，

@lisp
(when condition a b c)
@end lisp


完全等同于

@lisp
(if condition (progn a b c) nil)
@end lisp


@lisp
Macro: unless condition forms… ¶
@end lisp

这是没有 then 形式的 if 的变体：

@lisp
(unless condition a b c)
@end lisp

完全等同于
@lisp
(if condition nil
   a b c)
@end lisp

@lisp
Special Form: cond clause… ¶
@end lisp

cond 在任意数量的备选方案中进行选择。cond 中的每个子句都必须是一个列表。此列表的 CAR 是条件；  其余的元素，如果有的话，身体形式。因此，一个子句如下所示：

@lisp
(condition body-forms…)
@end lisp

cond 通过评估每个子句的条件，按文本顺序尝试子句。如果条件的值为非零，则该子句成功；  然后 cond 评估它的 body-forms，并返回最后一个 body-forms 的值。任何剩余的子句都将被忽略。

如果 condition 的值为 nil，则该子句失败，因此 cond 转到下一个子句，尝试其条件。

子句也可能如下所示：

@lisp
(condition)
@end lisp

然后，如果条件在测试时不为零，则 cond 形式返回条件的值。

如果每个条件的计算结果都为 nil，因此每个子句都失败，则 cond 返回 nil。

以下示例有四个子句，分别测试 x 的值是数字、字符串、缓冲区和符号的情况：
@lisp
(cond ((numberp x) x)
      ((stringp x) x)
      ((bufferp x)
       (setq temporary-hack x) ; multiple body-forms
       (buffer-name x))        ; in one clause
      ((symbolp x) (symbol-value x)))
@end lisp

当前面的子句都没有成功时，我们经常希望执行最后一个子句。为此，我们使用 t 作为最后一个子句的条件，如下所示：(t body-forms)。形式 t 计算为 t，它永远不会是 nil，所以这个子句永远不会失败，只要 cond 得到它。例如：

@lisp
(setq a 5)
(cond ((eq a 'hack) 'foo)
      (t "default"))
⇒ "default"
@end lisp

如果 a 的值为 hack，则此 cond 表达式返回 foo，否则返回字符串 @code{default} 。

任何条件构造都可以用 cond 或 if 表示。因此，它们之间的选择是风格问题。例如：

@lisp
(if a b c)
≡
(cond (a b) (t c))
@end lisp

@node 113 组合条件的构造
@section 11.3 组合条件的构造

本节描述了经常与 if 和 cond 一起使用来表达复杂条件的结构。结构和和或也可以单独用作多种条件结构。

@lisp
Function: not condition ¶
@end lisp

此功能测试条件的虚假性。如果条件为 nil，则返回 t，否则返回 nil。函数 not 与 null 相同，如果您正在测试空列表，我们建议使用名称 null。 

@lisp
Special Form: and conditions… ¶
@end lisp

和特殊形式测试是否所有条件都为真。它通过按写入的顺序一一评估条件来工作。

如果任何条件的计算结果为 nil，则 and 的结果必须为 nil，而不管其余条件如何；  所以并立即返回 nil ，忽略其余条件。

如果所有条件都非零，那么最后一个条件的值将成为 and 形式的值。Just (and)，没有条件，返回 t，因为所有条件都非零。（想想看，哪个没有？）

这是一个例子。第一个条件返回整数 1，它不是 nil。同样，第二个条件返回整数 2，它不是 nil。第三个条件为 nil，因此永远不会评估剩余的条件。
@lisp
(and (print 1) (print 2) nil (print 3))
     -| 1
     -| 2
⇒ nil
@end lisp

这是一个更实际的使用 and 的例子：

@lisp
(if (and (consp foo) (eq (car foo) 'x))
    (message "foo is a list starting with x"))
@end lisp

请注意，如果 (consp foo) 返回 nil，则不执行 (car foo)，从而避免错误。

and 表达式也可以使用 if 或 cond 来编写。就是这样：
@lisp
(and arg1 arg2 arg3)
≡
(if arg1 (if arg2 arg3))
≡
(cond (arg1 (cond (arg2 arg3))))
@end lisp

@lisp
Special Form: or conditions… ¶
@end lisp

或特殊形式测试至少一个条件是否为真。它通过按写入的顺序一一评估所有条件来工作。

如果任何条件的计算结果为非零值，则 or 的结果必须为非零；  so or 立即返回，忽略其余条件。它返回的值是刚刚评估的条件的非零值。

如果所有条件都为 nil，则 or 表达式返回 nil。Just (or)，没有条件，返回 nil，因为所有条件都变成 nil。（想想看，哪个没有？）

例如，这个表达式测试 x 是 nil 还是整数零：

@lisp
(or (eq x nil) (eq x 0))
@end lisp
像 and 构造，or 可以写成 cond。例如：

@lisp
(or arg1 arg2 arg3)
≡
(cond (arg1)
      (arg2)
      (arg3))
@end lisp

你几乎可以用 if 来写或写，但不完全是：

@lisp
(if arg1 arg1
  (if arg2 arg2
    arg3))
@end lisp


这并不完全等效，因为它可以计算 arg1 或 arg2 两次。相比之下， (或 arg1 arg2 arg3) 从不多次评估任何参数。 

@lisp
Function: xor condition1 condition2 ¶
@end lisp

此函数返回条件 1 和条件 2 的布尔异或。也就是说，如果两个参数都为 nil，或者两者都不是 nil，则 xor 返回 nil。否则，它返回非零参数的值。

请注意，与 or 相比，两个参数总是被评估。

@node 114 模式匹配条件
@section 11.4 模式匹配条件

除了四种基本的条件形式之外，Emacs Lisp 还有一个模式匹配条件形式，pcase 宏，是 cond 和 cl-case 的混合体（参见 Common Lisp Extensions 中的条件），它克服了它们的限制并引入了模式匹配编程风格.  pcase 克服的限制是：

cond 形式通过评估其每个子句的谓词条件来在备选方案中进行选择（请参阅条件）。主要限制是条件中的变量对子句的主体形式不可用。

另一个烦恼（与其说是限制，不如说是不便）是，当一系列条件谓词实现相等测试时，会出现大量重复代码。（cl-case 解决了这个不便。）
cl-case 宏通过评估其第一个参数与一组特定值的相等性来在备选方案中进行选择。

它的局限性有两个：
    相等性测试使用 eql。
    这些值必须事先知道并写入。 

这些使 cl-case 不适用于字符串或复合数据结构（例如，列表或向量）。（cond 没有这些限制，但它有其他限制，见上文。） 

从概念上讲，pcase 宏借用了 cl-case 的 first-arg 焦点和 cond 的子句处理流程，将 condition 替换为作为模式匹配变体的等式测试的泛化，并添加了设施，以便您可以简洁地表达子句的谓词，并安排在子句的谓词和正文形式之间共享 let 绑定。

谓词的简洁表达称为模式。当调用第一个参数的值的谓词返回非零时，我们说 @code{模式匹配值} （或有时 @code{值匹配模式} ）。

@menu
* 11.4.1 pcase宏: 1141 pcase宏. 
* 11.4.2 扩展 pcase: 1142 扩展 pcase. 
* 11.4.3 反引号样式模式: 1143 反引号样式模式. 
* 11.4.4 解构 pcase模式: 1144 解构 pcase模式. 
@end menu

@node 1141 pcase宏
@subsection 11.4.1 pcase宏

有关背景，请参阅模式匹配条件。

@lisp
Macro: pcase expression &rest clauses ¶
@end lisp

子句中的每个子句都具有以下形式：（模式主体形式@dots{}）。

计算表达式以确定它的值，expval。在模式与 expval 匹配的子句中查找第一个子句，并将控制权传递给该子句的主体形式。

如果匹配，则 pcase 的值是成功子句中最后一个 body-forms 的值。否则，pcase 的计算结果为 nil。 

每个模式都必须是一个 pcase 模式，它可以使用下面定义的核心模式之一，或者通过 pcase-defmacro 定义的模式之一（请参阅扩展 pcase）。

本小节的其余部分描述了不同形式的核心模式，提供了一些示例，并以使用某些模式形式提供的 let-binding 工具的重要警告作为结尾。核心模式可以有以下形式：

@lisp
_
@end lisp

匹配任何 expval。这也称为无关或通配符。
@lisp
'val
@end lisp

如果 expval 等于 val，则匹配。比较是通过 equal 来完成的（参见 Equality Predicates）。
@lisp
keyword
@end lisp
@lisp
integer
@end lisp
@lisp
string
@end lisp

如果 expval 等于文字对象，则匹配。这是上面 'val 的一个特例，可能是因为这些类型的字面量对象是自引用的。
@lisp
symbol
@end lisp

匹配任何 expval，另外让 let-binds 符号与 expval 匹配，这样该绑定可用于 body-forms（请参阅动态绑定）。

如果symbol 是排序模式seqpat 的一部分（例如，通过使用and，下面），则绑定也可用于seqpat 出现在symbol 之后的部分。这种用法有一些注意事项，请参阅注意事项。

要避免的两个符号是 t，它的行为类似于 _（上图）并且已被弃用，以及 nil，它表示错误。同样，绑定关键字符号也没有任何意义（请参阅永不更改的变量）。
@lisp
(cl-type type)
@end lisp

如果 expval 是 type 类型，则匹配，这是 cl-typep 接受的类型描述符（请参阅 Common Lisp Extensions 中的类型谓词）。例子：

@lisp
(cl-type integer)
(cl-type (integer 0 10))
@end lisp


@lisp
(pred function)
@end lisp

如果谓词函数在 expval 上调用时返回非零，则匹配。可以使用语法 (pred (not function)) 来否定测试。谓词函数可以具有以下形式之一：

@lisp
function name (a symbol)
@end lisp

使用一个参数 expval 调用命名函数。

    示例：整数 p
拉姆达表达式
@lisp


@end lisp

使用一个参数 expval 调用匿名函数（请参阅 Lambda 表达式）。

示例： (lambda (n) (= 42 n))
@lisp
function call with n args
@end lisp

使用 n 个参数（其他元素）和一个附加的第 n+1 个参数（即 expval）调用函数（函数调用的第一个元素）。

示例：（= 42）
本例中，函数为=，n为1，实际函数调用变为：(= 42 expval)。 

@lisp
(app function pattern)
@end lisp

如果在 expval 上调用的函数返回与模式匹配的值，则匹配。函数可以采用上面为 pred 描述的形式之一。然而，与 pred 不同的是，app 根据模式而不是布尔真值测试结果。
@lisp
(guard boolean-expression)
@end lisp

如果 boolean-expression 计算结果为非 nil，则匹配。
@lisp
(let pattern expr)
@end lisp

评估 expr 以获取 exprval，如果 exprval 匹配模式则匹配。（之所以称为 let，是因为模式可以使用符号将符号绑定到值。） 

排序模式（也称为 seqpat）是一种按顺序处理其子模式参数的模式。pcase 有两个：and 和 or。它们的行为方式与共享其名称的特殊形式类似（请参阅组合条件的构造），但它们不是处理值，而是处理子模式。

@lisp
(and pattern1…)
@end lisp

尝试按顺序匹配 pattern1@dots{}，直到其中一个无法匹配。在这种情况下，同样无法匹配，其余的子模式不会被测试。如果所有子模式都匹配，则匹配。
@lisp
(or pattern1 pattern2…)
@end lisp

尝试按顺序匹配 pattern1、pattern2、@dots{}，直到其中一个成功。在那种情况下，或者同样匹配，其余的子模式不会被测试。

为了向 body-forms 呈现一致的环境（参见评估简介）（从而避免匹配时的评估错误），模式绑定的变量集是每个子模式绑定的变量的并集。如果一个变量没有被匹配的子模式绑定，那么它被绑定为 nil。
@lisp
(rx rx-expr…)
@end lisp

将字符串与正则表达式 rx-expr@dots{} 匹配，使用 rx 正则表达式表示法（请参阅 rx 结构化正则表达式表示法），就像通过字符串匹配一样。

除了通常的 rx 语法，rx-expr… 可以包含以下结构：

@lisp
(let ref rx-expr…)
@end lisp

将符号 ref 绑定到匹配 rx-expr@dots{}. 的子匹配。 ref 以 body-forms 绑定到子匹配或 nil 的字符串，但也可以在 backref 中使用。
@lisp
(backref ref)
@end lisp

与标准的 backref 结构类似，但这里的 ref 也可以是前一个 (let ref @dots{}) 结构引入的名称。 

示例： 优于 cl-case

这是一个示例，它突出了 pcase 相对于 cl-case 的一些优势（请参阅 Common Lisp Extensions 中的条件）。

@lisp
(pcase (get-return-code x)
  ;; string
  ((and (pred stringp) msg)
   (message "%s" msg))

  ;; symbol
  ('success       (message "Done!"))
  ('would-block   (message "Sorry, can't do it now"))
  ('read-only     (message "The shmliblick is read-only"))
  ('access-denied (message "You do not have the needed rights"))

  ;; default
  (code           (message "Unknown return code %S" code)))
@end lisp

使用 cl-case，您需要显式声明一个局部变量 code 来保存 get-return-code 的返回值。cl-case 也很难与字符串一起使用，因为它使用 eql 进行比较。
示例：使用和

一个常见的习惯用法是编写一个以 and 开头的模式，其中一个或多个符号子模式提供与随后的子模式（以及主体形式）的绑定。例如，以下模式匹配一​​位整数。

@lisp
(and
  (pred integerp)
  n                     ; bind n to expval
  (guard (<= -9 n 9)))
@end lisp

首先，如果 (integerp expval) 的计算结果为非零，则 pred 匹配。接下来，n 是一个匹配任何东西并将 n 绑定到 expval 的符号模式。最后，如果布尔表达式 (<= -9 n 9)（注意对 n 的引用）的计算结果为非零，则防护匹配。如果所有这些子模式都匹配，则匹配。
示例：使用 pcase 重新表述

这是另一个示例，展示了如何将简单的匹配任务从其传统实现（函数 grok/traditional）重新表述为使用 pcase（函数 grok/pcase）的匹配任务。这两个函数的文档字符串是： @code{如果 OBJ 是 ~key:NUMBER} 形式的字符串，则返回 NUMBER（字符串）。否则，返回列表（ @code{149} 默认）。~   一、传统实现（见正则表达式）：

@lisp
(defun grok/traditional (obj)
  (if (and (stringp obj)
           (string-match "^key:\\([[:digit:]]+\\)$" obj))
      (match-string 1 obj)
    (list "149" 'default)))


(grok/traditional "key:0")   ⇒ "0"
(grok/traditional "key:149") ⇒ "149"
(grok/traditional 'monolith) ⇒ ("149" default)
@end lisp

重新表述演示了符号绑定以及 or、and、pred、app 和 let。

@lisp
(defun grok/pcase (obj)
  (pcase obj
    ((or                                     ; line 1
      (and                                   ; line 2
       (pred stringp)                        ; line 3
       (pred (string-match                   ; line 4
              "^key:\\([[:digit:]]+\\)$"))   ; line 5
       (app (match-string 1)                 ; line 6
            val))                            ; line 7
      (let val (list "149" 'default)))       ; line 8
     val)))                                  ; line 9


(grok/pcase "key:0")   ⇒ "0"
(grok/pcase "key:149") ⇒ "149"
(grok/pcase 'monolith) ⇒ ("149" default)
@end lisp


grok/pcase 的大部分是 pcase 形式的单个子句，第 1-8 行的模式，第 9 行的（单个）主体形式。模式是 or，它尝试依次匹配其参数子模式，首先是 and（第 2-7 行），然后是 let（第 8 行），直到其中一个成功。

与前面的示例一样（参见示例 1），并以 pred 子模式开始，以确保以下子模式与正确类型的对象（在本例中为字符串）一起工作。如果 (stringp expval) 返回 nil，则 pred 失败，因此也失败了。

下一个 pred（第 4-5 行）计算 (string-match RX expval) 并在结果为非 nil 时进行匹配，这意味着 expval 具有所需的形式：key:NUMBER。再一次，失败了，pred 失败了，and 也失败了。

最后（在这一系列和子模式中），app 评估 (match-string 1 expval)（第 6 行）以获取临时值 tmp（即 @code{NUMBER} 子字符串）并尝试将 tmp 与模式 val（行7）。由于这是一个符号模式，它无条件匹配并且另外将 val 绑定到 tmp。

现在该应用程序已匹配，所有和子模式都已匹配，所以和匹配。同样，一旦和已经匹配，或者匹配并且不继续尝试子模式 let（第 8 行）。

让我们考虑一下 obj 不是字符串，或者它是字符串但格式错误的情况。在这种情况下，pred 之一（第 3-5 行）无法匹配，因此（第 2 行）无法匹配，因此或（第 1 行）继续尝试子模式 let（第 8 行）。

首先，让计算 (list "149" 'default) 得到 ("149" default) exprval，然后尝试将 exprval 与模式 val 匹配。由于这是一个符号模式，它无条件匹配并且另外将 val 绑定到 exprval。现在 let 已经匹配，或者匹配。

注意 and 和 let 子模式是如何以相同的方式完成的：通过在进程绑定 val 中尝试（总是成功）匹配符号模式 val。因此，or 总是匹配并且控制总是传递给 body 表单（第 9 行）。因为这是成功匹配的 pcase 子句中的最后一个主体形式，所以它是 pcase 的值，也是 grok/pcase 的返回值（参见什么是函数？）。
排序模式中符号的注意事项

前面的示例都使用了以某种方式包含符号子模式的排序模式。以下是有关该用法的一些重要细节。

当 symbol 在 seqpat 中多次出现时，第二次和后续的出现不会扩展为重新绑定，而是使用 eq 扩展为相等测试。

以下示例具有一个 pcase 形式，其中包含两个子句和两个 seqpat，A 和 B。A 和 B 都首先检查 expval 是否是一对（使用 pred），然后将符号绑定到 expval 的 car 和 cdr（每个使用一个 app ）。

对于 A，因为符号 st 被提及两次，第二次提及成为使用 eq 的相等性测试。另一方面，B 使用两个单独的符号 s1 和 s2，它们都成为独立的绑定。

@lisp


(defun grok (object)
  (pcase object
    ((and (pred consp)        ; seqpat A
          (app car st)        ; first mention: st
          (app cdr st))       ; second mention: st
     (list 'eq st))

    ((and (pred consp)        ; seqpat B
          (app car s1)        ; first mention: s1
          (app cdr s2))       ; first mention: s2
     (list 'not-eq s1 s2))))


(let ((s "yow!"))
  (grok (cons s s)))      ⇒ (eq "yow!")
(grok (cons "yo!" "yo!")) ⇒ (not-eq "yo!" "yo!")
(grok '(4 2))             ⇒ (not-eq 4 (2))
@end lisp


副作用代码引用符号未定义。避免。例如，这里有两个类似的函数。都使用和，符号和守卫：

@lisp
(defun square-double-digit-p/CLEAN (integer)
  (pcase (* integer integer)
    ((and n (guard (< 9 n 100))) (list 'yes n))
    (sorry (list 'no sorry))))

(square-double-digit-p/CLEAN 9) ⇒ (yes 81)
(square-double-digit-p/CLEAN 3) ⇒ (no 9)


(defun square-double-digit-p/MAYBE (integer)
  (pcase (* integer integer)
    ((and n (guard (< 9 (incf n) 100))) (list 'yes n))
    (sorry (list 'no sorry))))

(square-double-digit-p/MAYBE 9) ⇒ (yes 81)
(square-double-digit-p/MAYBE 3) ⇒ (yes 9)  ; WRONG!
@end lisp

区别在于保护中的布尔表达式：CLEAN 简单直接地引用 n，而 MAYBE 在表达式 (incf n) 中引用具有副作用的 n。当整数为 3 时，会发生以下情况：

第一个 n 将其绑定到 expval，即计算 (* 3 3) 或 9 的结果。
    评估布尔表达式：
@lisp
start:   (< 9 (incf n)        100)
becomes: (< 9 (setq n (1+ n)) 100)
becomes: (< 9 (setq n (1+ 9)) 100)

becomes: (< 9 (setq n 10)     100)
                                   ; side-effect here!
becomes: (< 9       n         100) ; n now bound to 10
becomes: (< 9      10         100)
becomes: t
@end lisp

因为评估的结果是非零，所以保护匹配和匹配，并且控制传递到该子句的主体形式。 

除了断言 9 是一个两位数的整数在数学上的错误之外，MAYBE 还有另一个问题。主体形式再次引用 n，但我们根本看不到更新后的值 10。这是怎么回事？

总而言之，最好完全避免对符号模式的副作用引用，不仅在 boolean-expression（在 guard 中），而且在 expr（在 let）和 function（在 pred 和 app）中。
在匹配时，子句的主体形式可以引用模式 let-binds 的符号集。当 seqpat 是 and 时，这个集合是所有符号的并集，每个符号的子模式 let-binds。这是有道理的，因为为了匹配，所有子模式都必须匹配。

当 seqpat 为 or 时，情况有所不同： or 匹配第一个匹配的子模式；  其余的子模式被忽略。每个子模式让绑定不同的符号集是没有意义的，因为主体形式无法区分哪个子模式匹配并在不同的集合中进行选择。例如，以下内容无效：

@lisp
(require 'cl-lib)
(pcase (read-number "Enter an integer: ")
  ((or (and (pred cl-evenp)
            e-num)      ; bind e-num to expval
       o-num)           ; bind o-num to expval
   (list e-num o-num)))


Enter an integer: 42
error→ Symbol’s value as variable is void: o-num

Enter an integer: 149
error→ Symbol’s value as variable is void: e-num
@end lisp

评估正文形式（list e-num o-num）表示错误。为了区分子模式，您可以使用另一个符号，在所有子模式中名称相同但值不同。重写上面的例子：

@lisp
(require 'cl-lib)
(pcase (read-number "Enter an integer: ")
  ((and num                                ; line 1
        (or (and (pred cl-evenp)           ; line 2
                 (let spin 'even))         ; line 3
            (let spin 'odd)))              ; line 4
   (list spin num)))                       ; line 5


Enter an integer: 42
⇒ (even 42)

Enter an integer: 149
⇒ (odd 149)
@end lisp


第 1 行用 and 和符号 @code{分解} 了 expval 绑定（在本例中为 num）。在第 2 行，或以与之前相同的方式开始，但不是绑定不同的符号，而是使用 let 两次（第 3-4 行）在两个子模式中绑定相同的符号自旋。spin 的值区分子模式。正文形式引用了这两个符号（第 5 行）。

@node 1142 扩展 pcase
@subsection 11.4.2 扩展 pcase

pcase 宏支持多种模式（请参阅模式匹配条件）。您可以使用 pcase-defmacro 宏添加对其他类型模式的支持。

宏：pcase-defmacro name args [doc] &rest body ¶

为 pcase 定义一种新的模式，以 (name actual-args) 调用。pcase 宏将此扩展为一个评估 body 的函数调用，它的工作是将调用的模式重写为其他模式，在 args 绑定到实际参数的环境中。

此外，安排与 pcase 的文档字符串一起显示文档。按照惯例，doc 应该使用 EXPVAL 来代表计算表达式的结果（第一个 arg 到 pcase）。 

通常，body 会重写调用的模式以使用更基本的模式。尽管所有的模式最终都归结为核心模式，但身体不需要立即使用核心模式。下面的示例定义了两个模式，分别命名为小于和整数小于。

@lisp
(pcase-defmacro less-than (n)
  "Matches if EXPVAL is a number less than N."
  `(pred (> ,n)))


(pcase-defmacro integer-less-than (n)
  "Matches if EXPVAL is an integer less than N."
  `(and (pred integerp)
        (less-than ,n)))
@end lisp

请注意，文档字符串以通常的方式提到了 args（在这种情况下，只有一个：n），并且按照惯例也提到了 EXPVAL。第一次重写（即，小于的主体）使用一个核心模式：pred。第二种使用两个核心模式：and 和 pred，以及新定义的模式 less-than。两者都使用单个反引号结构（请参阅反引号）。

@node 1143 反引号样式模式
@subsection 11.4.3 反引号样式模式

本小节描述了反引号样式模式，这是一组简化结构匹配的内置模式。有关背景，请参阅模式匹配条件。

反引号样式模式是一组功能强大的 pcase 模式扩展（使用 pcase-defmacro 创建），可以轻松地将 expval 与其结构规范进行匹配。

例如，要匹配 expval 必须是两个元素的列表，其中第一个元素是特定字符串，第二个元素是任何值，您可以编写一个核心模式：

@lisp
(and (pred listp)
     ls

     (guard (= 2 (length ls)))
     (guard (string= "first" (car ls)))
     (let second-elem (cadr ls)))
@end lisp

或者您可以编写等效的反引号样式模式：

@lisp
`("first" ,second-elem)
@end lisp


反引号样式的模式更简洁，类似于 expval 的结构，并且避免了绑定 ls。

反引号样式的模式具有 `qpat 形式，其中 qpat 可以具有以下形式：

@lisp
[qpat1 qpat2 … qpatm]
@end lisp
如果 expval 是其 car 与 qpat1 匹配且 cdr 与 qpat2 匹配的 cons 单元格，则匹配。这很容易推广到 (qpat1 qpat2 @dots{}) 中的列表。
@lisp
symbol
@end lisp

如果 expval 是长度为 m 的向量，其第 0..(m-1) 个元素分别匹配 qpat1、qpat2 @dots{} qpatm，则匹配。
@lisp
keyword
@end lisp
@lisp
number
@end lisp
@lisp
string
@end lisp

如果 expval 的对应元素等于指定的文字对象，则匹配。
@lisp
,pattern
@end lisp

如果 expval 的相应元素与模式匹配，则匹配。请注意，模式是 pcase 支持的任何类型。（在上面的例子中，second-elem 是一个符号核心模式；因此它匹配任何东西，并且 let-binds second-elem。） 

对应的元素是 expval 中与反引号样式模式中 qpat 的结构位置相同的部分。（在上面的例子中，second-elem 的对应元素是 expval 的第二个元素。）

这是一个使用 pcase 为小表达式语言实现简单解释器的示例（请注意，这需要对 fn 子句中的 lambda 表达式进行词法绑定以正确捕获 body 和 arg（请参阅词法绑定）：

@lisp
(defun evaluate (form env)
  (pcase form
    (`(add ,x ,y)       (+ (evaluate x env)
                           (evaluate y env)))

    (`(call ,fun ,arg)  (funcall (evaluate fun env)
                                 (evaluate arg env)))
    (`(fn ,arg ,body)   (lambda (val)
                          (evaluate body (cons (cons arg val)
                                               env))))

    ((pred numberp)     form)
    ((pred symbolp)     (cdr (assq form env)))
    (_                  (error "Syntax error: %S" form))))
@end lisp

前三个子句使用反引号样式的模式。`(add ,x ,y) 是一种模式，它检查表单是否是以文字符号 add 开头的三元素列表，然后提取第二个和第三个元素并将它们分别绑定到符号 x 和 y。子句主体评估 x 和 y 并添加结果。同样，call 子句实现函数调用，fn 子句实现匿名函数定义。

其余子句使用核心模式。(pred numberp) 如果 form 是数字，则匹配。在比赛中，身体评估它。(pred symbolp) 如果 form 是一个符号，则匹配。匹配时，主体在 env 中查找符号并返回其关联。最后， _ 是匹配任何东西的包罗万象的模式，因此它适用于报告语法错误。

以下是一些用这种小语言编写的示例程序，包括它们的评估结果：

@lisp
(evaluate '(add 1 2) nil)                 ⇒ 3
(evaluate '(add x y) '((x . 1) (y . 2)))  ⇒ 3
(evaluate '(call (fn x (add 1 x)) 2) nil) ⇒ 3
(evaluate '(sub 1 2) nil)                 ⇒ error
@end lisp

@node 1144 解构 pcase模式
@subsection 11.4.4 解构 pcase模式

Pcase 模式不仅表达了它们可以匹配的对象形式的条件，而且它们还可以提取这些对象的子字段。例如，我们可以使用以下代码从变量 my-list 的值的列表中提取 2 个元素：

@lisp
(pcase my-list
  (`(add ,x ,y)  (message "Contains %S and %S" x y)))
@end lisp


这不仅会提取 x 和 y，还会额外测试 my-list 是否是一个恰好包含 3 个元素且其第一个元素是符号 add 的列表。如果这些测试中的任何一个失败，pcase 将立即返回 nil 而不会调用 message。

提取存储在对象中的多个值称为解构。使用 pcase 模式允许执行解构绑定，这类似于局部绑定（请参阅局部变量），但通过从兼容结构的对象中提取这些值来为变量的多个元素提供值。

本节中描述的宏使用 pcase 模式来执行解构绑定。对象具有兼容结构的条件意味着对象必须匹配模式，因为只有这样才能提取对象的子字段。例如：

@lisp
(pcase-let ((`(add ,x ,y) my-list))
  (message "Contains %S and %S" x y))
@end lisp


与前面的示例相同，只是它直接尝试从 my-list 中提取 x 和 y，而无需首先验证 my-list 是否是具有正确数量的元素并且将 add 作为其第一个元素的列表。当对象实际上与模式不匹配时的精确行为是未定义的，尽管主体不会被静默地跳过：要么发出错误信号，要么运行主体，其中一些变量可能绑定到任意值，如 nil。

对解构绑定有用的 pcase 模式通常是反引号样式模式中描述的那些模式，因为它们表达了将匹配的对象结构的规范。

有关解构绑定的替代工具，请参阅 seq-let。

@lisp
Macro: pcase-let bindings body… ¶
@end lisp

根据绑定对变量进行解构绑定，然后对body求值。

bindings 是 (pattern exp) 形式的绑定列表，其中 exp 是要计算的表达式，而 pattern 是 pcase 模式。

首先评估所有 exp，然后将它们与各自的模式匹配，引入新的变量绑定，然后可以在 body 中使用。变量绑定是通过解构 pattern 元素与计算的 exp 的相应元素的值的绑定来产生的。 

@lisp
Macro: pcase-let* bindings body… ¶
@end lisp

根据绑定对变量进行解构绑定，然后对body求值。

bindings 是 (pattern exp) 形式的绑定列表，其中 exp 是要计算的表达式，而 pattern 是 pcase 模式。变量绑定是通过解构 pattern 元素与计算的 exp 的相应元素的值的绑定来产生的。

与 pcase-let 不同，但与 let* 类似，每个 exp 在处理绑定的下一个元素之前与其对应的模式匹配，因此在每个绑定中引入的变量绑定在它后面的绑定的 exp 中可用，除了身体可用。 

@lisp
Macro: pcase-dolist (pattern list) body… ¶
@end lisp

对 list 的每个元素执行一次 body ，在每次迭代时，将 pattern 中的变量解构绑定到 list 元素的相应子字段的值。绑定就像通过 pcase-let 一样执行。当 pattern 是一个简单变量时，这最终等同于 dolist（请参阅迭代）。 

@lisp
Macro: pcase-setq pattern value… ¶
@end lisp

以 setq 形式为变量赋值，根据其各自的模式解构每个值。

@node 115 迭代
@section 11.5 迭代

迭代意味着重复执行程序的一部分。例如，您可能希望对列表的每个元素重复一次计算，或者对从 0 到 n 的每个整数重复一次。您可以在 Emacs Lisp 中使用特殊形式执行此操作，同时：

@lisp
Special Form: while condition forms… ¶
@end lisp

而首先评估条件。如果结果非零，它会按文本顺序评估表单。然后它重新评估条件，如果结果是非零，它再次评估表格。重复此过程，直到条件评估为零。

可能发生的迭代次数没有限制。循环将继续，直到任一条件评估为 nil 或直到错误或 throw 跳出它（请参阅非本地退出）。

@lisp
(setq num 0)
     ⇒ 0

(while (< num 4)
  (princ (format "Iteration %d." num))
  (setq num (1+ num)))
     -| Iteration 0.
     -| Iteration 1.
     -| Iteration 2.
     -| Iteration 3.
     ⇒ nil
@end lisp

要编写一个 repeat-until 循环，它将在每次迭代中执行某些操作，然后进行结束测试，请将主体后跟结束测试作为 while 的第一个参数放在 progn 中，如下所示：

@lisp
(while (progn
         (forward-line 1)
         (not (looking-at "^$"))))
@end lisp


这将向前移动一行并继续逐行移动，直到到达空行。奇怪的是，while 没有主体，只是结束测试（它也完成了移动点的实际工作）。 

dolist 和 dotimes 宏提供了方便的方法来编写两种常见的循环。

@lisp
Macro: dolist (var list [result]) body… ¶
@end lisp

此构造对列表的每个元素执行一次 body，在本地绑定变量 var 以保存当前元素。然后它返回评估结果的值，如果省略结果，则返回 nil。例如，以下是如何使用 dolist 定义反向函数：

@lisp
(defun reverse (list)
  (let (value)
    (dolist (elt list value)
      (setq value (cons elt value)))))
@end lisp


@lisp
Macro: dotimes (var count [result]) body… ¶
@end lisp

此构造对从 0（包括）到 count（不包括）的每个整数执行一次 body，将变量 var 绑定到当前迭代的整数。然后它返回评估结果的值，如果省略结果，则返回 nil。不推荐使用结果。下面是一个使用 dotimes 做某事 100 次的例子：

@lisp
(dotimes (i 100)
  (insert "I will not obey absurd orders\n"))
@end lisp

@node 116 生成器
@section 11.6 生成器

生成器是一个产生潜在无限值流的函数。每次函数产生一个值时，它都会挂起自己并等待调用者请求下一个值。

@lisp
Macro: iter-defun name args [doc] [declare] [interactive] body… ¶
@end lisp

iter-defun 定义了一个生成器函数。生成器函数与普通函数具有相同的签名，但工作方式不同。生成器函数在调用时不会执行主体，而是返回一个迭代器对象。该迭代器运行 body 以生成值，发出一个值并在出现 iter-yield 或 iter-yield-from 的地方暂停。当 body 正常返回时，iter-next 以 body 的结果作为其条件数据发出 iter-end-of-sequence 信号。

任何类型的 Lisp 代码在正文中都是有效的，但 iter-yield 和 iter-yield-from 不能出现在 unwind-protect 表单中。

@lisp
Macro: iter-lambda args [doc] [interactive] body… ¶
@end lisp

iter-lambda 生成一个未命名的生成器函数，其工作方式与使用 iter-defun 生成的生成器函数一样。 

@lisp
Macro: iter-yield value ¶
@end lisp

当它出现在生成器函数中时，iter-yield 表示当前迭代器应该暂停并从 iter-next 返回值。iter-yield 计算为下一次调用 iter-next 的 value 参数。 

@lisp
Macro: iter-yield-from iterator ¶
@end lisp

iter-yield-from 产生迭代器生成的所有值，并计算为迭代器的生成器函数正常返回的值。虽然它有控制权，但迭代器使用 iter-next 接收发送给迭代器的值。 

要使用生成器函数，首先正常调用它，生成一个迭代器对象。迭代器是生成器的特定实例。然后使用 iter-next 从这个迭代器中检索值。当没有更多值可以从迭代器中提取时，iter-next 会使用迭代器的最终值引发 iter-end-of-sequence 条件。

重要的是要注意生成器函数体仅在对 iter-next 的调用内部执行。对使用 iter-defun 定义的函数的调用会产生一个迭代器；  您必须使用 iter-next 驱动此迭代器，以使任何有趣的事情发生。对生成器函数的每次调用都会产生一个不同的迭代器，每个迭代器都有自己的状态。

@lisp
Function: iter-next iterator value ¶
@end lisp

从迭代器中检索下一个值。如果没有更多值要生成（因为返回了迭代器的生成器函数），iter-next 会发出 iter-end-of-sequence 条件的信号；  与此条件关联的数据值是迭代器的生成器函数返回的值。

value 被发送到迭代器并成为 iter-yield 评估的值。对于给定迭代器的第一次 iter-next 调用， value 将被忽略，因为在迭代器的生成器函数开始时，生成器函数不会评估任何 iter-yield 形式。 

@lisp
Function: iter-close iterator ¶
@end lisp

如果迭代器在 unwind-protect 的 bodyform 中暂停并且变得无法访问，Emacs 最终将在垃圾收集通过后运行 unwind 处理程序。（请注意，在 unwind-protect 的 unwindforms 中，iter-yield 是非法的。）要确保这些处理程序在此之前运行，请使用 iter-close。 

提供了一些便利功能以使使用迭代器更容易：

@lisp
Macro: iter-do (var iterator) body … ¶
@end lisp

运行 body 并将 var 绑定到迭代器生成的每个值。

Common Lisp 循环工具还包含使用迭代器的功能。请参阅 Common Lisp 扩展中的循环工具。

以下代码展示了使用迭代器的一些重要原则。

@lisp
(require 'generator)
(iter-defun my-iter (x)
  (iter-yield (1+ (iter-yield (1+ x))))
   ;; Return normally
  -1)

(let* ((iter (my-iter 5))
       (iter2 (my-iter 0)))
  ;; Prints 6
  (print (iter-next iter))
  ;; Prints 9
  (print (iter-next iter 8))
  ;; Prints 1; iter and iter2 have distinct states
  (print (iter-next iter2 nil))

  ;; We expect the iter sequence to end now
  (condition-case x
      (iter-next iter)
    (iter-end-of-sequence
      ;; Prints -1, which my-iter returned normally
      (print (cdr x)))))
@end lisp

@node 117 非本地出口
@section 11.7 非本地出口

非本地出口是从程序中的一个点到另一个远程点的控制转移。由于错误，Emacs Lisp 中可能会出现非本地退出；  您也可以在显式控制下使用它们。非本地退出取消绑定由正在退出的构造所做的所有变量绑定。

@menu
* 11.7.1 显式非本地出口： catch和 throw: 1171 显式非本地出口： catch和 throw. 
* 11.7.2 示例 catch和 throw: 1172 示例 catch和 throw. 
* 11.7.3 错误: 1173 错误. 
* 11.7.4 清理非本地出口: 1174 清理非本地出口. 
@end menu

@node 1171 显式非本地出口： catch和 throw
@subsection 11.7.1 显式非本地出口： catch和 throw

大多数控制结构只影响结构本身的控制流。函数 throw 是正常程序执行规则的一个例外：它根据请求执行非本地退出。（还有其他异常，但它们仅用于错误处理。） throw 在 catch 内使用，并跳转回该 catch。例如：

@lisp
(defun foo-outer ()
  (catch 'foo
    (foo-inner)))

(defun foo-inner ()
  …
  (if x
      (throw 'foo t))
  …)
@end lisp

如果执行 throw 形式，则将控制权直接转移回相应的 catch，该 catch 立即返回。throw 后面的代码不会被执行。throw 的第二个参数用作 catch 的返回值。

throw 函数根据第一个参数找到匹配的 catch：它搜索第一个参数等于 throw 中指定的参数的 catch。如果有多个适用的捕获，则最里面的捕获优先。因此，在上面的示例中，throw 指定了 foo，而 foo-outer 中的 catch 指定了相同的符号，因此 catch 是适用的（假设两者之间没有其他匹配的 catch）。

执行 throw 会退出所有 Lisp 结构，直到匹配的 catch，包括函数调用。当以这种方式退出诸如 let 或函数调用之类的绑定构造时，绑定是未绑定的，就像这些构造正常退出时一样（请参阅局部变量）。同样， throw 恢复由 save-excursion 保存的缓冲区和位置（请参阅 Excursions），以及由 save-restriction 保存的缩小状态。当它退出该表单时，它还会运行使用 unwind-protect 特殊表单建立的任何清理（请参阅从非本地出口清理）。

throw 不需要在它跳转到的 catch 中出现在词汇上。它同样可以从 catch 中调用的另一个函数中调用。只要投掷是在进入接球之后按时间顺序进行的，并且在退出接球之前按时间顺序进行，它就可以访问该接球。这就是为什么 throw 可以在诸如 exit-recursive-edit 之类的命令中使用，这些命令会返回到编辑器命令循环（请参阅递归编辑）。

Common Lisp 注意：大多数其他版本的 Lisp，包括 Common Lisp，都有几种非顺序转移控制的方法：例如，return、return-from 和 go。Emacs Lisp 只有 throw。cl-lib 库提供了其中一些版本。请参阅 Common Lisp 扩展中的块和退出。 

@lisp
Special Form: catch tag body… ¶
@end lisp

catch 为 throw 函数建立一个返回点。返回点通过标签与其他此类返回点区分开来，标签可以是除 nil 之外的任何 Lisp 对象。在建立返回点之前，通常会评估参数标记。

在返回点生效的情况下，catch 按文本顺序评估正文的形式。如果表单正常执行（没有错误或非本地退出），则从 catch 返回最后一个正文表单的值。

如果在body执行过程中执行了throw，指定了相同的value标签，catch表单立即退出；  它返回的值是指定为 throw 的第二个参数的值。 

@lisp
Function: throw tag value ¶
@end lisp
throw 的目的是从先前用 catch 建立的返回点返回。参数标签用于在现有的各种返回点中进行选择；  它必须等于 catch 中指定的值。如果多个返回点与标签匹配，则使用最里面的一个。

参数值用作从该捕获返回的值。

如果没有返回点对标签标签有效，则使用数据（标签值）发出未捕获错误信号。

@node 1172 示例 catch和 throw
@subsection 11.7.2 示例 catch和 throw

使用 catch 和 throw 的一种方法是退出双重嵌套循环。（在大多数语言中，这将通过 goto 完成。）这里我们计算 i 和 j 从 0 到 9 变化的 (foo ij)：
@lisp
(defun search-foo ()
  (catch 'loop
    (let ((i 0))
      (while (< i 10)
        (let ((j 0))
          (while (< j 10)
            (if (foo i j)
                (throw 'loop (list i j)))
            (setq j (1+ j))))
        (setq i (1+ i))))))
@end lisp

如果 foo 返回非 nil，我们立即停止并返回 i 和 j 的列表。如果 foo 总是返回 nil，则 catch 正常返回，并且值为 nil，因为这是 while 的结果。

这里有两个棘手的例子，略有不同，同时显示两个返回点。首先，两个相同标签的返回点，hack：
@lisp
(defun catch2 (tag)
  (catch tag
    (throw 'hack 'yes)))
⇒ catch2


(catch 'hack
  (print (catch2 'hack))
  'no)
-| yes
⇒ no
@end lisp

由于两个返回点都有与投掷相匹配的标签，因此它转到内部的那个，即在 catch2 中建立的那个。因此，catch2 正常返回值为 yes，并打印该值。最后，外部捕获中的第二个主体形式，即 @code{否} ，被评估并从外部捕获返回。

现在让我们更改给 catch2 的参数：
@lisp
(catch 'hack
  (print (catch2 'quux))
  'no)
⇒ yes
@end lisp

我们仍然有两个返回点，但这次只有外面的一个有标签 hack；  内部的有标签 quux 。因此， throw 使外部 catch 返回值 yes。函数 print 永远不会被调用，并且 body-form 'no 永远不会被评估。

@node 1173 错误
@subsection 11.7.3 错误

当 Emacs Lisp 尝试评估由于某种原因无法评估的表单时，它会发出错误信号。

当发出错误信号时，Emacs 的默认反应是打印错误消息并终止当前命令的执行。在大多数情况下，这是正确的做法，例如在缓冲区末尾键入 Cf。

在复杂的程序中，简单的终止可能不是您想要的。例如，程序可能对数据结构进行了临时更改，或者创建了应在程序完成之前删除的临时缓冲区。在这种情况下，您将使用 unwind-protect 建立清理表达式以在出现错误时进行评估。（请参阅从非本地退出中清除。）有时，您可能希望程序继续执行，尽管子例程中有错误。在这些情况下，您将使用条件案例来建立错误处理程序以在发生错误时恢复控制。

抵制使用错误处理将控制从程序的一部分转移到另一部分的诱惑；  使用 catch 和 throw 代替。请参阅显式非本地退出：catch and throw。

@enumerate
@item
11.7.3.1 如何发出错误信号


发出错误信号意味着开始错误处理。错误处理通常会中止所有或部分正在运行的程序并返回到为处理错误而设置的点（请参阅 Emacs 如何处理错误）。在这里，我们描述了如何发出错误信号。

大多数错误都会在您为其他目的调用的 Lisp 原语中自动发出信号，例如，如果您尝试获取整数的 CAR 或在缓冲区末尾向前移动一个字符。您还可以使用函数 error 和 signal 显式地发出错误信号。

当用户键入 Cg 时发生的退出不被视为错误，但它几乎像错误一样被处理。请参阅退出。

每个错误都以一种或另一种方式指定错误消息。消息应该说明出了什么问题（ @code{文件不存在} ），而不是事情应该如何（ @code{文件必须存在} ）。Emacs Lisp 中的约定是错误消息应该以大写字母开头，但不应以任何标点符号结尾。

@lisp
Function: error format-string &rest args ¶
@end lisp

此函数通过将 format-message（请参阅格式化字符串）应用于 format-string 和 args 构造的错误消息发出错误信号。

这些示例显示了错误的典型用法：
@lisp
(error "That is an error -- try something else")
     error→ That is an error -- try something else


(error "Invalid name `%s'" "A%%B")
     error→ Invalid name ‘A%%B’
@end lisp

error 通过使用两个参数调用信号来工作：错误符号 error 和包含由 format-message 返回的字符串的列表。

通常，格式中的重音和撇号会转换为匹配的弯引号，例如， @code{Missing `%s'} 可能会导致 @code{Missing 'foo'} 。有关如何影响或禁止此翻译的信息，请参阅文本引用样式。

警告：如果您想将自己的字符串逐字用作错误消息，请不要只写（错误字符串）。如果字符串 string 包含 '%'、'`' 或 ''' 它可能会被重新格式化，从而产生不希望的结果。而是使用（错误 @code{%s} 字符串）。 

@lisp
Function: signal error-symbol data ¶
@end lisp

此函数表示一个由错误符号命名的错误。参数 data 是与错误情况相关的附加 Lisp 对象的列表。

参数error-symbol 必须是一个错误符号——一个用define-error 定义的符号。这就是 Emacs Lisp 对不同类型错误进行分类的方式。有关错误符号、错误条件和条件名称的说明，请参阅错误符号和条件名称。

如果错误没有被处理，这两个参数用于打印错误信息。通常，此错误消息由 error-symbol 的 error-message 属性提供。如果 data 不为零，则后面是冒号和逗号分隔的未计算数据元素的列表。对于错误，错误消息是数据的 CAR（必须是字符串）。文件错误的子类别经过特殊处理。

数据中对象的数量和重要性取决于错误符号。例如，对于错误类型参数错误，列表中应该有两个对象：一个描述预期类型的​​谓词，以及一个不适合该类型的对象。

处理错误的任何错误处理程序都可以使用错误符号和数据：条件案例将局部变量绑定到表单列表 (error-symbol .data)（请参阅编写代码以处理错误）。

函数信号永远不会返回。
@lisp
(signal 'wrong-number-of-arguments '(x y))
     error→ Wrong number of arguments: x, y


(signal 'no-such-error '("My unknown error condition"))
     error→ peculiar error: "My unknown error condition"
@end lisp

@lisp
Function: user-error format-string &rest args ¶
@end lisp

此函数的行为与 error 完全相同，只是它使用错误符号 user-error 而不是 error。顾名思义，这是为了报告用户的错误，而不是代码本身的错误。例如，如果您尝试使用命令 Info-history-back (l) 移回您的 Info 浏览历史记录的开头，Emacs 会发出用户错误信号。此类错误不会导致进入调试器，即使 debug-on-error 不为零。请参阅出现错误时进入调试器。 

Common Lisp 注意：Emacs Lisp 与 Common Lisp 的可连续错误概念完全不同。

@item
11.7.3.2 Emacs 如何处理错误


当发出错误信号时，信号会搜索错误的活动处理程序。处理程序是一系列 Lisp 表达式，指定在 Lisp 程序的一部分发生错误时执行。如果错误具有适用的处理程序，则执行处理程序，并且控制继续跟随处理程序。处理程序在建立它的条件案例的环境中执行；  在该条件案例中调用的所有函数都已退出，处理程序无法返回它们。

如果没有适用的错误处理程序，它将终止当前命令并将控制权返回给编辑器命令循环。（命令循环对所有类型的错误都有一个隐式处理程序。）命令循环的处理程序使用错误符号和相关数据来打印错误消息。您可以使用变量 command-error-function 来控制如何完成：

@lisp
Variable: command-error-function ¶
@end lisp

这个变量，如果非 nil，指定一个函数用来处理返回控制给 Emacs 命令循环的错误。该函数应该接受三个参数：数据，一个与条件案例绑定到其变量的形式相同的列表；  context，一个描述错误发生情况的字符串，或者（更常见的）nil；  和调用者，Lisp 函数调用发出错误信号的原语。 

没有显式处理程序的错误可能会调用 Lisp 调试器。如果变量 debug-on-error（请参阅在出现错误时进入调试器）非零，则启用调试器。与错误处理程序不同，调试器在错误环境中运行，因此您可以准确地检查变量的值，就像它们在错误发生时一样。

@item
11.7.3.3 编写代码来处理错误


发出错误信号的通常效果是终止正在运行的命令并立即返回 Emacs 编辑器命令循环。您可以通过建立一个错误处理程序来安排捕获程序的一部分中发生的错误，使用特殊形式的条件案例。一个简单的示例如下所示：

@lisp
(condition-case nil
    (delete-file filename)
  (error nil))
@end lisp

这将删除名为 filename 的文件，捕获任何错误并在发生错误时返回 nil。（对于这样的简单情况，您可以使用宏忽略错误；见下文。）

condition-case 构造通常用于捕获可预测的错误，例如在调用 insert-file-contents 时无法打开文件。它还用于捕获完全不可预测的错误，例如当程序评估从用户读取的表达式时。

条件案例的第二个参数称为受保护形式。（在上面的示例中，受保护的表单是对 delete-file 的调用。）错误处理程序在此表单开始执行时生效，并在此表单返回时停用。它们在所有干预时间内都保持有效。特别是，它们在执行由这种形式调用的函数期间、在它们的子例程中等期间有效。这是一件好事，因为严格来说，错误只能由受保护形式调用的 Lisp 原语（包括信号和错误）发出信号，而不能由受保护形式本身发出。

受保护形式之后的参数是处理程序。每个处理程序列出一个或多个条件名称（它们是符号）以指定它将处理哪些错误。发出错误信号时指定的错误符号还定义了条件名称列表。如果它们有任何共同的条件名称，则处理程序适用于错误。在上面的例子中，有一个handler，它指定了一个条件名error，它涵盖了所有的错误。

搜索适用的处理程序会检查所有已建立的处理程序，从最近建立的处理程序开始。因此，如果两个嵌套的条件案例形式提供处理相同的错误，则两者的内部可以处理它。

如果错误是由某种条件案例形式处理的，这通常会阻止调试器运行，即使 debug-on-error 说这个错误应该调用调试器。

如果您希望能够调试由条件案例捕获的错误，请将变量 debug-on-signal 设置为非零值。您还可以通过在条件中编写 debug 来指定特定的处理程序应该让调试器首先运行，如下所示：

@lisp
(condition-case nil
    (delete-file filename)
  ((debug error) nil))
@end lisp


这里的 debug 的作用只是防止 condition-case 抑制对调试器的调用。任何给定的错误只有在 debug-on-error 和其他常用过滤机制认为应该调用时才会调用调试器。请参阅出现错误时进入调试器。

@lisp
Macro: condition-case-unless-debug var protected-form handlers… ¶
@end lisp

宏 condition-case-unless-debug 提供了另一种处理此类表单调试的方法。它的行为与条件情况完全相同，除非变量 debug-on-error 不为零，在这种情况下，它根本不处理任何错误。 

一旦 Emacs 决定某个处理程序处理错误，它就会将控制权返回给该处理程序。为此，Emacs 取消绑定由正在退出的绑定构造所做的所有变量绑定，并执行对正在退出的所有 unwind-protect 表单的清理。一旦控制到达处理程序，处理程序的主体就会正常执行。

处理程序主体执行后，执行从条件案例形式返回。因为受保护的表单在处理程序执行之前完全退出，所以处理程序不能在错误点恢复执行，也不能检查在受保护的表单中进行的变量绑定。它所能做的就是清理并继续。

错误信号和处理与 throw 和 catch 有一些相似之处（请参阅显式非本地退出：catch 和 throw），但它们是完全独立的工具。错误不能被 catch 捕获，并且 throw 不能由错误处理程序处理（尽管在没有合适的 catch 时使用 throw 表示可以处理的错误）。

@lisp
Special Form: condition-case var protected-form handlers… ¶
@end lisp

这种特殊形式围绕受保护形式的执行建立错误处理程序处理程序。如果 protected-form 执行没有错误，它返回的值将成为条件案例形式的值（在没有成功处理程序的情况下；见下文）。在这种情况下，条件案例无效。当在受保护形式期间发生错误时，条件案例形式会有所不同。

每个处理程序都是表单（条件体@dots{}）的列表。这里的 conditions 是要处理的错误条件名称，或条件名称列表（可以包括 debug 以允许调试器在处理程序之前运行）。条件名称 t 匹配任何条件。body 是这个处理程序处理错误时要执行的一个或多个 Lisp 表达式。以下是处理程序的示例：
@lisp
(error nil)

(arith-error (message "Division by zero"))

((arith-error file-error)
 (message
  "Either division by zero or failure to open a file"))
@end lisp

发生的每个错误都有一个错误符号来描述它是什么类型的错误，并且还描述了一个条件名称列表（请参阅错误符号和条件名称）。Emacs 在所有活动的条件案例形式中搜索指定一个或多个条件名称的处理程序；  最里面的匹配条件案例处理错误。在这种情况下，第一个适用的处理程序处理错误。

执行处理程序主体后，条件案例正常返回，使用处理程序主体中最后一个表单的值作为整体值。

参数 var 是一个变量。condition-case 在执行 protected-form 时不绑定此变量，仅在它处理错误时。那时，它将 var 本地绑定到错误描述，这是一个给出错误细节的列表。错误描述的形式为 (error-symbol . data)。处理程序可以参考这个列表来决定做什么。例如，如果错误是因为打开文件失败，则文件名是数据的第二个元素——错误描述的第三个元素。

如果 var 为 nil，则表示没有绑定任何变量。然后错误符号和相关数据对处理程序不可用。

作为一种特殊情况，其中一个处理程序可以是表单 (:success body@dots{}) 的列表，其中执行 body 时，当该表达式无错误终止时，绑定到 protected-form 的返回值的 var（如果非 nil） .

有时有必要重新抛出一个被条件案例捕获的信号，以便某些外层处理程序捕获。以下是如何做到这一点：

@lisp
(signal (car err) (cdr err))
@end lisp

其中 err 是错误描述变量，是要重新抛出其错误条件的 condition-case 的第一个参数。见信号定义。 

@lisp
Function: error-message-string error-descriptor ¶
@end lisp

此函数返回给定错误描述符的错误消息字符串。如果您想通过打印该错误的通常错误消息来处理错误，这很有用。见信号定义。 

这是使用条件案例处理除以零导致的错误的示例。处理程序显示错误消息（但没有哔声），然后返回一个非常大的数字。

@lisp
(defun safe-divide (dividend divisor)
  (condition-case err
      ;; Protected form.
      (/ dividend divisor)

    ;; The handler.
    (arith-error                        ; Condition.
     ;; Display the usual message for this error.
     (message "%s" (error-message-string err))
     1000000)))
⇒ safe-divide


(safe-divide 5 0)
     -| Arithmetic error: (arith-error)
⇒ 1000000
@end lisp

处理程序指定条件名称 arith-error 以便它只处理除零错误。其他类型的错误将不会被处理（通过这种情况）。因此：

@lisp
(safe-divide nil 3)
     error→ Wrong type argument: number-or-marker-p, nil
@end lisp


这是一个捕获各种错误的条件案例，包括来自错误的错误：
@lisp
(setq baz 34)
     ⇒ 34


(condition-case err
    (if (eq baz 35)
        t
      ;; This is a call to the function error.
      (error "Rats!  The variable %s was %s, not 35" 'baz baz))
  ;; This is the handler; it is not a form.
  (error (princ (format "The error was: %s" err))
         2))
-| The error was: (error "Rats!  The variable baz was 34, not 35")
⇒ 2
@end lisp



@lisp
Macro: ignore-errors body… ¶
@end lisp

此构造执行主体，忽略执行期间发生的任何错误。如果执行没有错误，则ignore-errors返回body中最后一个表单的值；  否则，它返回 nil。

这是本小节开头使用忽略错误重写的示例：

@lisp
(ignore-errors
 (delete-file filename))
@end lisp


@lisp
Macro: ignore-error condition body… ¶
@end lisp

此宏类似于忽略错误，但只会忽略指定的特定错误条件。

@lisp
(ignore-error end-of-file
   (read ""))
@end lisp
condition 也可以是错误条件列表。 

@lisp
Macro: with-demoted-errors format body… ¶
@end lisp

这个宏就像是忽略错误的温和版本。它不是完全抑制错误，而是将它们转换为消息。它使用字符串格式来格式化消息。格式应包含单个 '%' 序列；  例如， @code{错误：%S} 。使用 with-demoted-errors 来处理预期不会发出错误信号的代码，但如果确实发生错误，应该是健壮的。请注意，此宏使用 condition-case-unless-debug 而不是 condition-case。

@item
11.7.3.4 错误符号和条件名称


当您发出错误信号时，您指定一个错误符号来指定您想到的错误类型。每个错误都有一个且只有一个错误符号来对其进行分类。这是 Emacs Lisp 语言定义的最好的错误分类。

这些狭窄的分类被分组为更广泛的类的层次结构，称为错误条件，由条件名称标识。最窄的此类属于错误符号本身：每个错误符号也是一个条件名称。还有更广泛的类的条件名称，直到条件名称错误，它接受各种错误（但不退出）。因此，每个错误都有一个或多个条件名称：错误、与错误不同的错误符号，可能还有一些中间分类。

@lisp
Function: define-error name message &optional parent ¶
@end lisp

为了使符号成为错误符号，必须使用 define-error 定义它，它采用父条件（默认为错误）。这个父级定义了这种错误所属的条件。父母的传递集总是包括错误符号本身和符号错误。因为退出不被认为是一个错误，所以退出的父集合就是（退出）。 

除了其父项之外，错误符号还有一条消息，该消息是在发出错误信号但未处理时要打印的字符串。如果该消息无效，则使用错误消息 @code{特殊错误} 。见信号定义。

在内部，父集合存储在错误符号的错误条件属性中，消息存储在错误符号的错误消息属性中。

下面是我们如何定义一个新的错误符号 new-error：

@lisp
(define-error 'new-error "A new error" 'my-own-errors)
@end lisp


这个错误有几个条件名称：new-error，最窄的分类；  我自己的错误，我们认为这是一个更广泛的分类；  以及我自己的错误的所有条件，其中应该包括错误，这是最广泛的。

错误字符串应以大写字母开头，但不应以句点结尾。这是为了与 Emacs 的其余部分保持一致。

自然，Emacs 永远不会自己发出新错误信号。只有在代码中显式调用信号（参见信号定义）才能执行此操作：

@lisp
(signal 'new-error '(x y))
     error→ A new error: x, y
@end lisp


可以通过其任何条件名称来处理此错误。此示例处理 my-own-errors 类中的 new-error 和任何其他错误：

@lisp
(condition-case foo
    (bar nil t)
  (my-own-errors nil))
@end lisp

错误分类的重要方式是通过它们的条件名称——用于将错误与处理程序匹配的名称。错误符号仅用作指定预期错误消息和条件名称列表的便捷方式。给 signal 提供一个条件名称列表而不是一个错误符号会很麻烦。

相比之下，仅使用没有条件名称的错误符号会严重降低条件案例的能力。当您编写错误处理程序时，条件名称可以在各种通用级别上对错误进行分类。单独使用错误符号将消除除最窄级别之外的所有分类。

有关主要错误符号及其条件的列表，请参阅标准错误。
@end enumerate

@node 1174 清理非本地出口
@subsection 11.7.4 清理非本地出口

每当您临时将数据结构置于不一致状态时，unwind-protect 构造都是必不可少的。它允许您在发生错误或抛出时再次使数据保持一致。（另一个仅用于更改缓冲区内容的更具体的清理结构是原子更改组；原子更改组。）

@lisp
Special Form: unwind-protect body-form cleanup-forms… ¶
@end lisp

unwind-protect 执行 body-form 并保证在控制离开 body-form 时将评估清理表单，无论这种情况如何发生。body-form 可以正常完成，或者执行一个 throw out of the unwind-protect，或者导致错误；  在所有情况下，都会评估清理表单。

如果 body-form 正常完成，unwind-protect 在评估 cleanup-forms 后返回 body-form 的值。如果 body-form 没有完成， unwind-protect 不会返回任何正常意义上的值。

只有身体形态受 unwind-protect 保护。如果任何清理表单本身非本地退出（通过抛出或错误），则不能保证 unwind-protect 评估其余的。如果其中一个清理表单的故障有可能造成麻烦，则在该表单周围使用另一个展开保护来保护它。

当前活动的展开保护表单的数量与局部变量绑定的数量一起根据 max-specpdl-size 限制进行计数（请参阅局部变量）。 

例如，这里我们制作了一个不可见的缓冲区以供临时使用，并确保在完成之前将其杀死：

@lisp
(let ((buffer (get-buffer-create " *temp*")))
  (with-current-buffer buffer
    (unwind-protect
        body-form
      (kill-buffer buffer))))
@end lisp

你可能认为我们也可以写 (kill-buffer (current-buffer)) 并省去变量缓冲区。但是，如果 body-form 在切换到不同的缓冲区后发生错误，上面显示的方式更安全！  （或者，您可以在 body-form 周围编写一个 save-current-buffer，以确保临时缓冲区及时再次变为当前缓冲区以杀死它。）

Emacs 包含一个名为 with-temp-buffer 的标准宏，它或多或少地扩展为上面显示的代码（请参阅当前缓冲区）。本手册中定义的几个宏以这种方式使用 unwind-protect。

这是一个从 FTP 包派生的实际示例。它创建一个进程（参见进程）来尝试建立与远程机器的连接。由于函数 ftp-login 极易受到函数编写者无法预料的许多问题的影响，因此它受到一种形式的保护，该形式保证在发生故障时删除进程。否则，Emacs 可能会充满无用的子进程。
@lisp
(let ((win nil))
  (unwind-protect
      (progn
        (setq process (ftp-setup-buffer host file))
        (if (setq win (ftp-login process host user password))
            (message "Logged in")
          (error "Ftp login failed")))
    (or win (and process (delete-process process)))))
@end lisp

这个例子有一个小bug：如果用户键入Cg 退出，并且在函数ftp-setup-buffer 返回之后但在变量process 设置之前立即退出，该进程不会被杀死。修复此错误没有简单的方法，但至少不太可能。

@bye