Emacs Lisp编程入门指南

需积分: 9 35 浏览量更新于2024-07-18 收藏 1.01MB PDF 举报

"Robert Chassell的《An Introduction to Programming in Emacs Lisp》第二版，由Free Software Foundation出版，ISBN 1-882114-43-4，遵循GNU Free Documentation License，旨在介绍Emacs Lisp编程基础。" 这篇文档是关于Emacs Lisp编程的一个入门教程，由Robert Chassell撰写。Emacs Lisp是一种用于定制和扩展Emacs编辑器的脚本语言，它具有强大的功能，允许用户自定义编辑器的行为，创建新的功能和宏。 1. **List Processing**： Emacs Lisp基于Lisp语言，而Lisp的一个核心特性是列表处理。在这一部分，读者将学习如何创建、操作和遍历列表，这是Lisp编程的基础。这包括对原子（atomic）和非原子（consp）值的理解，以及使用函数如`car`、`cdr`、`cons`和`list`来操作列表。 2. **Practicing Evaluation**：这一章深入探讨了Lisp中的求值（evaluation）过程。在Lisp中，代码即数据，数据也可以是代码。作者可能会解释如何执行表达式，理解求值规则，例如函数调用、运算符优先级和作用域规则。 3. **How To Write Function Definitions**：在这个章节，读者会学习如何定义自己的函数，这是任何编程语言中都至关重要的技能。可能包括函数的基本结构，参数传递，以及返回值的概念。此外，还可能涉及局部变量和作用域规则。 4. **A Few Buffer-Related Functions**：编辑器的核心是缓冲区（buffer），这里讨论的是与Emacs编辑器缓冲区相关的函数。这些函数可能包括读写文件，移动光标，插入文本，以及管理多个缓冲区的技巧。 5. **A Few More Complexities**：预计这部分将引入更复杂的概念，可能涵盖条件语句（如`if`）、循环（如`dotimes`或`dolist`）、错误处理和异常机制，以及递归的使用。这本书的目标读者是对Emacs编辑器有基本了解，希望通过学习Emacs Lisp提升其定制能力的人。通过这本书，读者不仅可以掌握Lisp编程基础，还能深入理解Emacs的工作原理，从而更高效地利用这款强大的编辑工具。

xii Preface

opportunity to get acquainted with Emacs as a Lisp programming environ-

ment. GNU Emacs supports programming and provides tools that you will

want to become comfortable using, such as M-. (the key which invokes the

find-tag command). You will also learn about buﬀers and other objects

that are part of the environment. Learning about these features of Emacs is

like learning new routes around your home town.

Finally, I hope to convey some of the skills for using Emacs to learn

aspects of programming that you don’t know. You can often use Emacs to

help you understand what puzzles you or to ﬁnd out how to do something

new. This self-reliance is not only a pleasure, but an advantage.

For Whom This is Written

This text is written as an elementary introduction for people who are not

programmers. If you are a programmer, you may not be satisﬁed with this

primer. The reason is that you may have become expert at reading reference

manuals and be put oﬀ by the way this text is organized.

An expert programmer who reviewed this text said to me:

I prefer to learn from reference manuals. I “dive into” each para-

graph, and “come up for air” between paragraphs.

When I get to the end of a paragraph, I assume that that subject

is done, ﬁnished, that I know everything I need (with the possible

exception of the case when the next paragraph starts talking about

it in more detail). I expect that a well written reference manual

will not have a lot of redundancy, and that it will have excellent

pointers to the (one) place where the information I want is.

This introduction is not written for this person!

Firstly, I try to say everything at least three times: ﬁrst, to introduce it;

second, to show it in context; and third, to show it in a diﬀerent context, or

to review it.

Secondly, I hardly ever put all the information about a subject in one

place, much less in one paragraph. To my way of thinking, that imposes

too heavy a burden on the reader. Instead I try to explain only what you

need to know at the time. (Sometimes I include a little extra information

so you won’t be surprised later when the additional information is formally

introduced.)

When you read this text, you are not expected to learn everything the ﬁrst

time. Frequently, you need only make, as it were, a ‘nodding acquaintance’

with some of the items mentioned. My hope is that I have structured the

text and given you enough hints that you will be alert to what is important,

and concentrate on it.

You will need to “dive into” some paragraphs; there is no other way to

read them. But I have tried to keep down the number of such paragraphs.

A Note for Novices xiii

This book is intended as an approachable hill, rather than as a daunting

mountain.

This introduction to Programming in Emacs Lisp has a companion doc-

ument, The GNU Emacs Lisp Reference Manual. The reference manual has

more detail than this introduction. In the reference manual, all the infor-

mation about one topic is concentrated in one place. You should turn to it

if you are like the programmer quoted above. And, of course, after you have

read this Introduction, you will ﬁnd the Reference Manual useful when you

are writing your own programs.

Lisp History

Lisp was ﬁrst developed in the late 1950s at the Massachusetts Institute

of Technology for research in artiﬁcial intelligence. The great power of the

Lisp language makes it superior for other purposes as well, such as writing

editor commands and integrated environments.

GNU Emacs Lisp is largely inspired by Maclisp, which was written at

MIT in the 1960s. It is somewhat inspired by Common Lisp, which became

a standard in the 1980s. However, Emacs Lisp is much simpler than Common

Lisp. (The standard Emacs distribution contains an optional extensions ﬁle,

‘cl.el’, that adds many Common Lisp features to Emacs Lisp.)

A Note for Novices

If you don’t know GNU Emacs, you can still read this document prof-

itably. However, I recommend you learn Emacs, if only to learn to move

around your computer screen. You can teach yourself how to use Emacs

with the on-line tutorial. To use it, type C-h t. (This means you press and

release the

CTRL

key and the h at the same time, and then press and release

t.)

Also, I often refer to one of Emacs’ standard commands by listing the

keys which you press to invoke the command and then giving the name of

the command in parentheses, like this: M-C-\ ( indent-region). What this

means is that the indent-region command is customarily invoked by typing

M-C-\. (You can, if you wish, change the keys that are typed to invoke the

command; this is called rebinding. See Section 16.8, “Keymaps”, page 221.)

The abbreviation M-C-\ means that you type your

META

key, the

ESC

key preﬁx is used in place of it. In

this case, M-C-\ means that you press and release your

ESC

key and then

type the

CTRL

key and the

key at the same time. But usually M-C-\

means press the

CTRL

key along with the key that is labelled

ALT

and, at

the same time, press the

key.

Lisp Atoms 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 un-

warranted. 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 preceded 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 white-

space 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 ‘indivis-

ible’. 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

2 Chapter 1: List Processing

‘+’. On the other hand, unlike an atom, a list can be split into parts. (See

Chapter 7, “car cdr & cons Fundamental Functions”, page 81.)

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

expressions 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

example, 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 programmers 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.)

剩余313页未读，继续阅读

tongfangtemp

粉丝: 0
资源: 1

Emacs Lisp编程入门指南

An Introduction to Programming in Emacs Lisp

gnu emacs lisp reffrence manual

vscode配置lisp

emacs安装linux

bash ： emacs：未找到命令

linux 编译安装 emacs

用lisp写的著名的开源软件有哪些

linux安装emacs

emacs编辑器安装教程

在Ubuntu20.04中，分别使用ed、ex、emacs编辑器创建test.txt文件

最新资源