GNU Emacs Lisp Manual 学习笔记

它的范围取决于机器。最小的范围是 -536,870,912 ~ 536,870,911 (30 bits ，例如 : -2²⁹ ~ 2²⁹-1) ，但一些机器提供更大的范围。Emacs Lisp 算术 function 并不会检测一个 integer 是否 overflow 的。因此 (1+ 536870911) 的结果是 -536,870,912 ，如果 Emacs 的 integer 是 30bits 的话。

它的 read syntax 是一个数字 sequence （10进制），可带有一个可选的在开头的符号（正负）以及一个可选的在结尾的 period 。 它的 printed representation , 由 Lisp interpreter 产生的， 是不会带有 '+' 或 结尾的 '.' 的。

-1               ; The integer -1.
1                ; The integer 1.
1.               ; Also the integer 1.
+1               ; Also the integer 1.

作为一个特殊的例外，如果一个 integer 的数字 sequence 是太大或太小，以及是一个 invalid 的 integer object ，则 Lisp reader 会将它读取为一个 floating-point number 。例如，如果 Emacs integer 是 30bits 的话，则 536870912 会读取为一个 floating-point number 536870912.0

它等同于计算机中的 scientific notation ，你可以想象 floating-point number 是一个分数与一个以10为底数一起的。精度以及指数的范围是依赖于机器的，Emacs 使用 C 语言中的 double 来保存该 value ，并且内部是使用以2为底数而不是以10为底数的。

它的 printed representation 要求是要有一个浮点（并且至少要带有一位小数），或者指数，或者两者都有。例如

    ‘1500.0’, ‘+15e2’, ‘15.0e+2’, ‘+1500000e-3’, and ‘.15e4’

Emacs Lisp 中， character 只是一个 integer 。换句话说， character 是用它们的 character code 来表示的。例如 character A 是用 integer 65 来表示的。 单独的 character 只是偶尔在程序中使用，更多的是使用 strings ，它是由 character 组成的 sequence 。

在 strings 和 buffers 中的 characters code 的当前限制的范围是 0 ~ 4194303 . Code 0 ~ 127 是 ASCII code ，其余的是非 ASCII 。

在 GNU Emacs Lisp 中，一个 symbol 就是一个带有 name 的 object 。symbol name 作为它的 printed representation 。一个 symbol 的 name 是唯一的，没有两个 symbol 会有相同的 name 。

一个 symbol 可以作为 variable 或 function 的 name ，或者拥有一个 property list 。或者它仅作为区分其他所有 Lisp objects ，以便它在数据结构中可以容易识别出来。在一个给定的 Context 中，仅会使用这些中的一个意思。但是，你可以用 symbol 独立地来处理这所有的方式。

一个以 colon (':') 开头的 symbol name 称为 keyword symbol 。这些 symbol 自动地表现为 constants ，并且通常下仅用几个具体的选项来与一个 unknown symbol 来进行比较。一个 symbol name 可以包含任何字符。绝大部分情况下，使用 letters, digits 和 punctuation charater '-+=*/' 来进行书写。这些 names 的要求是没有特殊的 punctuation ； name 的 charater 要足够长以便让它看起来不像是一个 number 即可 (如果还像 number 的话，那就 name 前面加上一个 \ 来强制解释为 symbol) 。 _~!@$%^&:<>{}? 这些 charater 虽然比较少使用，但也要求是没有特殊的 punctuation 。

其他的 charater 要用在 symbol name 的话，则需要进行 escape 。

下面是一些例子：

foo                 ; A symbol named ‘foo’.
FOO                 ; A symbol named ‘FOO’, different from ‘foo’.
1+                  ; A symbol named ‘1+’
                                        ;   (not ‘+1’, which is an integer).
\+1                 ; A symbol named ‘+1’
                                        ;   (not a very readable name).
\(*\ 1\ 2\)         ; A symbol named ‘(* 1 2)’ (a worse name).
+-*/_~!@$%^&=:<>{}  ; A symbol named ‘+-*/_~!@$%^&=:<>{}’.
                                        ;   These characters need not be escaped.

一个 sequence 表示一个带有元素顺序的 set 的 Lisp object 。在 Emacs Lisp 中有两种:

1. lists
2. arrays

Lists 是最常用的 sequence 。一个 list 可以拥有任意 type 的 elements ，它的 length 可以容易地通过添加或移除 elements 来改变。

Arrays 是一个 fixed-length 的 sequences 。它进一步分为：

1. strings ，它的 elements 必须为 characters 。这些 characters 可以有 text properties ，就像在 buffer 中的 characters 一样。
2. vectors , 它的 elements 可以是任意的 type 。它不支持 text properties ，即使它的 elements 是 characters 。
3. char-tables ，与 vectors 类似，但它是通过任意有效的 character code 来索引的。
4. bool-vectors ，它的 elements 必须是 t 或 nil

Lists, strings 和其他 array type 都有相似性。例如，它们都有一个 length / ，并且所有的 elements 都是从 0 到 /-1 的索引 。

通常，同一个 sequences 是不可能读取两次的，因为 sequences 总是在读取时创建一个新的。如果你读取 sequences 的 read syntax 两次的话，你会获得两个拥有相同内容的 sequences 。有一个是例外的：空list () ，它总是表示同样的 obejct nil 。

一个 cons cell 是一个由2个 slots 组成的对象：

1. CAR slot
2. CDR slot

每一个 slot 可以持有任意的 Lisp object 。我们也可以这样说，这个 cons cell 的 CAR 是当前拥有的任何 object ，CDR 同样也如此。

一个 list 是由一系列的 cons cell 链接在一起的，使得每个 cons cell 的 CDR slot 持有下一个 cons cell 或是一个空 list 。一个空 list 实际上是 symbol nil 。由于绝大多数的 cons cell 是用作 list 的部分，我们指那些由 cons cell 组成的结构称为 list 结构 。

C 语言程序员注意： 一个 Lisp list 因此表现得像由 cons cell 为节点的 linked list 。因为 pointer 在 Lisp 中是隐式的，我们不区分一个 cons cell 是持有一个 value ，还是 point to 这个 value

由于 cons cell 是 Lisp 的核心，我们为这些 object 有另一个单词而不是 cons cell 来称呼它，称为 atoms

list 的 read syntax 和 printed representation 是相同的：由一个左括号，一个任意数是的 elements ，以及一个右括号组成。例如:

(A 2 "A")            ; A list of three elements.
()                   ; A list of no elements (the empty list).
nil                  ; A list of no elements (the empty list).
("A ()")             ; A list of one element: the string "A ()".
(A ())               ; A list of two elements: A and the empty list.
(A nil)              ; Equivalent to the previous.
((A B C))            ; A list of one element
                                        ;   (which is a list of three elements).

在括号中的每一个 object ，都会成为 list 的 element 。也就是说，是一个 cons cell 组成了每个 element 。*cons cell* 的 CAR slot 持有 element ，并且它的 CDR slot 指向 list 中的下一个 cons cell element 。最后一个 cons cell 的 CDR 是设置为 nil 。

CAR 和 CDR 的名字，是从 Lisp 的历史中获得的。原始的 Lisp 实现运行在一台 IBM 704 计算机上的，它将 words 分成两部分： address 和 decrement 。 CAR 是一个从 register 保存的 address 指示的地方获取内容的指令； CDR 是一个获取剩余内容的指令。

参考上面的 sequences type

在 Lisp 中， evaluate 一个 string 会返回它自身。

它是一个可包含任意 type 的一维 array 。在 vector 中，访问任意一个 element 的时间一样的（在 list 中，则时间并不一样，最开始的 element 耗时短）

它的 printed representation 是由： 一个左边的 square bracket ， elements 和一个右边的 square bracket 。这也是它的 read syntax 。例如:

[1 "two" (three)]      ; A vector of three elements.
 ⇒ [1 "two" (three)]

它是一个一维 array ，可包含任意 type 的 elements ，通过 character code 来进行 index 。 它的 printed representation 像 vector 一样，除了它有一个额外的 #^ 开头。

它也是一个一维 array ，elements 必须是 t 或 nil

bool-vector 实际指定的内容是在 string constant 用 bitmap 表示的。在 string 中的每个 character 包含 8bits ，它指示了 bool-vector 的之后的 8 个 elements （1 代表 t ，0 代表 *nil*国）.

它的 printed representation 像一个 string ，除它了是以 #& 开头，且后面接着它的 length 。

(make-bool-vector 3 t)
⇒ #&3"^G"
(make-bool-vector 3 nil)
⇒ #&3"^@"

因为它是三个 t 即是： 111 ，所以，它显示为 C-g （C-g 的 Code 就是 111）。下面的同理。

它是一个非常快的查找表，与 alist 相似，但是它更快。它的 printed representation 是 properties 和 contents 。比如这样：

(make-hash-table)
 ⇒ #s(hash-table size 65 test eql rehash-size 1.5
                         rehash-threshold 0.8 data ())

它是 executable code ，就像其他语言中的 function 一样。在 Lisp 中，不同于大多数其他语言， function 也是 Lisp Object 。一个 non-compiled 的 function 是一个 lambda expression ，也就是说，它的第一个 element 是 symbol lambda 。

在大多数语言中，一个 function 是不能没有 name 的。在 Lisp 中，一个 function 没有真正的 name 。一个 lambda expression 可以作为 function 来调用，即使它没有 name ；为了强调这点，我们也称它为 anonymous function 。一个 带有 name 的 function 仅是一个带有有效 function 的 symbol 。

大部分的时候，在 Lisp 程序中，是用它们的 name 来调用的。然而，你也可以构建或在 run time 获取一个 function 然后通过 primitive function funcall 和 apply 来调用它。

一个 Lisp macro 是 user-defined 的结构，用来扩展 Lisp language 的。它的表现与 function 很相似，但是有不同的 argument-passing 。一个 Lisp macro 的 form 是一个 list ，它的第一个 element 是 symbol macro 以及 CDR 部分是一个 lisp function object ，包括 lambda symbol 。

Lisp macro 通过用内建的 defmacro 来定义。

注意，Lisp macro 和 keyboard macros 是完全不同的两个东西。当我们使用 macro 时，如果没有特别说明，是指 Lisp macro ，而不是 keyboard macro

一个 primitive function 是一个可以从 Lisp 调用的 function， 但是它是用 C 语言写的。它也称为 subrs 或 build-in functions 。( subr 源于 subroutine ）

大部分的 primitive function 当它们被调用时，会将它的们 arguments 全进行 evaluate 。一个没有将它们的 arguments 全进行 evaluate 的，称为 special form 。

对于 caller ，调用一个 function 不需要关心它是否是一个 primitive function 。但是，如果你试图用 Lisp 来重新定义一个 primitive function 时，这就需要关心了。因为 primitive function 可能从 C 代码中直接调用。 用 Lisp 重定义的 function 在调用时会使用重定义后的 function ，但从 C 代码中调用的，仍会使用 build-in 定义的。因此，我们不鼓励重定义 primitive function

术语 functions 是指所有的 Emacs functions ，不管它是用 Lisp 还是 C 写的。

它没有 read syntax ，并且它是用 带有 subroutine name 的 hash notation 来 print 的。如:

(symbol-function 'car)          ; Access the function cell
                                        ;   of the symbol.
⇒ #<subr car>
(subrp (symbol-function 'car))  ; Is this a primitive function?
⇒ t                       ; Yes.

Byte-Code Function objects 是由 byte-compiling 后的 Lisp code 生成的。在内部，一个 byte-code function 与 vector 很像；然而，*evaluator* 在 function call 时会特别处理这种 data type。

它的 printed representation 和 read syntax 类似 vector ，但在 [ 前面有个额外的 # 。

它是一个 list ，但它的第一个 element 是 symbol autoload 。它保存了 symbol 的 function definition ，作为一个 real definition 的 placeholder 。一个 autoload object 是说，*real definition* 当需要的时候，从一个带有 Lisp code 的文件中进行 load 。它包含了文件的 name 和一些关于 real definition 的其他信息。

当该文件已经 loaded 的时候，该 symbol 就有了一个新的 function definition ，并且不再是一个 autoload object 了。

一个 finalizer object 在不再需要这些对象的时候帮助 Lisp code 来清理它们。一个 finalizer 持有一个 Lisp function 。当一个 finalizer object 在 garbage collection 进行后， 变成 unreadable ，Emacs 就会调用它相关的 function 了。该 function 在每个 finalizer object 中仅会执行一次。

一个 buffer 是一个持有可被编辑的文本的 object 。大部分的 buffer 是持有 disk 文件的内容的，但也有一些 buffer 是用作其他目的的。大部分的 buffer 也是对用户可见的，但也有一些是不可见的。 它没有 read syntax 。它的 printed representation 是用 hash notation ：

(current-buffer)
 ⇒ #<buffer objects.texi>

一个 marker 是批一个特定的 buffer 中的一个 position . 因此 ，它有两部分：一部分是指一个 buffer ，另一部分是指一个 position 。 它没有 read syntax 。它的 printed representation 是用 hash notation ，给出当前 charater 的 position 以及 buffer 的name 。

(point-marker)
 ⇒ #<marker at 10779 in objects.texi>

一个 windows 是 Emacs 用来显示一个 buffer 的 terminal screen 的一部分。每一个 window 都有一个与之相关的 buffer ，它的内容就出现在 window 中。相比之下，一个给定的 buffer ，可能出现在一个 window ，或没有 window 或在好几个 window 中。

虽然可以同时存在好个 window ，但在同一时间，只有一个 window 是 selected window ，即 cursor 出现所在的 window 。它对应的 buffer ，也就称为 curent-buffer 。

在screen 中 Window 分组为 frame 。每一个 window 仅属于一个 frame 。

它没有 read syntax 。它的 printed representation 是用 hash notation ，给出 window number ，以及显示的 buffer 的name。比如:

(selected-window)
 ⇒ #<window 1 on objects.texi>

一个 frame 是包含一个或多个 Emacs window 的 screen area 。

它没有 read syntax 。它的 printed representation 是用 hash notation ，给出了 frame 的 title ，加上它的 address 。（用于唯一地标识一个 frame）。如:

(selected-frame)
 ⇒ #<frame emacs@psilocin.gnu.org 0xdac80>

一个 terminal ，可以显示一个或多个 Emacs frame 。 它没有 read syntax 。它的 printed representation 是给出 terminal 的序号以及它的 TTY 设置文件名。如:

(get-device-terminal nil)
 ⇒ #<terminal 1 on /dev/tty>

一个 window configuration 保存了在一个 frame 中的 window 的 position, size 以及 content 的信息。 它没有 read syntax ，它的 printed representation 看起来像 #<window-configuration> .

一个 frame configuration 保存了在所有 frames 中的关于 window 的 position, size 和 content 的信息。它不是一个 primitive type ，实际是一个 list ，它的 CAR 是 frame-configuration ，CDR 是一个 alist 。

process 通常意味着 running program 。Emacs 自身在这种类型中执行的。然而，在 Emacs Lisp 中，一个 process 是一个 Lisp object ，是设计用来通过 Emacs process 来创建一个 subprocess 的。例如 shell, GDB 和 compiler 这些程序，在 Emacs 中是执行在 subprocesses 中的。它没有 read syntax ，它的 printed representation 是:

(process-list)
 ⇒ (#<process shell>)

一个 stream 是一个可用作 character source 的 object 。一些不同的 type 可以使用这种方式： markers, buffers, strings, 和 functions 。 nil object ，除了其他含义，也可作用 stream 。它表示 standard-input 或 standard-output 的 value 。 t 也可以作为用在 minibuffer 或 echo area 的 input stream 。

它没有 read syntax ，它的 printed representation 是与它的 primitive type 是什么就会显示为什么。

一个 keymap 是映射 key type 为用户指定的 commands 。它实际上是一个 list ，它的 CAR 是 symbol keymap 。

一个 overlay 是应用到一部分的 buffer 的 specifies properties 。用于临时用一个不同的显示风格来显示buffer中的一部分。

一个 font 指示了在一个 Graphical terminal 中如何显示文本。实际上有三种不同的 font types:

1. font objects
2. font specs
3. font entities

每一种都有稍微不同的 properties 。它们都没有 read syntax 。它们的 printed representation 分别为 :

#<font-object> 
#<font-spec> 
#<font-entity>

即除了 list 和 symbol 外的 form 。 Self-evaluating evaluate 为它自身，即它们进行 evaluate 之后，还是它们自身。因此， number 25 evaluate 为 25 ；string "foo" evaluate 之后还是 "foo" 。同样， evaluate 一个 vector 并不会导致将 vector 的 element 进行 evaluate ，它返回的是 vector 自身并且内容不变。

• numbers
• characters
• strings
• vectors

都属于此类。

当一个 symbol 进行 evaluate 时，它被视为一个 variable 。它的结果就是 variable 的 value ，如果有的话。如果 symbol 并没有作为 variable 的 value 的话，Lisp 解析器会产生一个错误。例如:

(setq a 123)
⇒ 123
(eval 'a)
⇒ 123
a
⇒ 123

symbol 中的 nil 和 t 是特殊对待的， nil 的 value 永远是 nil ， t 的 value 永远是 t ，并且你不能设置或绑定其他 value 给它们。

一些以 : 开头的 symbol 也是 self-evaluate 的， 同样地，它的 value 通常也是不能更改的。

一个 form 如果它是非空的 list ，则会根据它的第一个 element 来判断它是否是一个 function call ， 或 macro call 或 special form 。这三种类型的 form 是用不同的方式来进行 evaluate 。剩下的 list 元素组成这三种类型的 arguments 。

在一个非空的 list 中，evaluating 的第一步就是检测它的第一个 element 。这个 element 决定了该 form 是什么类型，以及list中剩下的元素将如何处理。 不过，在一些 Lisp dialects 中，第一个元素并不会被 evaluated ，比如 Scheme 。

如果 list 中的第一个 element 是一个 symbol ，然后 evaluation 测试该 symbol 的 function cell ，并使用它的内容来代替原始的 symbol 。如果它的内容是其他的 symbol ，这种处理，就称为 symbol function indirection ，它会一直这样子重复处理，直到包含一个非 symbol 。

如果 list 中的第一个 element 是一个 Lisp function object 或 byte-code object 或 primitive function object ，这种 list 就称为一个 function call 。例如

(+ 1 x)

evaluate 一个 function call 的第一步就是从左到右地进行 evaluate 这个 list 中的剩余的元素。结果就是 argument 的实际 value ，每一个 element 对应一个 value 。下一步就是将这些 argument 的value 进行 function call 。

如果准备进行 evaluated 的 list 的第一个 element 是一个 macro object ，则这个 list 就是一个 macro call 。 当它进行 evaluating 时，剩下的 list elements 并不会初始化地 evaluate 。相反，这些 elements 自身是作为这个 macro 的 arguments 。 macro 的定义计算出一个代替的 form ，称为 macro 的 expression， 被 evaluated 后就会替代原来的 form 。这个 expansion 可能是以下的 form ：一个 self-evaluating 常量，一个 symbol， 或一个 list 。如果该 expansion 自身还是一个 macro call ，则进行递归处理，直到结果是其他形式的 form 。

一个 special form 是一个特别标识的 primitive function ，它的 arguments 并不会进行 evaluated 。绝大部分的 special form 定义控制结构或执行 variable bindings —— 这些是 function 做不到的。 如果一个 expression 的第一个 symbol 是一个 special form ，则该 expression 应该遵循这个 special form 的规则，否则， Emacs 的行为是未定义的（尽管它不会崩溃）。例如 ((lambda (x) x . 3) 4) 是一个以 lambda 开头的但并不是 well-formed 的 lambda expression ，所以 Emacs 可能会产生一个错误信息，或者返回 或 4 或 nil ，又或者是其他方式的行为。

autoload 特性允许你调用一个还没有加载到 Emacs 的 function 或 macro 。它指出哪个文件包含它的定义。当一个 autoload object 作为一个 symbol 的 function definition ，作为 function 来调用这个 symbol 将会自动地加载所在的文件；然后从该文件中加载它真正要调用的 definition 。

(when condition a b c)

它等同于:

(if condition (progn a b c) nil)

(unless condition a b c)

它等同于:

(if condition nil
  a b c)