学习Emacs Lisp编程指南

需积分: 5 11 浏览量更新于2024-07-23 收藏 1023KB PDF 举报

"Introduction to Emacs Lisp" 本文档是针对非程序员的《Emacs Lisp编程入门》的修订第三版，由Robert J. Chassell撰写。它旨在帮助Emacs的用户了解和掌握Emacs Lisp（Elisp）的基础知识。Emacs Lisp是一种用于扩展和定制Emacs文本编辑器的内置编程语言。 Emacs Lisp的引入对那些不熟悉编程的人来说特别有价值，因为它允许用户自定义Emacs的几乎每一个方面，包括快捷键、编辑模式和工作流程。通过学习Elisp，用户可以创建自己的命令、宏和插件，从而根据个人需求定制编辑环境。 Emacs Lisp的特点包括： 1. **动态类型**：Elisp是一种动态类型的编程语言，变量的类型在运行时确定，无需提前声明。 2. **函数式编程**：Elisp支持函数式编程概念，如高阶函数和递归。 3. **面向对象编程**：虽然不是传统意义上的面向对象语言，但Elisp提供了对象和类的概念，允许实现面向对象的解决方案。 4. **交互式开发**：在Emacs环境中，用户可以直接测试和调试Elisp代码，快速迭代和优化。 5. **丰富的库**：Emacs内置了大量Elisp库，涵盖各种功能，如文件操作、网络通信和文本处理。 6. **自动缩进和语法高亮**：Emacs本身为Elisp代码提供了自动缩进和语法高亮，便于阅读和编写代码。文档的内容可能包括Elisp的基本语法，如变量、函数、条件语句、循环结构、列表操作以及错误处理。此外，它可能还涉及如何加载和调试Elisp代码，以及如何利用Emacs的内置工具进行开发。此版本的文档遵循GNU Free Documentation License v1.3或更高版本，这意味着任何人都可以自由地复制、分发和修改该文档，只要符合该许可证的条款。购买官方出版物可以支持自由软件基金会（FSF）的发展。通过学习和应用《Emacs Lisp编程入门》，用户不仅能提升在Emacs中的工作效率，还能深入理解编辑器的工作原理，并可能成为Emacs社区的贡献者，编写自己的插件和工具，为全球的Emacs用户共享。

4 Preface

Thank You

My thanks to all who helped me with this book. My especial thanks to

Jim Blandy, Noah Friedman, Jim Kingdon, Roland McGrath, Frank Ritter,

Randy Smith, Richard M. Stallman, and Melissa Weisshaus. My thanks also go

to both Philip Johnson and David Stampe for their patient encouragement. My

mistakes are my own.

Robert J. Chassell

bob@gnu.org

Section 1.1: Lisp Lists 1

1 List Processing

To the untutored eye, Lisp is a strange programming language. In Lisp code there

are parentheses everywhere. Some people even claim that the name stands for

‘Lots of Isolated Silly Parentheses’. But the claim is unwarranted. Lisp stands for

LISt Processing, and the programming language handles lists (and lists of lists) by

putting them between parentheses. The parentheses mark the boundaries of the

list. Sometimes a list is preceded by a single apostrophe or quotation mark, ‘’’

Lists are the basis of Lisp.

1.1 Lisp Lists

In Lisp, a list looks like this: ’(rose violet daisy buttercup). This list is pre-

ceded by a single apostrophe. It could just as well be written as follows, which looks

more like the kind of list you are likely to be familiar with:

’(rose

violet

daisy

buttercup)

The elements of this list are the names of the four diﬀerent ﬂowers, separated from

each other by whitespace and surrounded by parentheses, like ﬂowers in a ﬁeld with

a stone wall around them.

Lists can also have numbers in them, as in this list: (+ 2 2). This list has a

plus-sign, ‘+’, followed by two ‘2’s, each separated by whitespace.

In Lisp, both data and programs are represented the same way; that is, they are

both lists of words, numbers, or other lists, separated by whitespace and surrounded

by parentheses. (Since a program looks like data, one program may easily serve

as data for another; this is a very powerful feature of Lisp.) (Incidentally, these

two parenthetical remarks are not Lisp lists, because they contain ‘;’ and ‘.’ as

punctuation marks.)

Here is another list, this time with a list inside of it:

’(this list has (a list inside of it))

The components of this list are the words ‘this’, ‘list’, ‘has’, and the list ‘(a

list inside of it)’. The interior list is made up of the words ‘a’, ‘list’, ‘inside’,

‘of’, ‘it’.

1.1.1 Lisp Atoms

In Lisp, what we have been calling words are called atoms. This term comes from

the historical meaning of the word atom, which means ‘indivisible’. As far as Lisp

is concerned, the words we have been using in the lists cannot be divided into

any smaller parts and still mean the same thing as part of a program; likewise with

numbers and single character symbols like ‘+’. On the other hand, unlike an ancient

The single apostrophe or quotation mark is an abbreviation for the function quote; you

need not think about functions now; functions are deﬁned in Section 1.3 “Generate

an Error Message”, page 4.

2 Chapter 1: List Processing

atom, a list can be split into parts. (See Chapter 7 “car cdr & cons Fundamental

Functions”, page 72.)

In a list, atoms are separated from each other by whitespace. They can be right

next to a parenthesis.

Technically speaking, a list in Lisp consists of parentheses surrounding atoms

separated by whitespace or surrounding other lists or surrounding both atoms and

other lists. A list can have just one atom in it or have nothing in it at all. A list

with nothing in it looks like this: (), and is called the empty list. Unlike anything

else, an empty list is considered both an atom and a list at the same time.

The printed representation of both atoms and lists are called symbolic expres-

sions or, more concisely, s-expressions. The word expression by itself can refer to

either the printed representation, or to the atom or list as it is held internally in the

computer. Often, people use the term expression indiscriminately. (Also, in many

texts, the word form is used as a synonym for expression.)

Incidentally, the atoms that make up our universe were named such when they

were thought to be indivisible; but it has been found that physical atoms are not

indivisible. Parts can split oﬀ an atom or it can ﬁssion into two parts of roughly

equal size. Physical atoms were named prematurely, before their truer nature was

found. In Lisp, certain kinds of atom, such as an array, can be separated into parts;

but the mechanism for doing this is diﬀerent from the mechanism for splitting a

list. As far as list operations are concerned, the atoms of a list are unsplittable.

As in English, the meanings of the component letters of a Lisp atom are diﬀerent

from the meaning the letters make as a word. For example, the word for the South

American sloth, the ‘ai’, is completely diﬀerent from the two words, ‘a’, and ‘i’.

There are many kinds of atom in nature but only a few in Lisp: for ex-

ample, numbers, such as 37, 511, or 1729, and symbols, such as ‘+’, ‘foo’, or

‘forward-line’. The words we have listed in the examples above are all symbols.

In everyday Lisp conversation, the word “atom” is not often used, because program-

mers usually try to be more speciﬁc about what kind of atom they are dealing with.

Lisp programming is mostly about symbols (and sometimes numbers) within lists.

(Incidentally, the preceding three word parenthetical remark is a proper list in Lisp,

since it consists of atoms, which in this case are symbols, separated by whitespace

and enclosed by parentheses, without any non-Lisp punctuation.)

Text between double quotation marks—even sentences or paragraphs—is also

an atom. Here is an example:

’(this list includes "text between quotation marks.")

In Lisp, all of the quoted text including the punctuation mark and the blank spaces

is a single atom. This kind of atom is called a string (for ‘string of characters’) and

is the sort of thing that is used for messages that a computer can print for a human

to read. Strings are a diﬀerent kind of atom than numbers or symbols and are used

diﬀerently.

Section 1.2: Run a Program 3

1.1.2 Whitespace in Lists

The amount of whitespace in a list does not matter. From the point of view of

the Lisp language,

’(this list

looks like this)

is exactly the same as this:

’(this list looks like this)

Both examples show what to Lisp is the same list, the list made up of the

symbols ‘this’, ‘list’, ‘looks’, ‘like’, and ‘this’ in that order.

Extra whitespace and newlines are designed to make a list more readable by

humans. When Lisp reads the expression, it gets rid of all the extra whitespace

(but it needs to have at least one space between atoms in order to tell them apart.)

Odd as it seems, the examples we have seen cover almost all of what Lisp lists

look like! Every other list in Lisp looks more or less like one of these examples,

except that the list may be longer and more complex. In brief, a list is between

parentheses, a string is between quotation marks, a symbol looks like a word, and

a number looks like a number. (For certain situations, square brackets, dots and

a few other special characters may be used; however, we will go quite far without

them.)

1.1.3 GNU Emacs Helps You Type Lists

When you type a Lisp expression in GNU Emacs using either Lisp Interaction mode

or Emacs Lisp mode, you have available to you several commands to format the Lisp

expression so it is easy to read. For example, pressing the TAB key automatically

indents the line the cursor is on by the right amount. A command to properly

indent the code in a region is customarily bound to M-C-\. Indentation is designed

so that you can see which elements of a list belong to which list—elements of a

sub-list are indented more than the elements of the enclosing list.

In addition, when you type a closing parenthesis, Emacs momentarily jumps the

cursor back to the matching opening parenthesis, so you can see which one it is.

This is very useful, since every list you type in Lisp must have its closing parenthesis

match its opening parenthesis. (See Section “Major Modes” in The GNU Emacs

Manual, for more information about Emacs’s modes.)

1.2 Run a Program

A list in Lisp—any list—is a program ready to run. If you run it (for which the Lisp

jargon is evaluate), the computer will do one of three things: do nothing except

return to you the list itself; send you an error message; or, treat the ﬁrst symbol in

the list as a command to do something. (Usually, of course, it is the last of these

three things that you really want!)

The single apostrophe, ’, that I put in front of some of the example lists in

preceding sections is called a quote; when it precedes a list, it tells Lisp to do

nothing with the list, other than take it as it is written. But if there is no quote

preceding a list, the ﬁrst item of the list is special: it is a command for the computer

4 Chapter 1: List Processing

to obey. (In Lisp, these commands are called functions.) The list (+ 2 2) shown

above did not have a quote in front of it, so Lisp understands that the + is an

instruction to do something with the rest of the list: add the numbers that follow.

If you are reading this inside of GNU Emacs in Info, here is how you can evaluate

such a list: place your cursor immediately after the right hand parenthesis of the

following list and then type C-x C-e:

(+ 2 2)

You will see the number 4 appear in the echo area. (In the jargon, what you have

just done is “evaluate the list.” The echo area is the line at the bottom of the screen

that displays or “echoes” text.) Now try the same thing with a quoted list: place

the cursor right after the following list and type C-x C-e:

’(this is a quoted list)

You will see (this is a quoted list) appear in the echo area.

In both cases, what you are doing is giving a command to the program inside

of GNU Emacs called the Lisp interpreter—giving the interpreter a command to

evaluate the expression. The name of the Lisp interpreter comes from the word for

the task done by a human who comes up with the meaning of an expression—who

“interprets” it.

You can also evaluate an atom that is not part of a list—one that is not sur-

rounded by parentheses; again, the Lisp interpreter translates from the humanly

readable expression to the language of the computer. But before discussing this

(see Section 1.7 “Variables”, page 9), we will discuss what the Lisp interpreter

does when you make an error.

1.3 Generate an Error Message

Partly so you won’t worry if you do it accidentally, we will now give a command to

the Lisp interpreter that generates an error message. This is a harmless activity;

and indeed, we will often try to generate error messages intentionally. Once you

understand the jargon, error messages can be informative. Instead of being called

“error” messages, they should be called “help” messages. They are like signposts to

a traveler in a strange country; deciphering them can be hard, but once understood,

they can point the way.

The error message is generated by a built-in GNU Emacs debugger. We will

‘enter the debugger’. You get out of the debugger by typing q.

What we will do is evaluate a list that is not quoted and does not have a

meaningful command as its ﬁrst element. Here is a list almost exactly the same as

the one we just used, but without the single-quote in front of it. Position the cursor

right after it and type C-x C-e:

(this is an unquoted list)

A ‘*Backtrace*’ window will open up and you should see the following in it:

剩余269页未读，继续阅读

qq_14949573

粉丝: 0
资源: 1

学习Emacs Lisp编程指南

An Introduction to Programming in Emacs Lisp

Robert Chassell：An Introduction to Programming in Emacs Lisp

An Introduction to Programming in Emacs Lisp Second Edition

gnu emacs lisp reffrence manual

在Emacs Lisp编程中，当尝试创建一个模块时遇到提示'A package name must be specified for a module.'，应该如何指定包名以解决这个错误？

vscode配置lisp

DEFUN和DEFUNSH的区别

在Elispese中创建class时出现A package name must be specified for a module.该怎么办

windows下，emacs的配置文件如何导入文件夹

lisp 利用鼠标动态绘制曲线

最新资源