Node:Top, Next:Preface, Previous:(dir), Up:(dir)

PrePreface: 訳者まえがき
Preface: What to look for.
List Processing: What is Lisp?
Practicing Evaluation: Running several programs.
Writing Defuns: How to write function definitions.
Buffer Walk Through: Exploring a few buffer-related functions.
More Complex: A few, even more complex functions.
Narrowing & Widening: Restricting your and Emacs attention to a region.
car cdr & cons: Fundamental functions in Lisp.
Cutting & Storing Text: Removing text and saving it.
List Implementation: How lists are implemented in the computer.
Yanking: Pasting stored text.
Loops & Recursion: How to repeat a process.
Regexp Search: Regular expression searches.
Counting Words: A review of repetition and regexps.
Words in a defun: Counting words in a defun.
Readying a Graph: A prototype graph printing function.
Emacs Initialization: How to write a .emacs file.
Debugging: How to run the Emacs Lisp debuggers.
Conclusion: Now you have the basics.
the-the: An appendix: how to find reduplicated words.
Kill Ring: An appendix: how the kill ring works.
Full Graph: How to create a graph with labelled axes.
Index:
About the Author:
--- The Detailed Node Listing ---
Preface
On Reading this Text: Read, gain familiarity, pick up habits....
Who You Are: For whom this is written.
Lisp History:
Note for Novices: You can read this as a novice.
Thank You:
List Processing
Lisp Lists: What are lists?
Run a Program: Any list in Lisp is a program ready to run.
Making Errors: Generating an error message.
Names & Definitions: Names of symbols and function definitions.
Lisp Interpreter: What the Lisp interpreter does.
Evaluation: Running a program.
Variables: Returning a value from a variable.
Arguments: Passing information to a function.
set & setq: Setting the value of a variable.
Summary: The major points.
Error Message Exercises:
Lisp Lists
Lisp Atoms: Elemental entities.
Whitespace in Lists: Formating lists to be readable.
Typing Lists: How GNU Emacs helps you type lists.
The Lisp Interpreter
Byte Compiling: Specially processing code for speed.
Evaluation
Evaluating Inner Lists: Lists within lists...
Variables
Void Variable: The error message for a symbol without a value.
Arguments
Data types: Types of data passed to a function.
Args as Variable or List: An argument can be the value of a variable or list.
Variable Number of Arguments: Some functions may take a variable number of arguments.
Wrong Type of Argument: Passing an argument of the wrong type to a function.
message: A useful function for sending messages.
Setting the Value of a Variable
Using set: Setting values.
Using setq: Setting a quoted value.
Counting: Using setq to count.
Practicing Evaluation
How to Evaluate: Typing editing commands or C-x C-e causes evaluation.
Buffer Names: Buffers and files are different.
Getting Buffers: Getting a buffer itself, not merely its name.
Switching Buffers: How to change to another buffer.
Buffer Size & Locations: Where point is located and the size of the buffer.
Evaluation Exercise:
How To Write Function Definitions
Primitive Functions: Some functions are written in C.
defun: The defun special form.
Install: Install a Function Definition.
Interactive: Making a function interactive.
Interactive Options: Different options for interactive.
Permanent Installation: Installing code permanently.
let: Creating and initializing local variables.
if: What if?
else: If--then--else expressions.
Truth & Falsehood: What Lisp considers false and true.
save-excursion: Keeping track of point, mark, and buffer.
Review:
defun Exercises:
Install a Function Definition
Change a defun: How to change a function definition.
Make a Function Interactive
multiply-by-seven in detail: The interactive version.
let
Parts of let Expression:
Sample let Expression:
Uninitialized let Variables:
The if Special Form
type-of-animal in detail: An example of an if expression.
save-excursion
Template for save-excursion: One slot to fill in.
A Few Buffer--Related Functions
Finding More: How to find more information.
simplified-beginning-of-buffer: Shows goto-char, point-min, and push-mark.
mark-whole-buffer: Almost the same as beginning-of-buffer.
append-to-buffer: Uses save-excursion and insert-buffer-substring.
Buffer Related Review: Review.
Buffer Exercises:
The Definition of mark-whole-buffer
Body of mark-whole-buffer: Only three lines of code.
The Definition of append-to-buffer
append interactive: A two part interactive expression.
append-to-buffer body: Incorporates a let expression.
append save-excursion: How the save-excursion works.
A Few More Complex Functions
copy-to-buffer: With set-buffer, get-buffer-create.
insert-buffer: Read-only, and with or.
beginning-of-buffer: Shows goto-char, point-min, and push-mark.
Second Buffer Related Review:
&optional Exercise :
The Definition of insert-buffer
insert interactive expression: A read-only situation.
insert-buffer body: The body has an or and a let.
if & or: Using an if instead of an or.
insert or: How the or expression works.
insert let: Two save-excursion expressions.
The Interactive Expression in insert-buffer
read-only buffer:
b for interactive:
Complete Definition of beginning-of-buffer
Optional Arguments:
beginning-of-buffer opt arg: Example with optional argument.
beginning-of-buffer complete:
beginning-of-buffer with an Argument
large-case: Division and multiplication in a large buffer.
small-case: Functions embedded in parentheses.
Narrowing and Widening
narrowing advantages: The Advantages of Narrowing
save-restriction: The save-restriction special form.
what-line: The number of the line that point is on.
narrow Exercise:
car, cdr, cons: Fundamental Functions
Strange Names: An historical aside: why the strange names?
car & cdr: Functions for extracting part of a list.
cons: Constructing a list.
nthcdr: Calling cdr repeatedly.
setcar: Changing the first element of a list.
setcdr: Changing the rest of a list.
cons Exercise:
cons
length: How to find the length of a list.
Cutting and Storing Text
Storing Text: Text is stored in a list.
zap-to-char: Cutting out text up to a character.
kill-region: Cutting text out of a region.
delete-region: A digression into C.
defvar: How to give a variable an initial value.
copy-region-as-kill: A definition for copying text.
cons & search-fwd Review:
search Exercises:
zap-to-char
zap-to-char interactive: A three part interactive expression.
zap-to-char body: A short overview.
search-forward: How to search for a string.
progn: The progn function.
Summing up zap-to-char: Using point and search-forward.
v-18-zap-to-char: The version 18 implementation.
The Version 18 Implementation
progn body: The body of the progn expression
copy-region-as-kill
copy-region-as-kill body: The body of copy-region-as-kill
The Body of copy-region-as-kill
kill-append function: The kill-append function
copy-region-as-kill else-part: The else-part of copy-region-as-kill
How Lists are Implemented
List Exercise:
Yanking Text Back
Kill Ring Overview: The kill ring is a list.
kill-ring-yank-pointer: The kill-ring-yank-pointer variable.
yank nthcdr Exercises:
Loops and Recursion
while: Causing a stretch of code to repeat.
Recursion: Causing a function to call itself.
Looping exercise:
while
Loop Example: A while loop that uses a list.
print-elements-of-list: Uses while, car, cdr.
Incrementing Loop: A loop with an incrementing counter.
Decrementing Loop: A loop with a decrementing counter.
A Loop with an Incrementing Counter
Incrementing Example: Counting pebbles in a triangle.
Inc Example parts: The parts of the function definition.
Inc Example altogether: Putting the function definition together.
Loop with a Decrementing Counter
Decrementing Example: More pebbles on the beach.
Dec Example parts: The parts of the function definition.
Dec Example altogether: Putting the function definition together.
Recursion
Recursion with list: Using a list as the test whether to recurse.
Recursive triangle function: Replacing a while loop with recursion.
Recursion with cond: Recursion example with a different conditional.
Recursion in Place of a Counter
Recursive Example arg of 3:
Regular Expression Searches
sentence-end: The regular expression for sentence-end.
re-search-forward: Very similar to search-forward.
forward-sentence: A straightforward example of regexp search.
forward-paragraph: A somewhat complex example.
etags: How to create your own TAGS table.
Regexp Review:
re-search Exercises:
forward-sentence
fwd-sentence while loops: Two while loops.
fwd-sentence re-search: A regular expression search.
forward-paragraph: a Goldmine of Functions
fwd-para let: The let* expression.
fwd-para while: The forward motion while loop.
fwd-para between paragraphs: Movement between paragraphs.
fwd-para within paragraph: Movement within paragraphs.
fwd-para no fill prefix: When there is no fill prefix.
fwd-para with fill prefix: When there is a fill prefix.
fwd-para summary: Summary of forward-paragraph code.
Counting: Repetition and Regexps
Why Count Words: Emacs lacks a word count command.
count-words-region: Use a regexp, but find a problem.
recursive-count-words: Start with case of no words in region.
Counting Exercise:
The count-words-region Function
Whitespace Bug: The Whitespace Bug in count-words-region
Counting Words in a defun
Divide and Conquer: Split a daunting project into parts.
Words and Symbols: What to count?
Syntax: What constitutes a word or symbol?
count-words-in-defun: Very like count-words.
Several defuns: Counting several defuns in a file.
Find a File: Do you want to look at a file?
lengths-list-file: A list of the lengths of many definitions.
Several files: Counting in definitions in different files.
Several files recursively: Recursively counting in different files.
Prepare the data: Prepare the data for display in a graph.
Count Words in defuns in Different Files
append: Attaching one list to another.
Prepare the Data for Display in a Graph
Sorting: Sorting lists.
Files List: Making a list of files.
Readying a Graph
Columns of a graph: How to print individual columns.
graph-body-print: How to print the body of a graph.
recursive-graph-body-print:
Printed Axes:
Line Graph Exercise:
Your .emacs File
Default Configuration: Emacs has sensible defaults.
Site-wide Init: You can write site-wide init files.
edit-options: How to set some variables for a session.
Beginning a .emacs File: How to write a .emacs file.
Text and Auto-fill: Automatically wrap lines.
Mail Aliases: Use abbreviations for email addresses.
Indent Tabs Mode: Don't use tabs with TeX
Keybindings: Create some personal keybindings.
Loading Files: Load (i.e. evaluate) files automatically.
Autoload: Make functions available.
Simple Extension: Define a function; bind it to a key.
Keymaps: More about key binding.
X11 Colors: Colors in version 19 in X.
V19 Miscellaneous: Automatically resize minibuffer, and more.
Mode Line: How to customize your mode line.
Debugging
debug: How to use the built-in debugger.
debug-on-entry: Start debugging when you call a function.
debug-on-quit: Start debugging when you quit with C-g.
edebug: How to use Edebug, a source level debugger.
Debugging Exercises:
Handling the Kill Ring
rotate-yank-pointer: Move a pointer along a list and around.
yank: Paste a copy of a clipped element.
yank-pop: Insert first element pointed to.
The rotate-yank-pointer Function
rotate-yk-ptr body: The Body of rotate-yank-pointer.
The Body of rotate-yank-pointer
rotate-yk-ptr else-part: The else-part of the if expression.
Remainder Function: The remainder, %, function.
rotate-yk-ptr remainder: Using % in rotate-yank-pointer.
kill-rng-yk-ptr last elt: Pointing to the last element.
yank
rotate-yk-ptr arg: Pass the argument to rotate-yank-pointer.
rotate-yk-ptr negative arg: Pass a negative argument.
A Graph with Labelled Axes
Labelled Example: How a finished graph should look.
print-graph Varlist: let expression in print-graph.
print-Y-axis: Print a label for the vertical axis.
print-X-axis: Print a horizontal label.
Print Whole Graph: The function to print a complete graph.
The print-Y-axis Function
Compute a Remainder: How to compute the remainder of a division.
Y Axis Element: Construct a line for the Y axis.
Y-axis-column: Generate a list of Y axis labels.
print-Y-axis Final: Print a vertical axis, final version.
The print-X-axis Function
X Axis Tic Marks: Create tic marks for the horizontal axis.
Printing the Whole Graph
Test print-graph: Run a short test.
Graphing words in defuns: Executing the final code.
Final Printed Graph: The graph itself!
Graphing Numbers of Words and Symbols
lambda: How to write an anonymous function.
mapcar: Apply a function to elements of a list.
Another Bug: Yet another ... of a most insidious type.

Node:PrePreface, Next:Preface, Previous:Top, Up:Top

訳者まえがき

本書は、「Programming in Emacs Lisp: An Introduction」（texinfoファイルemacs-lisp-intro.texi、1.05版、更新日1997年10月21日）の翻訳である。日本語訳ファイルは

http://www.ascii.co.jp/pub/GNU/emacs-lisp-intro-jp.texi

に置いてある。日本語のTeXが利用できる環境ならば、texi2dviなどのコマンドで自前でdviファイルを作成して印刷できる。また、Muleを用いてバッファに読み込んでから M-x texinfo-format-bufferを実行すれば、日本語版のinfoファイルを作成することもできる。ただし、このようにして作ったinfoファイルでは、（メニューなどの）info特有の部分は未翻訳であることをあらかじめご了承願いたい。

Mule（Multilingual Enhancement to GNU Emacs）とそのLispは、多国語を扱うために拡張したため、 GNU EmacsやEmacs Lispと互換ではない部分がある。詳しくはMuleのディストリビューションに含まれるmule-jp.texiやマルチリンガル環境の実現 ¹ （特に第3章「Muleによるマルチリンガル環境の実現」）を参照してほしい。なお、本書の例題は、英数字を使用する限りはそのまま動作する。

GNU Emacsが扱う（7ビットの）ASCIIコードの文字は、コンピュータ内部では1文字を1バイトで表現し、これらの文字は画面上の表示でも1文字あたり1コラムを占める。したがって、文字数、内部表現のバイト数、表示コラム数のどれをとっても同じ値である。また、テキストをファイルに収めたときの文字コードと GNU Emacsのバッファ内での文字コードはまったく同じである。

ところが、多国語を扱うMuleでは、こうはならない。各国ごとにその国の文字を1バイトあるいは2バイトで表す規格がある。たとえば、日本には文字コードの規格としてJIS X 0208があり 2バイトで1文字を表す。また、ローマ字とカタカナの規格としてJIS X 0201があり 1バイトで1文字を表す。

1つのバッファ内に複数の国の文字コードが混在してもよいように、 Muleでは1バイトないしは2バイトの文字コードのまえに識別用に 1バイト（ないしは2バイト）を付加してバッファ内に保持する。この識別用のバイトをリーディングキャラクタ（leading character）と呼ぶ。ただし、7ビットのASCIIコードの文字は、GNU Emacsと同じで、リーディングキャラクタは付加しない。

たとえば、日本語の「あ」は、文字数は1であるが、内部表現には3バイト必要であり、表示には2コラム必要である。半角の「ア」は、文字数は1であるが、内部表現には2バイト必要であり、表示には1コラム必要である。 ASCII文字の「a」は、文字数も内部表現のバイト数も表示コラム数も1である。

このため、Muleでは、関数length （See length）は、文字列の「文字数」ではなく、内部表現の「バイト数」を返す。バッファ内のポイントやマーク（See Buffer Size & Locations）の位置も、「文字数」ではなく内部表現の「バイト数」が単位である。

一方、関数forward-charは、その名前から予想されるように、文字単位でポイントを移動する。文字列の「文字数」を調べるには関数chars-in-stringを使い、「表示コラム数」を調べるには関数string-widthを使う。

(length          "abcあいう")     => 12
(chars-in-string "abcあいう")     =>  6
(string-width    "abcあいう")     =>  9

.emacs（See Emacs Initialization）で Muleの版を区別するには、関数mule-versionが返す文字列を使う。また、日本語入力に「Wnn」、「sj3」、「かんな」のどれが使えるかを判別し、それぞれに固有の設定を行うには、関数featurepを使ってつぎのようにする。

(if (and (not (featurep 'egg)) (featurep 'canna))
    (progn 「かんな」に固有の設定 ... ))

(if (and (featurep 'egg) (featurep 'wnn-egg))
    (progn 「WNN」に固有の設定 ... ))

(if (and (featurep 'egg) (featurep 'sj3-egg))
    (progn 「sj3」に固有の設定 ... ))

MuleがX Window Systemのクライアントとして動作している場合、変数window-systemには値xが、そうでない場合にはnilが束縛されるので、つぎのように判別できる。

(if (eq window-system 'x)
    (progn 「X Window System」に固有の設定 ...)
  画面端末の場合の設定 ...)

Node:Preface, Next:List Processing, Previous:PrePreface, Up:Top

はじめに

テキストエディタGNU Emacsの大部分はEmacs Lispと呼ばれるプログラミング言語で書かれている。このプログラミング言語で書いたコードは、ユーザーが指令を与えたときに何をすべきかをコンピュータに指示するソフトウェア（一連の命令）である。 Emacsは、Emacs Lispで新たにコードを書いてエディタの拡張機能として簡単に追加できるように設計されている。「拡張可能なエディタ」と呼ばれる結縁である。

（Emacsは編集機能以上のものを提供するため、「拡張可能な計算環境」とでも呼ぶべきであるが、少々いいづらい。マヤ暦や月の満ち欠けを調べたり、多項式を簡約化したり、コードをデバッグしたり、ファイルを管理したり、手紙を読んだり、本を書いたりなどの Emacsで行えるすべてのことは、もっとも一般的な意味で編集である。）

Emacs Lispはテキストエディタに関連付けて考えられがちであるが、それ自体で1つのプログラミング言語である。他のプログラミング言語と同様に使える。

プログラミングを理解したい、Emacsを拡張したい、プログラマになりたいという読者もいることであろう。 Emacs Lispの入門である本書は、プログラミングの基本を学ぶための指針を与え、さらに重要なことは、自力で学習する方法を示すために執筆したものである。

On Reading this Text: Read, gain familiarity, pick up habits....
Who You Are: For whom this is written.
Lisp History:
Note for Novices: You can read this as a novice.
Thank You:

Node:On Reading this Text, Next:Who You Are, Previous:Preface, Up:Preface

本書には、Emacsで実行できる小さな例題プログラムがある。 GNU EmacsのInfoで読んでいる場合には、例題プログラムに出会うたびにそれらを実行できる（これは簡単に実行できるが、その方法は例題をあげたときに説明する）。あるいは、Emacsが動いているコンピュータを脇に置いて、印刷された本書を読んでいる場面もあろう（これは、筆者の好みでもある。筆者は印刷した書物が好きである）。手もとでEmacsを実行できなくても本書を読む意味はある。ただし、そのような場合には、小説や初めての国への旅行案内とみなしてほしい。興味深いはずであるが、実際にそこにいるのとは異なる。

本書の大部分は、GNU Emacsで使っているコードを眺める、つまり、ウォークスルーであり、ガイド付きツアーである。これらのツアーには2つの目的がある。第一に、実際に動作する（日常的に使用している）コードに慣れてもらうことであり、第二に、Emacsの動作方式に慣れてもらうことである。エディタの実装方式を学ぶことは興味深いはずである。また、ソースコードを読み進む際のコツも学んでほしい。ソースコードから学んだり、アイデアを堀り起こせるはずである。 GNU Emacsはまさに宝の山である。

エディタとしてのEmacsやプログラミング言語としてのEmacs Lispを学ぶことに加えて、例題やガイド付きツアーは、Lispのプログラミング環境としてのEmacsを熟知する機会となるはずである。 GNU Emacsは、プログラミングの支援に加えて、M-. （コマンドfind-tagを起動するキー）などの慣れると便利なツールも提供する。エディタ環境の一部であるバッファやその他のオブジェクトについても学ぶ。 Emacsのこれらの機能を学ぶことは、読者の街の周りの道を新たに学ぶことに似ている。

読者が知らないプログラミングの側面を学ぶためのEmacsの利用法も伝えたいと思う。読者を惑わすことがらを理解したり、新たなことを行う方法を調べるためにも Emacsを利用できるのである。この独立性は好ましいだけでなく利点でもある。

Node:Who You Are, Next:Lisp History, Previous:On Reading this Text, Up:Preface

対象とする読者

本書は、プログラマではない人向けの初歩の入門書である。すでにプログラマである読者には、本書は物足りないであろう。というのは、そのような読者はすでにリファレンスマニュアルを存分に読めるようになっており、本書の構成は間延びして見えるであろう。

経験あるプログラマは、本書をつぎのように評価してくれた。

リファレンスマニュアルで学ぶほうが好きである。各段落に「飛び込んで」、段落のあいだで「息つぎ」する。
段落を読み終えたときには、そこで取り上げた話題は完結しており、必要なことは（以降の段落でより詳しく説明する場合を除いて）すべてわかったと仮定したい。よく構成されたリファレンスマニュアルには、冗長な部分がなく、必要な情報への索引が整備されているはずである。

本書は、このような人向けではない！

第一に、おのおののことがらを少なくとも3回は説明するように努めた。 1回目は紹介、2回目は使い方、3回目は別の使い方や復習である。

第二に、1つの話題に関するすべての情報を1か所にまとめることはせずに、 1つの段落に詰め過ぎないようにした。筆者の考え方では、そうしないと読者に重荷を背負わせることになるからである。かわりに、その時点で必要なことのみを説明するように努めた（あとで詳しく説明する場合に備えて、少々余分に説明する場面もある）。

1回読むだけで、すべてを理解してもらえるとは考えていない。読者は、説明内容を「わかったつもり」にしておく必要があるだろう。重要なことがらを正しく読者に指し示し、注意を促すように本書を構成したつもりである。

いくつかの段落には、「飛び込んで」もらうしかなく、それ以外に読み進む方法はない。しかし、そのような段落の個数は少なくするように努めた。本書は登頂困難な山ではなく、楽に歩ける小山である。

本書Emacs Lispプログラミング入門には、姉妹編と呼ぶべきドキュメントがある。リファレンスマニュアルには本書より詳しい説明がある。リファレンスマニュアルでは、1つの話題に関する情報は1か所にすべてまとめてある。上で述べたようなプログラマは、そちらを参照すべきである。もちろん、本書を読み終えて自分のプログラムを書くときには、リファレンスマニュアルが有用であるはずである。

Node:Lisp History, Next:Note for Novices, Previous:Who You Are, Up:Preface

Lispの歴史

Lispは、人工知能の研究のために、 1950年代末にマサチューセッツ工科大学で初めて開発された。 Lisp言語はその強力な機能のため、エディタコマンドを書くなどの他の目的にも優れている。

GNU Emacs Lispは、1960年代にMITで開発されたMaclispから多くを受け継いでいる。 1980年代に標準規格となったCommon Lispからも一部を受け継いでいる。しかし、Emacs Lispは、Common Lispよりもずっと単純である（Emacsの標準ディストリビューションには、 Common Lispの多くの機能をEmacs Lispに追加するための機能拡張用ファイルcl.elがある）。

Node:Note for Novices, Next:Thank You, Previous:Lisp History, Up:Preface

初心者へ一言

GNU Emacsを知らない読者にも、本書は有益であろう。しかし、たとえスクリーンの移動方法だけであってもEmacsを学ぶことを勧める。 Emacsの使い方は、オンラインのチュートリアルで自習できる。それには、C-h tとタイプする（つまり、<CTRL>キーとhを同時に押してから離し、さらに、tを押してから離す）。

Emacsの標準コマンドを参照するために、 M-C-\（indent-region）のように、コマンドを起動するために押すキーに続けて括弧内にコマンド名を書く。つまり、コマンドindent-regionは、慣習的にはM-C-\とタイプすると起動できることを意味する（望むならば、コマンドを起動するためのキーを変更することもできる。これをリバインド（rebinding）という。 See Keymaps）。 M-C-\は、<META>キー、<CTRL>キー、<\>キーの3つを同時に押すことを意味する。ピアノを演奏するときの和音になぞらえて、このような組み合わせをキーコード（keychord）と呼ぶこともある。 <META>キーがないキーボードでは、かわりに<ESC>キーを前置キーとして使う。このような場合には、M-C-\は、<ESC>キーを押して離してから、 <CTRL>キーと<\>キーの2つを同時に押すことを意味する。

GNU EmacsのInfoで読んでいる場合には、スペースバー<SPC>を押すだけで全体を読み進められる（Infoについて学ぶには、C-h iとタイプしてInfoを選択すればよい）。

用語に関しての注意：単語Lispのみを使った場面では Lispのさまざまな方言全般を意味するが、 Emacs Lispを使った場面ではGNU Emacs Lispのみを意味する。

Node:Thank You, Previous:Note for Novices, Up:Preface

謝　辞

本書の執筆に協力していただいた方々に感謝したい。特に、Jim Blandy、Noah Friedman、Jim Kingdon、Roland McGrath、 Frank Ritter、Randy Smith、Richard M. Stallman、 Melissa Weisshausに感謝したい。辛抱強く励ましてくれたPhilip JohnsonとDavid Stampeにも感謝したい。誤りがあれば筆者の責任である。

Node:List Processing, Next:Practicing Evaluation, Previous:Preface, Up:Top

リスト処理

慣れていない人の目には、Lispは不可思議なプログラミング言語である。 Lispのコードには、いたるところに括弧がある。「Lots of Isolated Silly Parentheses（奇妙な括弧が多い）」の略であると批判する人達もいる。しかし、この批判は不当である。 LispはLISt Processingの略であり、括弧で囲んだリスト（list） （および、リストのリスト）を扱うプログラミング言語である。括弧はリストの境界を表す。リストの直前にアポストロフィ、つまり、引用符'を付ける場合もある。リストはLispの基本である。

Lisp Lists: What are lists?
Run a Program: Any list in Lisp is a program ready to run.
Making Errors: Generating an error message.
Names & Definitions: Names of symbols and function definitions.
Lisp Interpreter: What the Lisp interpreter does.
Evaluation: Running a program.
Variables: Returning a value from a variable.
Arguments: Passing information to a function.
set & setq: Setting the value of a variable.
Summary: The major points.
Error Message Exercises:

Node:Lisp Lists, Next:Run a Program, Previous:List Processing, Up:List Processing

Lispのリスト

Lispでは、リストを'(rose violet daisy buttercup)のように書く。このリストの直前にはアポストロフィが1つ付いている。これはつぎのように書くこともでき、こちらの書き方にも慣れてほしい。

'(rose
  violet
  daisy
  buttercup)

このリストの各要素は異なる4つの花の名前である。個々の要素を空白で区切り、庭の花を石で囲うように括弧で囲む。

(+ 2 2)のように、リストには数が含まれてもよい。このリストには、プラス記号+に続けて2つの2があり、おのおのは空白で区切ってある。

Lispでは、データとプログラムのどちらも同じ方法で表現する。つまり、どちらも、単語や数やリストを空白で区切って括弧で囲んだリストである（プログラムはデータのようにも見えるので、プログラムは容易に他のプログラムのデータとなりえる。これは、Lispの強力な機能である）。

（原文の2つの括弧書き

(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.)

には、句読点記号として;や.が含まれるので Lispのリストではない。）

つぎもリストの例であり、リストの中にリストを含む。

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

このリストの要素は、this、list、hasの単語と、リスト(a list inside of it)である。内側のリストは、a、list、inside、of、 itの単語からできている。

Lisp Atoms: Elemental entities.
Whitespace in Lists: Formating lists to be readable.
Typing Lists: How GNU Emacs helps you type lists.

Node:Lisp Atoms, Next:Whitespace in Lists, Previous:Lisp Lists, Up:Lisp Lists

Lispのアトム

Lispでは、これまで単語と呼んできたものをアトム（atoms）と呼ぶ。この用語はアトム（原子）の歴史的な意味からきており、「不可分」ということである。 Lispに関していえば、リストに用いてきた単語はそれ以上には小さく分割できず、プログラムの一部として同じものを意味する。数や+のような1文字の記号についてもそうである。一方、アトムとは異なり、リストは部分に分割できる（See car cdr & cons）。

リストでは、アトムを空白で区切る。アトムは、括弧のすぐ隣にあってもよい。

技術的には、Lispのリストは、空白で区切ったアトムを囲む括弧、リストを囲む括弧、アトムやリストを囲む括弧から成る。リストは、たった1個のアトムを含むだけでも、まったく含まなくてもよい。何も含まないリストは()のように書き、空リスト（empty list）と呼ぶ。空リストは、それ以外のものとは異なり、アトムであると同時にリストでもある。

アトムやリストを表示したものをシンボリック式（symbolic expressions）、あるいは、より簡素にはS式（s-expressions）と呼ぶ。用語「式（expression）」そのものでは、表示したアトムやリスト、あるいは、コンピュータ内部に格納したアトムやリストを意味する。しばしば、これらを区別せずに用語「式（expression）」を使う（さらに、多くの書籍では式の同義語として用語「フォーム（form）」を使う）。

われわれの宇宙を構成するアトム（原子）は、それらが不可分であると考えられた時代に命名されたものであるが、物質原子は不可分ではないことが知られている。原子の一部を分割したり、ほぼ同じ大きさに分裂させたりできる。物質原子は、その真の性質が発見される以前に命名されたのである。 Lispでは、配列などのある種のアトムは構成部分に分割できるが、この分割機構はリストを分割する機構とは異なる。リスト操作に関する限り、リストのアトムは分割できない。

英語の場合と同様に、Lispのアトムを構成する文字は、単語を作り上げる個々の文字とは異なる。たとえば、南米のナマケモノを表す単語ai（ミツユビナマケモノ）は、 2つの単語aとiとはまったく異なる。

自然界には多種類の原子が存在するが、Lispには数種類のアトムしかない。たとえば、37、511、1729などの数（numbers）、 +、foo、forward-lineなどのシンボル（symbols）である。これまで例にあげた単語はすべてシンボルである。 Lispの日常の習慣では、用語「アトム」をあまり使わない。というのは、プログラマは扱っているアトムの種類を特定しようとするからである。 Lispのプログラミングでは、リスト内のシンボル（やときには数）を扱う（括弧書き「（やときには数）」の原文(and sometimes numbers)は、アトムを空白で区切って括弧で囲んであり、しかも、Lispの句読点記号以外は含まないのでLispのリストである）。

さらに、二重引用符で囲まれたテキストは（文であろうと段落であろうと）アトムである。つぎに例を示す。

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

Lispでは、句読点記号や空白を含みこのように囲まれたテキストは単一のアトムである。この種のアトムは文字列（string）と呼ばれ、コンピュータが人間向けに出力するメッセージに使う。文字列は、数やシンボルとは異なる別の種類のアトムであり、使い方も異なる。

Node:Whitespace in Lists, Next:Typing Lists, Previous:Lisp Atoms, Up:Lisp Lists

リスト内の空白

リスト内の空白の個数はいくつでもよい。 Lisp言語の視点からすれば、

'(this list
   looks like this)

は、つぎとまったく同等である。

'(this list looks like this)

どちらの例もLispにとっては同じリストであり、 this、list、looks、like、 thisのシンボルからこの順に構成されたリストである。

余分な空白や改行は人間がリストを見やすくするためのものである。 Lispが式を読み取るとき、余分な空白をすべて取り除く（ただし、アトムとアトムのあいだには、これらを区切るために少なくとも1つの空白が必要である）。

奇妙に思えるかもしれないが、これまでの例で、 Lispのすべてのリストがどのようなものであるかを見てきた。 Lispのリストは多かれ少なかれこれまでの例のようなものであり、もっと長かったり複雑なだけである。要約すれば、リストは括弧で囲まれたものであり、文字列は二重引用符で囲まれたものであり、シンボルは単語のようなものであり、数は数字列である（鈎括弧やドットや特別な数種の文字を使う場合もあるが、しばらくはこれらを使わない）。

Node:Typing Lists, Previous:Whitespace in Lists, Up:Lisp Lists

GNU Emacsのリスト入力補佐機能

GNU EmacsのLisp InteractionモードやEmacs LispモードでLispの式を入力する場合には、Lispの式を読みやすく整形するためのコマンドを利用できる。たとえば、<TAB>キーを押すと、カーソルを置いた行を自動的に字下げする。あるリージョンのコードを正しく字下げするコマンドは、慣習的にM-C-\にバインドされている。リストの各要素が、どのリストに属するかがわかりやすくなるように字下げする。つまり、内側のリストの各要素は、そのリストを囲むリストの要素よりも字下げされる。

さらに、閉じ括弧をタイプするとEmacsは対応する開き括弧に一時的にカーソルを移動して、対応関係がわかるようにする。 Lispに与える個々のリストは括弧の対応が取れている必要があるので、これはとても便利である（Emacsのモードに関して詳しくは、 See Major Modes）。

Node:Run a Program, Next:Making Errors, Previous:Lisp Lists, Up:List Processing

プログラムの実行

Lispのどんなリストも実行できるプログラムである。それを実行する（Lispの専門用語では評価（evaluate）する）と、コンピュータは、つぎの3つのうちの1つを行う。リストそのものを返して、それ以外のことは何もしない。エラーメッセージを出す。リストの先頭シンボルをなんらかのコマンドとして扱う（もちろん、普通は3番目の動作を望む！）。

前節の例においてリストの直前に付けた1つのアポストロフィ'をクオート（quote）と呼ぶ。リストの直前にこれを付けると、そのリストに関しては何もせずに字面どおりに扱うことをLispに指示する。リストの直前にクオートがない場合には、リストの先頭要素を特別扱いし、コンピュータが従うべきコマンドとなる（Lispでは、これらのコマンドを関数（functions）と呼ぶ）。まえにあげたリスト(+ 2 2)の直前にはクオートがないので、 Lispは、+がリストの残りの部分に対して行うべき操作であると解釈する。この場合、後続の数を加算する。

GNU EmacsのInfoで読んでいる場合には、つぎのようにしてリストを評価する。つぎのリストの閉じ括弧の直後にカーソルを置いてから C-x C-eとタイプする。

(+ 2 2)

エコー領域に数4が表示されるはずである（専門用語では、たったいま「リストを評価」したのである。エコー領域とは画面の最下行のことで、テキストを表示する場所である）。クオートしたリストについても同じことをやってみよう。つぎのリストの直後にカーソルを置いてC-x C-eとタイプする。

'(this is a quoted list)

今度は、エコー領域に(this is a quoted list)と表示されるはずである。

いずれの場合も、GNU Emacsの内部にある Lispインタープリタ（Lisp interpreter）と呼ばれるプログラムに指令、つまり、式を評価せよという指令を与えたのである。 Lispインタープリタという名称は、表現の意味を追いかける人間の仕事、つまり、通訳（interpreter）からきている。

リストの一部ではないアトム、つまり、括弧に囲まれていないアトムを評価することもできる。この場合もLispインタープリタは人間が読める表現をコンピュータの言語に変換する。このこと（see Variables）を説明するまえに、まちがいを起こした場合にLispインタープリタがどうするかを説明しよう。

Node:Making Errors, Next:Names & Definitions, Previous:Run a Program, Up:List Processing

エラーメッセージの生成

偶然引き起こした場合は気にしないでよいが、ここではエラーメッセージを生成するようなコマンドをLispインタープリタに与えてみる。これは無害であり、意図してエラーメッセージを生成することにある。専門用語を理解すれば、エラーメッセージは有益でさえある。「エラー」メッセージと呼ぶよりは「ヘルプ」メッセージと呼ぶべきであろう。これらは、見知らぬ国を訪れた旅行者のための道標のようなものである。読みこなすのはたいへんであろうが、いったん理解してしまえば道を指し示してくれる。

リストの先頭要素に意味のあるコマンドもなく、クオートもしていないリストを評価してみよう。上で用いたリストとほとんど同じであるが、その直前には引用符を付けない。このリストの直後にカーソルを置いてC-x C-eとタイプする。

(this is an unquoted list)

今度は、エコー領域につぎのようなメッセージが表示されるはずである（端末のベルが鳴ったり画面が点滅したりする場合もある。これは人間の注意を引くためのものである）。

Symbol's function definition is void: this

カーソルを移動したり、何かキーをタイプするだけでメッセージは消えてしまう。

既知のことをもとにすれば、このエラーメッセージをほぼ読み取れる。用語Symbolの意味は知っている。ここでは、リストの先頭要素である単語thisを意味する。用語関数（function）については一度述べた。これは重要な用語である。ここでは、関数（function）とは、コンピュータに何かを行わせるためのコンピュータに対する一連の命令であると定義しよう（技術的には、シンボルは一連の命令を探す場所を指定するのであるが、ここではその詳細は無視できる）。

これでエラーメッセージSymbol's function definition is void: this の意味を理解できるはずである。シンボル（つまり単語this）には、コンピュータが実行すべき、いかなる命令列も定義されていないのである。

メッセージfunction definition is voidの単語の使い方が少々変わってるのは、Emacs Lispの実装方法に準じているのである。つまり、シンボルに関数定義が与えられていない場合には、命令列を格納する場所は「void（空）」になるのである。

一方で、(+ 2 2)を評価すると2に2を加算できるので、シンボル+にはコンピュータが実行すべき命令列が与えられており、しかも、それらは+に続く数を加算する命令であると推理できる。

Node:Names & Definitions, Next:Lisp Interpreter, Previous:Making Errors, Up:List Processing

シンボル名と関数定義

これまでに説明してきたことをもとに、Lispの別の特徴を明確にすることができる。 +のようなシンボルは、それ自身はコンピュータが実行すべき命令列ではないという重要な特徴である。そのかわりに、定義、すなわち、命令列を探すためにシンボルを（一時的に）使うのである。われわれが見ているものは、命令列を探すための名前である。人の名前も同じように使われる。筆者はBobと呼ばれているが、私はB、o、bの3文字ではなく、意識のある生命体である。名前そのものは私ではなく、私を指すために名前を使うのである。

Lispでは、1つの命令列に複数の名前を結び付けることができる。たとえば、コンピュータの加算命令列をシンボルplusにも+にも結び付けられる（そのようなLispの方言もある）。人間の世界でも、筆者をBobと呼んだりRobertと呼んだりでき、それ以外の単語でもよい。

その一方で、シンボルには1つの関数定義しか結び付けられない。さもなければ、どちらの定義を採用すべきかコンピュータが混乱する。これを人間の世界に当てはめると、 Bobという名前を持つ人は世界中で1人に限られることになる。しかし、名前が参照する関数定義を変更するのは容易である（See Install）。

Emacs Lispは巨大なので、関数が属するEmacsの構成部分がわかるようにシンボルを命名する慣習がある。したがって、Texinfoを扱うすべての関数の名前はtexinfo-で始まり、メールを読むことに関連する関数の名前はrmail-で始まる。

Node:Lisp Interpreter, Next:Evaluation, Previous:Names & Definitions, Up:List Processing

Lispインタープリタ

これまでの説明をもとに、リストの評価をLispインタープリタに命じると Lispインタープリタが何をするかを理解することができる。まず、リストの直前にクオートがあるかどうかを調べる。クオートがあれば、リストを返すだけである。一方、クオートがなければ、インタープリタはリストの先頭要素を調べ、それに関数定義があるかどうかを調べる。関数定義があれば、インタープリタはその関数定義内の命令列を実行する。さもなければ、インタープリタはエラーメッセージを出力する。

これがLispの動作であり、単純である。すぐに説明するが、これに加えて複雑なことがらもあるが、以上が基本である。当然、Lispプログラムを書くには、関数定義の書き方、名前への結び付け方、および、これらを読者やコンピュータに混乱のないように行う方法を知る必要がある。

では、複雑なことがらの最初のことを説明しよう。 Lispインタープリタは、リストに加えて、クオートもせず括弧で囲まれてもいないシンボルを評価できる。この場合、Lispインタープリタは、変数（variable）としてのシンボルの値を決定しようとする。これについては変数に関する節で説明する（See Variables）。

複雑なことがらの2番目は、特殊な関数があり、これらは普通の方式のように動作しないことである。これらをスペシャルフォーム（special forms）と呼ぶ。関数の定義などの特殊なことを行うものであり、それらの個数は多くはない。以下のいくつかの章では、重要なスペシャルフォームのいくつかを紹介する。

3番目で最後の複雑なことがらはつぎのとおりである。 Lispインタープリタが探しあてた関数がスペシャルフォームでなく、しかも、それがリストの一部である場合には、 Lispインタープリタはリストの内側にリストがあるかどうかを調べる。内側にリストがあれば、Lispインタープリタは内側のリストを処理してから、外側のリストを処理する。内側のリストの内側にもリストが含まれている場合には、それを処理してから内側のリストを処理する。つねに、もっとも内側のリストを最初に処理する。インタープリタはもっとも内側のリストの結果を得るためにそれを処理する。その結果はそれを含む式で使われる。

そうでない場合には、インタープリタは左から右への順で式を1つずつ処理する。

Byte Compiling: Specially processing code for speed.

Node:Byte Compiling, Previous:Lisp Interpreter, Up:Lisp Interpreter

バイトコンパイル

インタープリタには別の側面もある。 Lispインタープリタは2種類のものを解釈できる。本書で取り上げている人が読める形式のコードと、特別な処理を施し人には読めない形式のバイトコンパイル（byte compiled）コードである。バイトコンパイルしたコードは、人間向けのコードに比べて実行が速い。

byte-compile-fileのようなコンパイルコマンドを実行すれば、人間向けのコードをバイトコンパイルコードに変換できる。バイトコンパイルコードは、拡張子.elではなく拡張子.elcで終わるファイルに収容するのが一般的である。ディレクトリemacs/lispには両方の種類のファイルがあるが、読むのは拡張子.elのファイルである。

実用上は、Emacsを調整したり拡張したりするのがほとんどであろうから、バイトコンパイルする必要はなく、ここではこれ以上取り上げない。バイトコンパイルについて詳しくはSee Byte Compilation。

Node:Evaluation, Next:Variables, Previous:Lisp Interpreter, Up:List Processing

評　価

Lispインタープリタが式を処理することを評価する（evaluation）と呼ぶ。インタープリタが「式を評価する」という。これまでにも、この用語を何度か使ってきた。この用語は日常の言葉使いからきている。つまり、Webster's New Collegiate Dictionaryによれば、「価値や量を見定める、見積もること」である。

式を評価し終えると、Lispインタープリタは、関数定義で与えられた命令列をコンピュータが実行した結果を返す（return）のが一般的であるが、関数の処理を諦めてエラーメッセージを生成する場合もある（インタープリタ自体を別の関数に渡したり、「無限ループ」と呼ばれる無制限に同じことを繰り返すこともある。これらの動作は一般的ではないので、ここでは無視することにする）。ほとんどの場合、インタープリタは値を返す。

インタープリタは、値を返すと同時に、カーソルを移動したりファイルをコピーしたりなどの別の動作も行う。この種の別の動作は、副作用（side effect）と呼ばれる。結果の表示などの人間が重要と考える動作は、 Lispインタープリタによっては「副作用」であることが多い。この用語は奇妙に聞こえるかもしれないが、副作用の使い方を学ぶのはかなり簡単である。

まとめると、Lispインタープリタは、シンボリック式を評価するとほとんどの場合は値を返すが、副作用を伴うこともある。あるいは、エラーを生成する。

Evaluating Inner Lists: Lists within lists...

Node:Evaluating Inner Lists, Previous:Evaluation, Up:Evaluation

内側のリストの評価

内側にリストを含んだリストを評価するときには、内側のリストを評価して得られた値を、外側のリストを評価するときの情報として使う場合がある。そのために、内側の式を最初に評価するのである。それが返した値を外側の式で使用する。

このような評価の過程を、加算の例題で調べることにしよう。つぎの式の直後にカーソルを置いてC-x C-eとタイプする。

(+ 2 (+ 3 3))

エコー領域には数8が表示される。

Lispインタープリタで行われることは、まず内側の式(+ 3 3)を評価することであり、これは値6を返す。続いて、外側の式を(+ 2 6)であるかのように評価し、これは値8を返す。評価すべき外側の式はもうないので、インタープリタはこの値をエコー領域に表示する。

さて、キー列C-x C-eで起動されるコマンドの名前を理解するのは容易である。コマンドの名前はeval-last-sexpである。 sexpは「シンボリック式（symbolic expression）」の略、 evalは「評価（evaluate）」の略である。コマンドの意味は、「直前のシンボリック式を評価する」である。

式の直後の行の先頭や式の内側にカーソルを置いても式を評価できるかどうか試してみよう。

つぎの式で試してみる。

(+ 2 (+ 3 3))

式の直後の空行の先頭にカーソルを置いてC-x C-eとタイプしても、エコー領域には値8が表示される。今度は、式の内側にカーソルを置いて試してみる。最後の括弧のまえに（つまり、表示上は最後の括弧の上に）カーソルを置いて評価すると、エコー領域には値6が表示される！　コマンドは式(+ 3 3)を評価したからである。

今度は、数の直後にカーソルを置いてみる。 C-x C-eとタイプすると数そのものを得る。 Lispでは、数を評価するとその数そのものを得るのである。これが数とシンボルの違いである。 +のようなシンボルで始まるリストを評価すると、 +に結び付けた関数定義の命令列を実行した結果の値を得る。つぎの節で説明するように、シンボルそのものを評価すると別のことが起こる。

Node:Variables, Next:Arguments, Previous:Evaluation, Up:List Processing

変　数

Lispでは、シンボルに関数定義を結び付けるように、シンボルに値を結び付けることもできる。これらの2つは異なるものである。関数定義はコンピュータが遂行する命令列である。一方で、値は、数や名前などの何かであり、変更できる（これが、そのようなシンボルが変数と呼ばれる理由である）。シンボルの値としては、シンボル、数、リスト、文字列などの Lispの任意の式を取れる。値を持つシンボルをしばしば変数（variable）と呼ぶ。

シンボルには関数定義と値の両方を同時に結び付けておくことができる。これら2つは別々である。これは、ケンブリッジという名称が、マサチューセッツの都市を表すと同時に、「偉大なプログラミングセンター」のような名前の付加属性を持つことができるのに似ている。

あるいは、シンボルは箪笥であると考えてほしい。関数定義はある引き出しに入れてあり、値は別の引き出しに入れてあるのである。関数定義を収めた引き出しの中身を変えることなく、値を収めた引き出しの中身を変更でき、その逆もそうである。

値を持つシンボルの例として変数fill-columnを取り上げよう。 GNU Emacsの各バッファでは、このシンボルに72とか70の値が設定されるが、それ以外の値の場合もある。このシンボルの値を調べるには、それそのものを評価すればよい。 GNU EmacsのInfoで読んでいる場合には、シンボルの直後にカーソルを置いてC-x C-eとタイプする。

fill-column

筆者の場合、C-x C-eとタイプするとEmacsはエコー領域に数72を表示する。この値は、筆者が本書を執筆中にfill-columnに設定してある値である。読者のInfoバッファでは異なるかもしれない。変数の値として返された値は、関数の命令列を実行した結果返された値とまったく同じように表示されることに注意してほしい。 Lispインタープリタの視点からは、どちらも返された値である。値が求まってしまえば、それがどのような式から得られたかは関係ないのである。

シンボルにはどのような値でも結び付けることができる。専門用語を使えば、変数には、72のような数、"such as this"のような文字列、 (spruce pine oak)のようなリストを束縛（bind）できる。変数に関数定義を束縛することもできる。

シンボルに値を束縛する方法は何通りかある。 1つの方法は、See set & setq。

fill-columnの値を調べるために評価するときには、単語fill-columnの周りには括弧がないことに注意してほしい。これは、fill-columnを関数名としては使わないからである。 fill-columnがリストの先頭要素だとすると、 Lispインタープリタはこれに結び付けられた関数定義を探そうとする。しかし、fill-columnには関数定義はない。つぎを評価してみよう。

(fill-column)

すると、つぎのエラーメッセージを得る。

Symbol's function definition is void: fill-column

Void Variable: The error message for a symbol without a value.

Node:Void Variable, Previous:Variables, Up:Variables

値のないシンボルに対するエラーメッセージ

値が束縛されていないシンボルを評価すると、エラーメッセージを得る。たとえば、2足す2の例を用いて調べてみよう。つぎの式で、最初の数2のまえの+の直後にカーソルを置いて C-x C-eをタイプすると、

(+ 2 2)

つぎのエラーメッセージを得る。

Symbol's value as variable is void: +

これはまえに見たSymbol's function definition is void: thisとは違うエラーメッセージである。ここでは、シンボルには変数としての値がないのである。まえの場合は、（thisという）シンボルには関数定義がなかったのである。

+で試したことは、Lispインタープリタに+を評価させて、関数定義ではなく変数の値を探させたのである。そうするために、式を閉じる括弧の直後にカーソルを置くかわりに、シンボルの直後にカーソルを置いた。そのため、Lispインタープリタは直前のS式、つまり、 +そのものを評価したのである。

+には、関数定義はあるが、値は束縛されていないので、変数としてのシンボルの値は空（void）である旨のエラーメッセージが報告されたのである。

Node:Arguments, Next:set & setq, Previous:Variables, Up:List Processing

引　数

どのように関数に情報が伝えられるかを見るために、お馴染みの2足す2の例を使ってみよう。 Lispでは、つぎのように書く。

(+ 2 2)

この式を評価すると、エコー領域には数4が表示される。 Lispインタープリタが行ったことは、+のあとに続く数の加算である。

+が加算した数のことを、関数+の引数（arguments）と呼ぶ。これらの数は、関数に与えられた、つまり、渡された情報である。

「argument（引数）」という用語は数学での用法からきており、 2人のあいだの議論のことではない。ここでは、+という関数へ与えられた情報を意味する。 Lispでは、関数に対する引数は、その関数のあとに続くアトムやリストである。これらのアトムやリストを評価して返された値が関数へ渡される。関数が異なれば、必要な引数の個数も異なり、引数をまったく必要としない関数もある。 ²

Data types: Types of data passed to a function.
Args as Variable or List: An argument can be the value of a variable or list.
Variable Number of Arguments: Some functions may take a variable number of arguments.
Wrong Type of Argument: Passing an argument of the wrong type to a function.
message: A useful function for sending messages.

Node:Data types, Next:Args as Variable or List, Previous:Arguments, Up:Arguments

引数のデータ型

関数に渡すデータの型は、関数が使用する情報の種類に応じて決まる。 +は数を加算するので、 +のような関数への引数は数値である必要がある。別の関数では別の種類のデータの引数が必要である。

たとえば、関数concatは複数の文字列を繋いで1つの文字列を生成する。したがって、引数は文字列である。文字列abcとdefを繋ぐ（concatinate）と、 1つの文字列abcdefが作られる。これはつぎの式を評価するとわかる。

(concat "abc" "def")

この式を評価して得られる値は"abcdef"である。

substringのような関数は、引数として文字列と数を取る。この関数は文字列の一部分、つまり、第1引数の部分文字列を返す。この関数は3つの引数を取る。第1引数は文字列であり、第2引数と第3引数は数で、部分文字列の開始位置と終了位置を示す。これらの数は、文字列の先頭からの（空白や句読点を含む）文字の個数である。

たとえば、つぎを評価すると、

(substring "The quick brown fox jumped." 16 19)

エコー領域には"fox"と表示される。引数は、1つの文字列と2つの数である。

substringに渡された文字列は、空白で区切られた複数の単語ではあるが1つのアトムである。 Lispは、2つの二重引用符のあいだにあるものを、たとえ空白があいだにあっても文字列として扱う。関数substringは、他の方法では不可分なアトムから一部分を切り出すので、「アトム粉砕機」の一種と考えてもよい。しかし、substringは、文字列である引数から部分文字列を切り出すことができるだけであり、数やシンボルなどのそれ以外の種類のアトムは扱えない。

Node:Args as Variable or List, Next:Variable Number of Arguments, Previous:Data types, Up:Arguments

引数としての変数やリストの値

引数は、評価したときに値を返すシンボルでもよい。たとえば、シンボルfill-columnそのものを評価すると数を返す。この数は加算に使える。つぎの式のうしろにカーソルを置いてC-x C-eとタイプする。

(+ 2 fill-column)

fill-columnを単独で評価した値より2だけ大きな値が得られる。筆者の場合には、fill-columnの値は72なので、結果は74である。

このように、評価すると値を返すシンボルを引数に使えるのである。さらに、評価すると値を返すリストを引数に使うこともできる。たとえば、つぎの式では、関数concatへの引数は、文字列"The "と" red foxes."、さらに、リスト(+ 2 fill-column)である。

(concat "The " (+ 2 fill-column) " red foxes.")

この式を評価すると、エコー領域には"The 74 red foxes."と表示される（最終結果の文字列に空白が含まれるように、単語Theの直後と単語redの直前には空白が必要である）。

Node:Variable Number of Arguments, Next:Wrong Type of Argument, Previous:Args as Variable or List, Up:Arguments

可変個数の引数

concat、+、*などのある種の関数は、任意個数の引数を取る（*は乗算のシンボルである）。これは、以下の式のおのおのを通常の方法で評価するとわかる。 =>のあとのテキストがエコー領域に表示され、 =>は「の評価結果は」と読めばよい。

まず、関数に引数がない場合にはつぎのとおりである。

(+)       => 0

(*)       => 1

つぎは、関数に引数が1つの場合である。

(+ 3)     => 3

(* 3)     => 3

今度は、関数に引数が3つある場合である。

(+ 3 4 5) => 12

(* 3 4 5) => 60

Node:Wrong Type of Argument, Next:message, Previous:Variable Number of Arguments, Up:Arguments

引数に誤った型のオブジェクトを指定

誤った型の引数を関数へ渡すと、Lispインタープリタはエラーメッセージを生成する。たとえば、関数+は引数として数を仮定する。数のかわりにクオートしたシンボルhelloを与えてみよう。つぎの式の直後にカーソルを置いてC-x C-eとタイプする。

(+ 2 'hello)

そうすると、エラーメッセージを得る。何が起こったかというと、+は数2に'helloが返す値を加算しようとしたのだが、'helloが返した値はシンボルhelloであり、数ではない。加算できるのは数のみである。したがって、+は加算を実行できなかったのである。

普通、エラーメッセージは有用なようになっているので、読み方がわかれば意味がわかる。エラーメッセージはつぎのとおりである。

Wrong type argument: integer-or-marker-p, hello

エラーメッセージの最初の部分は簡単で、 Wrong type argument、つまり、引数の型がまちがっているである。つぎは、不思議な専門用語でinteger-or-marker-pである。これは、+が仮定する引数の種類を伝えようとしているのである。

シンボルinteger-or-marker-pの意味は、Lispインタープリタが渡された情報（引数の値）が整数（つまり数）かマーカー（バッファ内の位置を表す特殊なオブジェクト）かどうかを調べようとしているということである。つまり、加算すべき整数が+に与えられたかどうかを検査したのである。このとき、引数が、Emacs Lispに特有の機能であるマーカーかどうかも検査する（Emacsでは、バッファ内の位置をマーカーで記録する。コマンドC-@やC-<SPC>でマークを設定すると、その位置はマーカーとして保存される。マークは数として扱うことができ、バッファの先頭からのその位置までの文字の個数である）。 Emacs Lispでは、+でマーカー位置の数値を数として加算できる。

integer-or-marker-pのpは、 Lispプログラミングの早い時期に始まった慣習である。 pは「述語（predicate）」の略である。初期のLisp研究者が用いた専門用語では、述語とはある性質が真か偽か調べる関数を意味する。したがって、pがあることで、integer-or-marker-pは、与えられた引数が整数であるかマーカーであるかの真偽を調べる関数の名前であることがわかる。 pで終わるそのほかのLispシンボルには、引数の値が0であるかを調べる関数zerop、引数がリストであるかを調べる関数listpがある。

エラーメッセージの最後の部分はシンボルhelloである。これは+に渡された引数の値である。正しい型のオブジェクトが加算に渡されれば、渡された値はhelloのようなシンボルではなく37のような数であるはずである。そうであったならば、エラーメッセージが表示されることはなかったのである。

Node:message, Previous:Wrong Type of Argument, Up:Arguments

関数`message`

+のように、関数messageは任意個数の引数を取る。この関数はユーザーにメッセージを表示するために使うので、ここで説明しておくのがよいであろう。

メッセージはエコー領域に表示される。たとえば、つぎのリストを評価すると、エコー領域にメッセージが表示される。

(message "This message appears in the echo area!")

二重引用符のあいだの文字列は1つの引数であり、一塊で表示される（ここでの例では、エコー領域に表示されるメッセージは二重引用符で囲まれる。これは、関数messageが返した値を見ているからである。プログラム内でのmessageのほとんどの使い方では、副作用としてエコー領域にテキストが表示されるので、表示には引用符は含まれない。このような例について詳しくは、 See multiply-by-seven in detail）。

さて、文字列の中に%sがある場合、関数messageは%sをそのとおりに表示することはなく、文字列のあとに続く引数を調べる。第2引数を評価し、その値を文字列の%sの位置に表示する。

つぎの式の直後にカーソルを置いてC-x C-eとタイプしてみる。

(message "The name of this buffer is: %s." (buffer-name))

Infoでは、エコー領域に"The name of this buffer is: *info*."と表示されるはずである。関数buffer-nameはバッファ名を文字列として返し、それを関数messageが%sの位置に挿入する。

値を10進数として表示するには%sのかわりに%dを使う。たとえば、fill-columnの値を含んだメッセージをエコー領域に表示するにはつぎの式を評価する。

(message "The value of fill-column is %d." fill-column)

筆者のシステムでは、このリストを評価するとエコー領域に "The value of fill-column is 72."と表示される。

文字列の中に複数の%sがあれば、文字列のあとに続く最初の引数の値が最初の%sの位置に表示され、 2番目の引数の値が2番目の%sの位置に表示されると続く。たとえば、つぎの式を評価すると

(message "There are %d %s in the office!"
         (- fill-column 14) "pink elephants")

エコー領域に少々妙なメッセージが表示される。筆者のシステムでは"There are 58 pink elephants in the office!"となる。

式(- fill-column 14)が評価され、その結果の数が%dの位置に挿入される。二重引用符の中の文字列"pink elephants"は 1つの引数として扱われて%sの位置に挿入される（つまり、数と同様に、二重引用符で囲まれた文字列を評価するとそれ自身となる）。

最後は少々複雑な例で、数の計算を示すとともに、 %sと置き換わるテキストを生成する式を式の内側で使う方法を示す。

(message "He saw %d %s"
         (- fill-column 34)
         (concat "red "
                 (substring
                  "The quick brown foxes jumped." 16 21)
                 " leaping."))

この例では、messageには、文字列"He saw %d %s"、式(- fill-column 32)、関数concatで始まる式の3つの引数がある。 (- fill-column 32)を評価した結果は%dの位置に挿入され、 concatで始まる式の値は%sの位置に挿入される。

筆者の場合、この式を評価するとエコー領域に "He saw 38 red foxes leaping."と表示される。

Node:set & setq, Next:Summary, Previous:Arguments, Up:List Processing

変数への値の設定

変数に値を与える方法はいくつかある。 1つの方法は関数setか関数setqを使うことである。別の方法はlet（see let）を使うことである（この過程を専門用語では変数を値に束縛（bind）するという）。

つぎの節ではsetとsetqの動作を説明するとともに、引数がどのように渡されるかも説明する。

Using set: Setting values.
Using setq: Setting a quoted value.
Counting: Using setq to count.

Node:Using set, Next:Using setq, Previous:set & setq, Up:set & setq

`set`の使い方

シンボルflowersの値としてリスト'(rose violet daisy buttercup)を設定するには、つぎの式の直後にカーソルを移動してC-x C-eとタイプして式を評価する。

(set 'flowers '(rose violet daisy buttercup))

エコー領域には、リスト(rose violet daisy buttercup)が表示される。これは、関数setが返したものである。副作用として、シンボルflowersにリストが束縛される。つまり、シンボルflowersは変数とみなされ、その値としてリストが与えられるのである（値を設定するこの過程は、Lispインタープリタにとっては副作用であるが、人間にとっては興味のある主要な効果である。各Lisp関数はエラーがなければ値を返す必要があるが、関数の目的は副作用だけの場合もある）。

set式を評価したあとは、シンボルflowersを評価することができ、設定した値が返される。つぎのシンボルの直後にカーソルを置いてC-x C-eとタイプする。

flowers

flowersを評価すると、エコー領域にリスト(rose violet daisy buttercup)が表示される。

'flowers、つまり、直前にクオートを置いた変数を評価すると、エコー領域にはシンボルflowersそのものが表示される。つぎの例を試してみよう。

'flowers

setを使う場合、いずれの引数も評価してほしくない場合には、両方の引数をクオートする必要があることに注意してほしい。上の例では、変数flowersもリスト(rose violet daisy buttercup)も評価したくないので、両者をクオートした（setの第1引数をクオートせずに使うと、まず最初に第1引数が評価される。上の例でこれを行うと、flowersには値がないので、 Symbol's value as variable is voidというエラーメッセージを得る。一方、flowersを評価して値が返される場合には、 setはその返された値に値を設定しようとする。このように関数を動作させたい場面もあるが、そのような場面は少ない）。

Node:Using setq, Next:Counting, Previous:Using set, Up:set & setq

`setq`の使い方

実用上、setの第1引数をほとんどつねにクオートするはずである。 setで第1引数をクオートする組み合わせは多用されるので、スペシャルフォームsetqが用意してある。このスペシャルフォームはsetとほとんど同じであるが、第1引数を自動的にクオートするので、引用符をタイプする必要はない。さらに、便利なように、setqでは、複数の異なる変数に異なる値を 1つの式で設定することもできる。

setqを用いて、変数carnivoresの値をリスト'(lion tiger leopard)とするには、つぎの式を使う。

(setq carnivores '(lion tiger leopard))

これはsetを用いた場合とほぼ同じであるが、 setqでは第1引数を自動的にクオートするのが異なる（setqのqは、クオート（quote）を意味する）。 setを用いる場合は、つぎのようにする。

(set 'carnivores '(lion tiger leopard))

さらに、setqは、複数の異なる変数に異なる値を代入するためにも使える。第1引数には第2引数の値を束縛し、第3引数には第4引数の値を束縛し、……と続く。たとえば、シンボルtreesに樹木名のリストを、シンボルherbivoresにハーブの名前のリストを代入するにはつぎのようにする。

(setq trees '(pine fir oak maple)
      herbivores '(gazelle antelope zebra))

（式を1行に書いてもよいが、ページの幅に収まらない。人間には、適切にフォーマットしたリストは読みやすいものである。）

「代入」という用語を用いたが、setやsetqの動作を考える別の方法もある。つまり、setやsetqは、シンボルがリストを指す（point） ようにするのである。この考え方は非常によく使われ、うしろの章では、名前の一部に「pointer」があるシンボルを見ることになる。この名称は、シンボルには特にリストなどの値が結び付けらている、あるいは、シンボルがリストを「指す」ように設定されていることに由来する。

Node:Counting, Previous:Using setq, Up:set & setq

数え上げ

ここではカウンタでsetqを使う方法を示そう。プログラムのある部分を何回繰り返したかを数え上げるために使える。まず、変数に0を設定する。そして、プログラムを繰り返すたびに1を加える。そのためには、カウンタの役割を果たす変数と2つの式、つまり、カウンタ変数を0に初期化するsetqを用いた式と、評価するたびにカウンタを増加するsetqを用いた式が必要である。

(setq counter 0)                ; 初期化式

(setq counter (+ counter 1))    ; 増加式

counter                         ; カウンタ

（;以降のテキストは注釈である。 See Change a defun。）

これらの最初の式、つまり、初期化式(setq counter 0)を評価してから 3番目の式counterを評価すると、エコー領域には数0が表示される。続いて、2番目の式、増加式(setq counter (+ counter 1))を評価すると、カウンタの値は1になる。そのため、ふたたびcounterを評価するとエコー領域には数1が表示される。 2番目の式を評価するたびに、カウンタの値は増加する。

増加式(setq counter (+ counter 1))を評価するとき、 Lispインタープリタは、もっとも内側のリスト、つまり、加算を最初に評価する。このリストを評価するには、変数counterと数1を評価する必要がある。変数counterを評価するとその現在値が得られる。この値と数1が+に渡され加算される。この合計値がもっとも内側のリストの値として返され、さらに、変数counterにこの新しい値を設定するsetqへ渡される。したがって、変数counterの値が変更されるのである。

Node:Summary, Next:Error Message Exercises, Previous:set & setq, Up:List Processing

まとめ

Lispを学ぶことは、登り始めがもっとも険しい小山を登るようなものである。読者はもっとも困難な部分を登り終えたのであり、あとは、先へ進むほど楽になる。

本章をまとめるとつぎのようになる。

Lispプログラムは式から成り立ち、式とはリストやアトムである。
リストは、0個以上のアトムやリストを空白で区切って括弧で囲ったものである。リストは空でもよい。
アトムとは、forward-paragraphのような複数個の文字のシンボル、 +のような1文字のシンボル、二重引用符で囲った文字列、あるいは、数である。
数を評価するとそれ自身になる。
二重引用符で囲った文字列を評価するとそれ自身になる。
シンボルそのものを評価すると、その値が返される。
リストを評価するとき、Lispインタープリタはリストの先頭のシンボルを調べ、そのシンボルに束縛された関数定義を探す。そして、関数定義の命令列を実行する。
引用符'は、Lispインタープリタに対して続く式を字面のとおりに返すことを指示し、引用符がない場合のようには評価しない。
引数とは関数へ渡される情報である。関数への引数は、関数を先頭要素とするリストの残りの要素を評価することで計算される。
関数を評価すると（エラーがなければ）つねに値を返す。さらに、「副作用」と呼ばれるなんらかの動作を伴うこともある。多くの場合、関数の主要な目的は副作用を起こすことである。

Node:Error Message Exercises, Previous:Summary, Up:List Processing

演習問題

簡単な演習問題をあげておく。

括弧の中にはない適当なシンボルを評価してエラーメッセージを生成してみよ。
括弧の中に置いた適当なシンボルを評価してエラーメッセージを生成してみよ。
1つずつではなく2つずつ増やすカウンタを作成せよ。
評価するとエコー領域にメッセージを表示する式を書いてみよ。

Node:Practicing Evaluation, Next:Writing Defuns, Previous:List Processing, Up:Top

評価の練習

Emacs Lispにおける関数定義の書き方を学ぶまえに、これまでに説明してきたさまざまな式の評価に時間を割いてみるのも有益であろう。リストの先頭（あるいは唯一）の要素が関数であるようなリストである。バッファに関する関数は、単純でしかも興味深いので、これらから始めよう。本節では、それらのいくつかを評価してみる。他の節では、バッファに関連した数個の別の関数のコードを調べて、それらがどのように書かれているかを見てみる。

How to Evaluate: Typing editing commands or C-x C-e causes evaluation.
Buffer Names: Buffers and files are different.
Getting Buffers: Getting a buffer itself, not merely its name.
Switching Buffers: How to change to another buffer.
Buffer Size & Locations: Where point is located and the size of the buffer.
Evaluation Exercise:

Node:How to Evaluate, Next:Buffer Names, Previous:Practicing Evaluation, Up:Practicing Evaluation

Emacs Lispに、カーソルの移動や画面上のスクロールなどの 編集コマンドを与えるたびに、先頭要素が関数である式を評価している。 Emacsはこのようにして動いている。

キーをタイプすると、Lispインタープリタに式を評価させることになり、そのようにして操作しているのである。テキストをタイプした場合でさえも、Emacs Lispの関数を評価しており、タイプした文字を単に挿入する関数self-insert-commandを使った関数を評価しているのである。キーをタイプすることで評価される関数は、対話的（interactive）関数とかコマンド（commands）と呼ばれる。関数を対話的にする方法については、関数定義の書き方の章で例を示す。 See Interactive。

キーボードコマンドをタイプする以外にも、式を評価する方法についてはすでに説明した。すなわち、リストの直後にカーソルを置いてC-x C-eとタイプするのである。本節の残りでは、この方法を用いる。これ以外にも式を評価する方法があり、必要に応じて他の節で説明する。

これからの数節で説明する関数は、評価を練習すること以外にも、それ自体、重要なものである。これらの関数を学ぶことで、バッファとファイルの違い、バッファを切り替える方法、バッファ内での位置を調べる方法が明らかになる。

Node:Buffer Names, Next:Getting Buffers, Previous:How to Evaluate, Up:Practicing Evaluation

バッファ名

2つの関数、buffer-nameとbuffer-file-nameが、ファイルとバッファの違いを示してくれる。式(buffer-name)を評価すると、エコー領域にバッファ名が表示される。 (buffer-file-name)を評価すると、バッファが参照するファイル名がエコー領域に表示される。通常、(buffer-name)が返す名前は、そのバッファが参照するファイルの名前と同じであり、 (buffer-file-name)が返す名前はファイルの完全パス名である。

ファイルとバッファは異なる2つの実体である。ファイルは（削除しない限り）コンピュータに恒久的に記録された情報である。一方、バッファはEmacsの内部にある情報であり、（バッファを削除するか）編集作業を終了すると消えてしまう。通常、バッファにはファイルからコピーした情報が収められている。これを、バッファがファイルを訪れる（visiting）という。このコピーを処理したり修正したりしているのである。バッファを変更しても保存しない限り、ファイルは変更されない。バッファを保存すると、バッファはファイルにコピーされ、その結果、恒久的に保存されるのである。

GNU EmacsのInfoを使って読んでいる場合には、つぎのそれぞれの式の直後にカーソルを置いてC-x C-eとタイプすれば、それぞれの式を評価できる。

(buffer-name)

(buffer-file-name)

筆者がこれを行うと、(buffer-name)を評価して返される値は "introduction.texinfo"であり、 (buffer-file-name)を評価して返される値は "/gnu/work/intro/introduction.texinfo"である。前者はバッファ名であり、後者はファイル名である（各式には括弧があるので、Lispインタープリタはbuffer-nameと buffer-file-nameを関数として扱う。括弧がないと、インタープリタは変数としてシンボルを評価しようとする。 See Variables）。

ファイルとバッファの違いにもかかわらず、バッファを意味してファイルといったり、その逆のいい方をする場合が多い。もちろん、ほとんどの人は、「すぐにファイルに保存するバッファを編集している」というよりは、「ファイルを編集している」という。その人が何を意図しているかは、ほとんどの場合、文脈から明らかである。しかし、コンピュータプログラムに関していえば、コンピュータは人間のように賢くはないので、つねに違いを心にとめておく必要がある。

ところで、用語「バッファ（buffer）」は、衝突力を弱めるクッションを意味する語に由来する。初期のコンピュータでは、ファイルとコンピュータの中央処理装置のあいだの相互作用のクッションがバッファであった。ファイルを格納するドラムやテープと中央処理装置とは、互いに大きく異なる装置であり、それぞれ固有の動作速度で動いていた。バッファにより、これらが効率よく協調動作することが可能であった。しだいに、バッファは、中間の一時的な保管場所から、実際の処理を行う場所へと進展していった。これは、小さな港が大都市に発展したり、貨物を船に積み込むまえの一時的な保管倉庫がその重要性のためにビジネスや文化の中心に進展したことに似ている。

すべてのバッファがファイルに関連付けられるわけではない。たとえば、ファイル名をいっさい指定せずにコマンドemacsだけをタイプして Emacsを開始した場合には、画面にはバッファ*scratch*が表示されて Emacsが動き出す。このバッファはいかなるファイルも訪問していない。同様に、バッファ*Help*にはいかなるファイルも関連付けられていない。

バッファ*scratch*に切り替えてから、(buffer-name)と入力してその直後にカーソルを置いてC-x C-eとタイプしてこの式を評価すると、名前"*scratch*"が返されてエコー領域に表示される。 "*scratch*"がバッファの名前である。しかし、バッファ*scratch*で(buffer-file-name)とタイプしてこれを評価すると、エコー領域にはnilと表示される。 nilの語源はラテン語の「無（nothing）」を意味する単語であり、この場合、バッファ*scratch*にはいかなるファイルも関連付けられていないことを意味する（Lispでは、nilは「偽（false）」をも意味し、空リスト()の同義語でもある）。

バッファ*scratch*を使っているときに、式の評価結果をエコー領域ではなくバッファ*scratch*そのものに表示したい場合には、C-x C-eのかわりにC-u C-x C-eとタイプする。これにより、式の直後に返された値が表示される。バッファはつぎのようになる。

(buffer-name)"*scratch*"

Infoは読み出し専用なのでバッファの内容を変更できないため、 Infoではこの方法を使えない。しかし、編集可能なバッファならば、この方法を使える。コードや（本書のような）文書を書くときには、この機能はとても便利である。

Node:Getting Buffers, Next:Switching Buffers, Previous:Buffer Names, Up:Practicing Evaluation

バッファの取得

関数buffer-nameは、バッファの名前を返す。バッファそのものを取得するには、別の関数current-bufferが必要である。この関数をコードで使うと、バッファそのものを取得することになる。

名前とその名前が表すオブジェクトや実体とは互いに異なるものである。読者自身は読者の名前ではない。読者は、その名前で他人が参照する「人」である。読者がGeorgeと話したいと頼んだときに、G、e、o、r、 g、eと文字が書かれたカードを渡されたら、驚くであろうが、満足はしないであろう。名前と話をしたいのではなくて、その名前で参照される人と話をしたいのである。バッファも同様である。一時的バッファの名前は*scratch*であるが、名前そのものがバッファではない。バッファそのものを得るにはcurrent-bufferのような関数を使う必要がある。

しかし、多少込み入った事情もある。ここで試すように、式でcurrent-bufferを評価するとバッファの内容ではなくバッファの表示形式が表示される。 Emacsがこのように動作する理由は2つある。バッファには数千もの行が含まれることもあるので、これを簡便に表示するには長すぎる。また、バッファの内容は同じであっても、名前が異なるバッファもありえるので、それらを区別できる必要がある。

例を示そう。

(current-buffer)

いつものようにこの式を評価すると、エコー領域には#<buffer *info*>と表示される。バッファ名ではなく、バッファそのものを表す特殊な表示形式である。

数やシンボルはプログラムに入力できるが、バッファの表示形式を入力することはできない。バッファそのものを得る唯一の方法は、 current-bufferのような関数を使うことである。

関連する関数としてother-bufferがある。これは、現在使用しているバッファの直前に選択していたバッファを返す。たとえば、バッファ*scratch*から現在のバッファに切り替えた場合には、 other-bufferはバッファ*scratch*を返す。

つぎの式を評価してみよう。

(other-buffer)

エコー領域には、#<buffer *scratch*>、あるいは、今のバッファに切り替えるまえのバッファの表示形式が表示される。

Node:Switching Buffers, Next:Buffer Size & Locations, Previous:Getting Buffers, Up:Practicing Evaluation

バッファの切り替え

関数other-bufferの目的は、バッファそのものを引数に必要とする関数にバッファを与えることである。別のバッファに切り替えるためother-bufferとswitch-to-bufferとを使ってみよう。

まず、関数switch-to-bufferの概要を説明しておこう。 (buffer-name)を評価するためにInfoからバッファ*scratch*へ切り替えるときには、C-x bとタイプし、ミニバッファに表示された切り替え先バッファ名のプロンプトに*scratch*と入力したであろう。 C-x bとタイプすると、LispインタープリタはEmacs Lispの対話的関数 switch-to-bufferを評価する。すでに説明したように、Emacsはこのように動作する。キー列が異なれば、異なる関数を呼び出す、つまり、実行するのである。たとえば、C-fとタイプするとforward-charを呼び出し、 M-eとタイプするとforward-sentenceを呼び出すなどである。

switch-to-bufferを書いた式に切り替え先のバッファを指定すれば、 C-x bと同じようにバッファを切り替えられる。

たとえば、つぎのLispの式である。

(switch-to-buffer (other-buffer))

リストの先頭要素はシンボルswitch-to-bufferであるので、 Lispインタープリタはこれを関数として扱い、それに結び付けられている命令列を実行する。しかし、そのまえに、インタープリタはother-bufferが括弧の内側にあることを検出して、まずそのシンボルを処理する。 other-bufferはこのリストの先頭（かつ唯一の）要素なので、 Lispインタープリタはこの関数を呼び出す。これは別のバッファを返す。続いて、インタープリタは、この別のバッファを引数として switch-to-bufferに渡して実行し、そのバッファへ切り替える。 Infoで読んでいる場合には、この式を評価してみてほしい（Infoのバッファに戻るにはC-x b <RET>とタイプする）。

本書の以降の節のプログラム例では、関数switch-to-bufferよりも関数set-bufferを多用する。これは、コンピュータプログラムと人間との違いによるものである。人間には目があるので、端末画面で作業中のバッファを見ることを期待する。これは当然のことであり、これ以上説明する必要はなかろう。一方、プログラムに目はない。コンピュータプログラムがバッファを処理するときに、端末画面でバッファが見えている必要はない。

switch-to-bufferは人間向けに考えられたものであり、異なる2つのことを行う。 Emacsの注意をバッファに向けることと、ウィンドウに表示するバッファをそのバッファに切り替えることである。一方、set-bufferは1つのことだけを行い、コンピュータプログラムの注意をそのバッファに向けるだけである。画面上のバッファは変更しない（もちろん、コマンドが終了するまでは、何も起こらない）。

ここでは、新たな専門用語呼び出し（call）も使った。リストの先頭のシンボルが関数であるようなリストを評価すると、その関数を呼び出すのである。この用語は、鉛管工を「呼ぶ」とパイプの洩れを修理してくれるのと同じように、関数は、「呼び出す」と何かを行ってくれる実体であるという考え方からきている。

Node:Buffer Size & Locations, Next:Evaluation Exercise, Previous:Switching Buffers, Up:Practicing Evaluation

バッファサイズとポイントの位置

最後に、buffer-size、point、point-min、point-max などの比較的単純な関数を見てみよう。これらにより、バッファのサイズやバッファ内のポイントの位置に関する情報を得ることができる。

関数buffer-sizeは、カレントバッファのサイズを返す。つまり、バッファ内の文字の個数を返す。

(buffer-size)

いつものように、この式の直後にカーソルを置いてC-x C-eとタイプすれば、この式を評価できる。

Emacsでは、カーソルの現在位置をポイント（point）と呼ぶ。式(point)は、バッファの先頭からポイントまでの文字の個数として、カーソルの位置を返す。

いつものようにつぎの式を評価すると、バッファ内でのポイントまでの文字数を調べることができる。

(point)

筆者の場合、この値は65724であった。本書の例では、関数pointを多用している。

ポイントの値は、当然であるが、バッファ内での位置に依存する。ここでつぎの式を評価すると、より大きな数になる。

(point)

筆者の場合、ポイントの値は66043となり、 2つの式のあいだには（空白を含めて）319文字あることがわかる。

関数point-minは、pointとほぼ同じであるが、カレントバッファにおいて取ることが可能なポイントの最小値を返す。ナロイング（narrowing）していなければ、これは数1である（ナロイング（偏狭化）とは、プログラムなどで操作するバッファの範囲を制限する機構である。 See Narrowing & Widening）。同じように、関数point-maxは、カレントバッファにおいて取ることが可能なポイントの最大値を返す。

Node:Evaluation Exercise, Previous:Buffer Size & Locations, Up:Practicing Evaluation

演習問題

適当なファイルを読み込み、その中ほどに移動する。バッファ名、ファイル名、長さ、ファイル内での位置のそれぞれを調べてみよ。

Node:Writing Defuns, Next:Buffer Walk Through, Previous:Practicing Evaluation, Up:Top

関数定義の書き方

リストを評価するとき、Lispインタープリタは、リストの先頭のシンボルに関数定義が結び付けられているかどうかを調べる。いいかえれば、シンボルが関数定義を指すかどうかを調べる。そうならば、コンピュータは定義内の命令列を実行する。関数定義を持つシンボルを、単に関数と呼ぶ（しかし、正確には、定義が関数であり、シンボルはそれを指すだけである）。

Primitive Functions: Some functions are written in C.
defun: The defun special form.
Install: Install a Function Definition.
Interactive: Making a function interactive.
Interactive Options: Different options for interactive.
Permanent Installation: Installing code permanently.
let: Creating and initializing local variables.
if: What if?
else: If--then--else expressions.
Truth & Falsehood: What Lisp considers false and true.
save-excursion: Keeping track of point, mark, and buffer.
Review:
defun Exercises:

Node:Primitive Functions, Next:defun, Previous:Writing Defuns, Up:Writing Defuns

すべての関数は別の関数を用いて定義されているが、プログラミング言語Cで書かれた少数の基本操作（primitive）関数はそうではない。関数の定義を書くときには、他の関数を構成部品として用いてEmacs Lispで書く。そのとき使用する関数は、それ自身Emacs Lispで（読者自身が）書いたものであったり、 Cで書かれた基本操作関数である。基本操作関数は、Emacs Lispで書いたものとまったく同じように使え、そのように動作する。これらをCで書いてあるのは、Cが動く十分な能力を持ったコンピュータならば容易にGNU Emacsを動作できるようにするためである。

強調しておくが、Emacs Lispでコードを書くとき、 Cで書いた関数の使い方とEmacs Lispで書いた関数の使い方とは区別しない。両者の違いは無関係なのである。わざわざ言及したのは、興味深いと考えたからである。既存の関数がEmacs Lispで書いてあるのか、Cで書いてあるのかは、特に調べない限りわからない。

Node:defun, Next:Install, Previous:Primitive Functions, Up:Writing Defuns

スペシャルフォーム`defun`

Lispでは、mark-whole-bufferのようなシンボルには、関数として呼ばれたときにコンピュータが実行するコードが結び付けられている。このコードを関数定義（function definition）と呼び、シンボルdefun（define function（関数を定義する）の略）で始まる Lispの式を評価することで作成する。 defunは、その引数を通常のようには評価しないので、スペシャルフォーム（special form）と呼ばれる。

以下の節では、mark-whole-bufferのようなEmacsのソースコードの関数定義を調べる。本節では、関数定義がどのようなものかを理解してもらうために、簡単な関数定義を説明する。例を簡単にするために、算術演算を使った関数定義を取り上げる。算術演算を使った例が嫌いな人もいるであろうが、落胆しないでほしい。残りの節で説明するコードには、算術演算や数学はほとんどない。そのほとんどは、テキストを扱う。

関数定義は、単語defunに続く最大で5つの部分から成る。

関数定義を結び付けるシンボルの名前。
関数に渡される引数のリスト。関数に引数を渡さない場合には、空リスト()を指定する。
関数の説明文（省略できるが、付けることを強く推奨する）。
M-xに続けて関数名を入力したり、適当なキー列をタイプして使えるように、関数を対話的にするための式。省略できる。
コンピュータに動作を命じるコード。関数定義の本体（body）。

関数定義の5つの部分を、つぎのような雛型にまとめて考えるとわかりやすい。

(defun 関数名 (引数...)
  "省略可能な関数の説明文..."
  (interactive 引数に関する情報) ;    省略可能
  本体...)

例として、引数を7倍する関数のコードを示す（この例は、対話的関数ではない。これについては、See Interactive）。

(defun multiply-by-seven (number)
  "Multiply NUMBER by seven."
  (* 7 number))

この定義は、括弧とシンボルdefunで始まり、関数名が続く。

関数名のあとには、関数に渡される引数のリストが続く。このリストを、引数リスト（argument list）と呼ぶ。この例では、リストには1つの要素、シンボルnumberのみがある。関数が使われると、関数への引数として使われた値がこのシンボルに束縛される。

引数の名前としては、単語numberのかわりに別の名前を指定してもよい。たとえば、単語multiplicandでもよい。引数の値の種類がわかるように単語numberを選んだ。同様に、関数の実行において引数の役割を表すmultiplicand（被乗数）を選んでもよかった。引数をfoogleとも書けるが、これでは何を意味するか不明なのでよくない。名前の選択はプログラマの責任であり、関数の意味を明らかにするように選ぶべきである。

引数リストのシンボルにはどんな名前を選んでもよく、他の関数で使っているシンボルの名前でもよい。引数リストに使用した名前は、その定義において私的である。つまり、その定義において名前で参照した実体は、その関数定義の外部で同じ名前で参照する実体とは別である。たとえば、家族のあいだでは読者の愛称は「ショーティ」だとしよう。家族の誰かが「ショーティ」といった場合には、読者のことである。しかし、別の家族が「ショーティ」といった場合には、別の誰かのことである。引数リスト中の名前は関数定義に私的なので、関数本体の内側でそのようなシンボルの値を変更しても、関数の外部の値には影響しない。 let式でも同様な効果が得られる（See let）。

引数リストには、関数の説明文である文字列が続く。 C-h fに続けて関数名をタイプしたときに表示されるのは、この文字列である。 aproposなどのある種のコマンドでは複数行の説明文のうち最初の1行のみを表示するので、関数の説明文を書く場合には、最初の1行を1つの文にすべきである。また、C-h f（describe-function）で表示した場合に、表示が変にならないように、説明文の2行目以降を字下げしないこと。説明文は省略できるが、あると有益なので、読者が書くほとんどの関数には指定するべきである。

上の例の3行目は関数定義の本体である（当然、ほとんどの関数の定義は、この例よりも長いはずである）。ここでは、本体はリスト(* 7 number)であり、 numberの値を7倍する（Emacs Lispでは、+が加算であるように、*は乗算である）。

関数multiply-by-sevenを使うときには、引数numberは読者が指定した実際の数に評価される。 multiply-by-sevenの使い方を示すが、まだ、評価しないでほしい。

(multiply-by-seven 3)

関数を実際に使用すると、次節の関数定義に指定したシンボルnumberには、値3が与えられる、つまり、「束縛」される。関数定義ではnumberは括弧の内側にあるが、関数multiply-by-sevenに渡される引数は括弧の内側にはないことに注意してほしい。関数定義において引数を括弧で囲むのは、コンピュータが引数リストの終わりと関数定義の残りの部分を区別できるようにするためである。

さて、この例を評価すると、エラーメッセージを得る（実際に試してみるとよい）。これは、関数定義を書いたけれども、その定義をコンピュータに与えていないからである。つまり、関数定義をEmacsにインストール（あるいは、ロード）していないからである。関数のインストールとは、Lispインタープリタに関数の定義を教える操作である。次節では、インストールについて説明する。

Node:Install, Next:Interactive, Previous:defun, Up:Writing Defuns

関数定義のインストール

EmacsのInfoで読んでいる場合には、multiply-by-sevenの関数定義を評価してから(multiply-by-seven 3)を評価すれば、関数multiply-by-sevenを試すことができる。関数定義をもう一度つぎにあげておく。関数定義の最後の括弧の直後にカーソルを置いてC-x C-eとタイプする。すると、エコー領域にmultiply-by-sevenと表示される（関数定義を評価すると、その値として定義された関数の名前が返される）。同時に、この操作で関数定義がインストールされるのである。

(defun multiply-by-seven (number)
  "Multiply NUMBER by seven."
  (* 7 number))

このdefunを評価すると、Emacsにmultiply-by-sevenをインストールしたことになる。これで、forward-wordや編集関数などと同じく、この関数もEmacsの一部である（Emacsを終了するまで、multiply-by-sevenはインストールされたままである。 Emacs起動時に自動的にコードをロードするには Permanent Installationを参照）。

つぎの例を評価すれば、multiply-by-sevenをインストールした効果がわかる。つぎの式の直後にカーソルを置いてC-x C-eとタイプする。エコー領域に数21が表示されるはずである。

(multiply-by-seven 3)

必要ならば、C-h f（describe-function）に続けて関数名 multiply-by-sevenをタイプすれば、関数の説明文を読むことができる。これを行うと、つぎのような内容のウィンドウ*Help*が画面に現れる。

multiply-by-seven:
Multiply NUMBER by seven.

（画面を単一のウィンドウに戻すには、C-x 1とタイプする。）

Change a defun: How to change a function definition.

Node:Change a defun, Previous:Install, Up:Install

関数定義の変更

multiply-by-sevenのコードを変更するには、書き変えればよい。旧版のかわりに新版をインストールするには、関数定義を再度評価する。 Emacsではこのようにコードを修正すればよく、非常に簡単である。

例として、7を掛けるかわりに、数そのものを7回足すように関数multiply-by-sevenを変更する。同じ結果を得るが、その方法が異なる。同時に、コードに注釈を加えよう。注釈とは、Lispインタープリタは無視するテキストであるが、人には有用であり意味を明らかにする。この例では、「第2版」が注釈である。

(defun multiply-by-seven (number)       ; 第2版
  "Multiply NUMBER by seven."
  (+ number number number number number number number))

セミコロン;に続けて注釈を書く。 Lispでは、行の中でセミコロンに続くものはすべて注釈である。注釈は行末で終わる。 2行以上にわたる注釈は、各行をセミコロンで始める。

注釈に関してより詳しくは、 Commentsや See Beginning a .emacs File。

この版の関数multiply-by-sevenをインストールするには、最初の版を評価したのと同じように評価すればよい。すなわち、最後の括弧の直後にカーソルを置いてC-x C-eとタイプする。

まとめると、Emacs Lispでコードを書くには、関数を書いてインストールしてテストし、必要に応じて、修正や機能強化して再インストールする。

Node:Interactive, Next:Interactive Options, Previous:Install, Up:Writing Defuns

関数を対話的にする

関数を対話的にするには、関数の説明文のあとにスペシャルフォームinteractiveで始まるリストを置く。こうすれば、M-xに続けて関数名をタイプするか、関数に束縛したキー列をタイプすれば対話的関数を起動できる。たとえば、next-lineを起動するにはC-nとタイプし、 mark-whole-bufferを起動するにはC-x hとタイプする。

対話的関数を対話的に呼び出した場合には、関数が返した値は自動的にはエコー領域に表示されない。これは、対話的関数を呼び出すのは、単語単位や行単位の移動などの副作用のためであり、返された値は必要ないからである。キーをタイプするたびに返された値をエコー領域に表示すると、とても煩わしい。

multiply-by-sevenの対話的な版を作って、スペシャルフォームinteractiveの使い方とエコー領域に値を表示する1つの方法を示そう。

コードはつぎのとおりである。

(defun multiply-by-seven (number)       ; 対話的版
  "Multiply NUMBER by seven."
  (interactive "p")
  (message "The result is %d" (* 7 number)))

このコードの直後にカーソルを置いてC-x C-eとタイプして、このコードをインストールする。エコー領域には関数名が表示されるはずである。そうすれば、C-u、数、M-x multiply-by-sevenとタイプして <RET>を押せば、このコードを使うことができる。エコー領域には、 The result is ...に続けて乗算結果が表示されるはずである。

より一般的には、このような関数を起動する方法は2つある。

C-u 3 M-x forward-sentenceのように、関数に渡すべき数を含む前置引数をタイプしてから、 M-xに続けて関数名をタイプする。あるいは、
C-u 3 M-eのような関数にバインドされたキー列をタイプする。

上のキー列の例は、どちらもポイントを文単位に3つ進める（multiply-by-sevenにはキーがバインドされていないので、キーバインドを使う例としては使えない）。

（コマンドをキーにバインドする方法については See Keybindings。）

前置引数を対話的関数に渡すには、 M-3 M-eのようにキー<META>に続けて数をタイプするか、 C-u 3 M-eのようにC-uに続けて数をタイプする（数をタイプせずにC-uだけをタイプすると、デフォルトは4）。

multiply-by-seven in detail: The interactive version.

Node:multiply-by-seven in detail, Previous:Interactive, Up:Interactive

対話的`multiply-by-seven`

スペシャルフォームinteractiveと関数messageの使い方を multiply-by-sevenで見てみよう。関数定義はつぎのとおりであった。

(defun multiply-by-seven (number)       ; 対話的版
  "Multiply NUMBER by seven."
  (interactive "p")
  (message "The result is %d" (* 7 number)))

この関数では、式(interactive "p")は、要素2個のリストである。 "p"は、前置引数を関数に渡すことをEmacsに指示するもので、その値を関数への引数として使う。

引数は数である。つまり、つぎの行のシンボルnumberには数が束縛される。

(message "The result is %d" (* 7 number))

たとえば、前置引数が5であったとすると、 Lispインタープリタはつぎのような行であるとして評価する（GNU Emacsで読んでいる場合には、読者自身がこの式を評価してほしい）。

(message "The result is %d" (* 7 5))

まず、インタープリタは内側のリスト(* 7 5)を評価する。値35が返される。つぎに、インタープリタは外側のリストを評価するが、それには、リストの第2要素以降の値を関数messageに渡す。

すでに説明したように、messageはユーザーに1行のメッセージを表示するために考えられたEmacs Lispの関数である（See message）。すなわち、関数messageは、%dや%sや%cを除いて、第1引数を字面のとおりにエコー領域に表示する。 %dや%sや%cの制御文字列があると、 2番目以降の引数を調べてその値を対応する制御文字列の位置に表示する。

対話的関数multiply-by-sevenでは、制御文字列としては%dを使っており、これは数を必要とする。 (* 7 5)を評価した結果は数35である。したがって、%dの位置に数35が表示されるので、メッセージはThe result is 35となる。

（関数multiply-by-sevenを呼んだときは、メッセージには二重引用符が付かないが、messageを呼んだときには、二重引用符のあいだにテキストが表示されることに注意してほしい。 messageを先頭要素とする式を評価したときには、 messageが返した値がエコー領域に表示されるが、関数内で用いた場合には、副作用としてmessageが二重引用符なしでテキストを表示するからである。）

Node:Interactive Options, Next:Permanent Installation, Previous:Interactive, Up:Writing Defuns

`interactive`の他のオプション

上の例のmultiply-by-sevenでは、 interactiveの引数として"p"を用いた。この引数は、ユーザーがタイプしたC-uや<META>に続く数を、関数への引数として渡すコマンドとして解釈するようにEmacsに指示する。 Emacsでは、あらかじめ定義された20個以上の文字をinteractiveに指定できる。ほとんどの場合、これらのオプションの数個を指定すれば、必要な情報を関数へ対話的に渡せる（See Interactive Codes）。

たとえば、文字rを指定すると、Emacsは、リージョンの開始位置と終了位置（ポイントとマークの現在値）を2つの引数として関数へ渡す。つぎのように使う。

(interactive "r")

一方、Bを指定すると、Emacsは関数にバッファ名を渡す。この場合、Emacsは、"BAppend to buffer: "のようなBに続く文字列をプロンプトとしてミニバッファに表示して、ユーザーに名前を問い合わせる。 Emacsはプロンプトを表示するだけでなく、<TAB>が押されると名前を補完する。

2つ以上の引数を取る関数では、 interactiveに続く文字列に要素を追加すれば各引数に情報を渡せる。このとき、各引数に情報を渡す順番は、リストinteractiveに指定した順番と同じである。文字列の各部分は、改行\nで区切る。たとえば、"BAppend to buffer: "に続けて、\nとrを指定する。こうすると、Emacsはバッファ名を問い合わせることに加えて、ポイントとマークの値を関数に渡す。つまり、引数は全部で3つである。

この場合、関数定義はつぎのようになり、 buffer、start、endの各シンボルには、バッファ、リージョンの開始位置、終了位置の現在値をinteractiveが束縛する。

(defun 関数名 (buffer start end)
  "説明文..."
  (interactive "BAppend to buffer: \nr")
  関数の本体...)

（プロンプトのコロンのうしろの空白は、プロンプトを表示したときに見やすくするためのものである。関数append-to-bufferでもこのようにしている。 See append-to-bufferm。）

引数がない関数の場合には、interactiveには何も指定しなくてよい。そのような関数では、単に式(interactive)を指定する。関数mark-whole-bufferは、このようになっている。

読者のアプリケーションにおいて、あらかじめ定義した文字では不十分な場合には、 interactiveにリストを指定すれば、独自の引数を渡せる。この技法について詳しくは、See interactive。

Node:Permanent Installation, Next:let, Previous:Interactive Options, Up:Writing Defuns

コードの恒久的インストール

関数定義を評価して関数定義をインストールすると、 Emacsを終了するまでは関数定義は有効である。新たにEmacsを起動したときには、関数定義を再度評価するまでは関数定義はインストールされない。

新たにEmacsを起動するたびに、自動的にコードをインストールしたくなるであろう。これにはいくつかの方法がある。

個人用のコードの場合には、個人用の初期化ファイル.emacsに関数定義のコードを入れておく。 Emacsを起動すると、個人用の.emacsが自動的に評価され、その中のすべての関数定義がインストールされる。 See Emacs Initialization。
あるいは、インストールしたい関数定義をいくつかのファイルに収めておき、関数loadを用いてEmacsに各ファイルの関数定義を評価させインストールする。 See Loading Files。
読者のサイト全体で使用するコードの場合には、 Emacsを構築する際にロードするファイルsite-init.elにコードを収める。こうすると、サイトのユーザーなら誰でもコードを使えるようになる（Emacsのディストリビューションに含まれるファイルINSTALLを参照のこと）。

最後に、Emacsのすべてのユーザーが使いそうなコードならば、ネットワークに投稿するかFree Software Foundationに送付する（こうする場合には、投稿するまえにコードにコピーレフトの注意書きを入れてほしい）。 Free Software Foundationにコードを送付すると、 Emacsの次期リリースにコードが含まれるかもしれない。このような「寄贈行為」によりEmacsが成長してきたのである。

Node:let, Next:if, Previous:Permanent Installation, Up:Writing Defuns

`let`

let式はLispのスペシャルフォームであり、ほとんどの関数定義で使う必要がある。 letはよく使うので、本節で説明しておく。

letはシンボルに値を結び付ける、すなわち、束縛するのであるが、関数の内部と外部で同じ名前の変数を使ってもLispインタープリタが混乱しないような方法でこれを行う。このスペシャルフォームが必要な理由を理解するために、「家を塗装し直す必要がある」などのように一般的に「家」と呼ぶような家屋を所有している状況を仮定してみよう。読者が友人宅を訪問したときに、友人が「家」といったときには、 友人の家を意味しているのであって、読者の家ではないだろう。友人は彼の家を意味しているのに、読者が読者の家を意味していると考えると、混乱が生じる。ある関数の内部で使う変数と別の関数の内部で使う変数が同じ名前でも、同じ値を参照する意図がないのであれば、Lispでも同じことが起こる。

スペシャルフォームletはこの種の混乱を防ぐ。 letは、let式の外側にある同じ名前を隠すようなローカル変数（local variable）としての名前を作り出す。これは、友人が「家」といった場合、彼は読者のではなく彼の家を意味していると理解することに似ている（引数リストに使われるシンボルも同じように働く。 See defun）。

let式が作るローカル変数は、let式の内側（とlet式から呼ばれた式の内側）でのみそれらの値を保持する。ローカル変数は、let式の外側にはまったく影響しない。

letでは一度に複数個の変数を作れる。また、letで各変数を作るときには、指定した値かnilを初期値として設定できる（専門用語では、「変数に値を束縛する」という）。 letで変数を作って束縛すると、letの本体のコードを実行し、 let式全体の値として本体の最後の式の値を返す（「実行（execute）」とは、リストを評価することを意味する専門用語である。これは、「実質的な効果を与える」という単語の用法（Oxford English Dictionary）からきている。ある動作を行わせるために式を評価するので、「実行（execute）」は「評価（evaluate）」の同義語である）。

Parts of let Expression:
Sample let Expression:
Uninitialized let Variables:

Node:Parts of let Expression, Next:Sample let Expression, Previous:let, Up:let

`let`式の構造

let式は、3つの要素からなるリストである。第一の部分は、シンボルletである。第二の部分は、変数リスト（varlist）と呼ばれるリストであり、その個々の要素は、単独のシンボルであるか、第1要素がシンボルであるような 2要素リストである。 let式の第3の部分は、letの本体である。通常、本体は複数個のリストである。

let式の雛型はつぎのとおりである。

(let 変数リスト 本体...)

変数リストの各シンボルは、スペシャルフォームletで初期値を設定された変数である。単独のシンボルの場合、初期値はnilである。第1要素がシンボルであるような2要素リストである場合、そのシンボルには、Lispインタープリタが第2要素を評価した結果を束縛する。

�

訳者まえがき

はじめに

対象とする読者

Lispの歴史

初心者へ一言

謝 辞

リスト処理

Lispのリスト

Lispのアトム

リスト内の空白

GNU Emacsのリスト入力補佐機能

プログラムの実行

エラーメッセージの生成

シンボル名と関数定義

Lispインタープリタ

バイトコンパイル

評 価

内側のリストの評価

変 数

値のないシンボルに対するエラーメッセージ

引 数

引数のデータ型

引数としての変数やリストの値

可変個数の引数

引数に誤った型のオブジェクトを指定

関数message

変数への値の設定

setの使い方

setqの使い方

数え上げ

まとめ

演習問題

評価の練習

バッファ名

バッファの取得

バッファの切り替え

バッファサイズとポイントの位置

演習問題

関数定義の書き方

スペシャルフォームdefun

関数定義のインストール

関数定義の変更

関数を対話的にする

対話的multiply-by-seven

interactiveの他のオプション

コードの恒久的インストール

let

let式の構造

謝　辞

評　価

変　数

引　数

関数`message`

`set`の使い方

`setq`の使い方

スペシャルフォーム`defun`

対話的`multiply-by-seven`

`interactive`の他のオプション

`let`

`let`式の構造