@c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
@c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. 
@c See the file elisp-jp.texi for copying conditions.
@c 複製の条件は elisp-jp.texi に書いてあります。
@setfilename ../info/eval-jp
@clear jp-draft
@node Evaluation, Control Structures, Symbols, Top
@chapter 評価
@cindex evaluation
@cindex interpreter
@cindex value of expression
@cindex 評価[ひょうか]
@cindex インタプリタ[いんたぷりた]
@cindex 式の値[しきのあたい]
@cindex 値、式の[あたい、しきの]

@c  according to以下のうまいわけがねぇ。  XXX
    Emacs Lisp式の@dfn{評価(evaluation)}は、
@dfn{Lispインタプリタ(Lisp interpreter)}が行ないます。
Lispインタプリタは、Lispオブジェクトを入力として受け取り、
@dfn{式としての値(value as an expression)}を計算するプログラムです。
評価方法はオブジェクトのデータ型に依存します。本章に述べる規則にしたがいます。
インタプリタはプログラムの一部分を評価するために自動的に実行されますが、
Lispプリミティブ@code{eval}を明示的に呼び出すことでも実行できます。


@ifinfo

@menu
* Intro Eval::  評価とはどのようなものか。
* Eval::        Lispインタプリタの明示的起動法。
* Forms::       さまざまな種類のオブジェクトをどのように評価するか。
* Quoting::     評価の避け方(プログラムに定数を置く方法)。
@end menu
@c  word    invoke  起動

@node Intro Eval, Eval, Evaluation, Evaluation
@section 評価序説

    Lispインタプリタ、即ち評価子は、与えられた式の値を計算するプログラ
ムです。Lispで書かれた関数が呼ばれると、評価子は関数本体中の式を評価す
ることで、関数の値を計算します。そのため、Lispプログラムを実行することは、
本当はLispインタプリタを実行することを意味します。

@c  word    handle  操作
    評価子がどのようにオブジェクトを操作するかは、主にオブジェクトのデー
タ型に依存します。
@end ifinfo

@cindex forms
@cindex expression
@cindex 形式[けいしき]
@cindex 式[しき]
@c  word    fundamental 根本的
    評価を目的とするLispオブジェクトを@dfn{式(expression)}あるいは
@dfn{形式(form)}と呼びます。式がデータ・オブジェクトであって、
単なるテキストではないということは、
@c  はいはい、有難うございました。全くLispを理解してない証拠ですね。
Lispのような言語と典型的プログラミング言語との間の
根本的な違いの一つです。どんなLispオブジェクトも評価できますが、実際には数、
シンボル、リスト、文字列だけが非常に頻繁に評価されます。

    Lisp式を読み込み、その後その式を評価するということは、ごく普通に行なわれ
ますが、読込みと評価は別の行為であり、いずれも単独で行なうことができます。
@c  word    read    読込み
@c  word    activity    行為
読込みそれ自体は何も評価しません。
@c  word    per se  それ自体; ラテン語だってさ
それは、Lispオブジェクトの印字表現をオブジェクト自身に変換するものです。
このオブジェクトが評価すべき形式であるかどうか、あるいは全く異なる目的
に使うものなのかどうかということは、@code{read}の呼び手次第です。
@xref{Input Functions}。
@c  word    itself  自身; で通してるな

    評価とキー解釈とを混同しないでください。
@c  word    key interpretation  キー解釈
エディタのコマンド・ループは、アクティブなキーマップを使ってキーボード入力を
コマンド(対話的に呼び出せる関数)に変換し、その後@code{call-interactively}を
使ってそのコマンドを起動します。
@c  word    translate   変換
@c  word    active keymaps  アクティブなキーマップ
コマンドがLispで書かれていたならばコマンドの実行自身が評価を含みますが、それ
はコマンドのキー解釈自身の一部ではありません。@xref{Command Loop}。

@cindex recursive evaluation
@cindex 再帰的評価[さいきてきひょうか]
    評価は再帰的処理です。いいかえると、形式の評価は形式の一部分を評価
するために@code{eval}を呼び出すかもしれないということです。たとえば、関
数呼び出の評価では最初に関数呼出しの各引数の評価を行ない、その後で関数本体
中の各形式を評価します。形式@code{(car x)}の評価を考えてみると、部分形式
@code{x}を最初に再帰的に評価しなければ、その値を関数@code{car}の引数として
渡すことができません。
@c  word    subform 部分形式
@c  the subform ... は、感覚的に訳したからね

@c  word    ultimately  最終的
    関数呼出しの評価は、最終的には、そこで指定された関数を呼び出します。
@xref{Functions}。関数の実行は、それ自体がその関数定義の評価による
ものかも知れません。あるいは、関数はCで実装されたLispのプリミティブかも
知れませんし、バイトコンパイルされた関数(@pxref{Byte Compilation})
かも知れません。

@cindex environment
@cindex 環境[かんきょう]
    形式の評価は、全てのLisp変数の現在の値と現在の束縛からなる
@dfn{環境(environment)}と呼ばれる状況の中で行なわれます。
@footnote{この「環境」の定義はプログラムの結果に影響するような全てのデータを
含むことを明確に意図してはいません。}
@c  environmentもcontextも、用語じゃないよね?
その変数に新しい束縛を与える場合を除いて、形式が変数を参照するときは常に
現在の環境中で束縛された値が使われます。@xref{Variables}。
@c  どうもbindingを束縛と訳すのはやだなぁ。そんな難しいいい方じゃないだろ?
@c  「結びつける」程度のニュアンスだろうなぁ。まあ確かに束縛という意味だが。

@cindex side effect
@cindex 副作用[ふくさよう]
@c  word    side effect 副作用
    形式の評価は、変数の束縛によって、再帰的評価のための新たな環境を作るこ
とがあります(@pxref{Local Variables})。これら環境は一時的なもので、
形式の評価完了時には消えてしまいます。形式は永続的な変更を作ることもあります。
このような変更を@dfn{副作用(side effect)}と呼びます。副作用を起こす形式の例は、
@code{(setq foo 1)}です。

    各種の形式に対する評価が何であるかということの詳細を以下に説明します
(@pxref{Forms})。

@node Eval, Forms, Intro Eval, Evaluation
@section Eval
@c ??? Perhaps this should be the last section in the chapter.

    ほとんどの場合、実行中のプログラムの現れた場所で、形式は自動的に評価さ
れます。まれに、実行時に計算される形式を評価するコードを書く必要に迫られるか
も知れません。編集中のテキストから形式を読み取った後や、属性リストから
形式を取り出した後のような場合です。このような場合に@dfn{eval}関数
を使います。

    @strong{注意!:}  一般的には、データ構造に格納された式を評価するよりも、
データ構造に格納された関数を呼び出す方が、きれいかつ柔軟です。
関数を使うと、情報を引数として渡すことができます。

    この節で説明する関数と変数には、形式を評価するもの、評価処理の制限を指定す
るもの、最近返された値を記録するものがあります。ファイルをロードすると、
やはり評価を行ないます(@pxref{Loading})。

@defun eval form
評価を行なう基本の関数です。現在の環境の@var{form}を評価し、結果を返します。
評価がどのように処理されるかは、オブジェクトの型に依存します(@pxref{Forms})。

@code{eval}は関数なので、@code{eval}呼出しに現れる引数の式は2回評価され
ます。そのうち1回は@code{eval}呼出し前の準備として、
もう1回は@code{eval}関数自身によって行なわれます。例を挙げます:

@example
@group
(setq foo 'bar)
     @result{} bar
@end group
@group
(setq bar 'baz)
     @result{} baz
;; @r{@code{eval} は引数@code{bar}(@code{foo}の値である)を受取る。}
(eval foo)
     @result{} baz
(eval 'foo)
     @result{} bar
@end group
@end example

@code{eval}呼出しの、ある時点での有効回数は、
@code{max-lisp-eval-depth}(以下参照)によって制限されます。
@end defun

@deffn Command eval-region start end &optional stream
この関数は、カレント・バッファの位置@var{start}と@var{end}の範囲で定められる
リージョン内の全形式を評価します。
@c  word    position    位置
@c  word    region  リージョン
リージョンから形式を読み込んで、その形式に対して@code{eval}を呼び出すことを、
リージョンの終わりに達するかハンドルされないエラーが通知されるまで続けます。

@var{stream}を与えると、評価中は@code{standard-output}を
@var{stream}に束縛します。

変数@code{load-read-function}を使うと、@code{eval-region}が式を読み込むときに
@code{read}の代わりに使う関数を指定することもできます。
@xref{How Programs Do Loading}。

@code{eval-region}は常に@code{nil}を返します。
@end deffn

@cindex evaluation of buffer contents
@cindex バッファ内容の評価[ばっふぁないようのひょうか]
@cindex 評価、バッファ内容の[ひょうか、ばっふぁないようの]
@c  word    contents    内容
@deffn Command eval-current-buffer &optional stream
この関数は、バッファ全体に対して実行することを除けば@code{eval-region}と
同じです。
@end deffn

@defvar max-lisp-eval-depth
この変数は、@code{eval}, @code{apply}, @code{funcall}呼出しにおいて許され
るネストの深さの最大値を定義します。これを超えると、(エラー・メッセージ 
@code{"Lisp nesting exceeds max-lisp-eval-depth"}をともなう)エラーが
通知されます。この数には、これらの関数の内部的使用や、関数呼出しの引数や
関数本体の形式の再帰的評価も勘定に入れます。前者には、Lisp式の形で
書かれた関数の呼出しも含まれます。

@cindex Lisp nesting error
@cindex Lispネスト・エラー[Lispねすと・えらー]
@c  word    nest    ネスト
この制限は、制限を超えたときにそれを表すエラーを出力することで、間違って定義
された関数の無限再帰をLispで回避するための一つの方法です。

この変数のデフォルト値は200です。設定した値が100未満のときにその値に達した場合
は、Lispは値を100に再設定します。

@code{max-specpdl-size} が別のネストの制限を与えます。@xref{Local Variables}。
@end defvar

@defvar values
この変数の値は、(ミニバッファを含む)バッファから読み込まれ、評価され、
印字された全ての式が返した値のリストです。その要素は最近のものほど前に
来るように並んでいます。

@example
@group
(setq x 1)
     @result{} 1
@end group
@group
(list 'A (1+ 2) auto-save-default)
     @result{} (A 3 t)
@end group
@group
values
     @result{} ((A 3 t) 1 @dots{})
@end group
@end example

この変数は、最近評価された式の値を振り返って参照するのに便利です。
@code{values}自身の値を印字するのは一般的にはよくないことです。
なぜなら結果は非常に長くなり得るからです。代わりに、このように特定の要素
を調べるとよいでしょう:

@example
@group
;; @r{一番新しい評価結果を参照する。}
(nth 0 values)
     @result{} (A 3 t)
@end group
@group
;; @r{これで新しい要素を一つ追加したことになるので、}
;;   @r{全ての要素は一つ後ろに動く。}
(nth 1 values)
     @result{} (A 3 t)
@end group
@group
;; @r{この例の実行前には2番目に新しかった}
;;   @r{要素を取り出す。}
(nth 3 values)
     @result{} 1
@end group
@end example
@end defvar

@node Forms, Quoting, Eval, Evaluation
@section 形式の種類

    評価されることを目的とするLispオブジェクトを@dfn{形式(form)}と呼びます。
Emacsがどのように形式を評価するかは、そのデータ型に依存します。
Emacsは評価方法の違いで形式を3種類に分けます。
シンボル、リスト、および「ほかの全ての型」です。
この節では、自己評価型形式である「ほかの全ての型」から始めて、
これら3種すべてについて説明します。
@c  word    self-evaluating 自己評価型

@menu
* Self-Evaluating Forms::   自分自身に評価される形式。
* Symbol Forms::            変数として評価されるシンボル。
* Classifying Lists::       さまざまな種類のリスト形式の区別法。
* Function Indirection::    シンボルがリストのcarとして現れたときは、
                                実際の関数をそのシンボルから見つける。
* Function Forms::          関数を呼び出す形式。
* Macro Forms::             マクロを呼び出す形式。
* Special Forms::           「特殊形式」は独特なプリミティブであり、
                                そのほとんどが大変に重要。
* Autoloading::             実際の定義を含むファイルを
                                ロードするように設定する関数。
@end menu

@node Self-Evaluating Forms, Symbol Forms, Forms, Forms
@subsection 自己評価型形式
@cindex vector evaluation
@cindex literal evaluation
@cindex self-evaluating form
@cindex ベクタの評価[べくたのひょうか]
@cindex リテラルの評価[りてらるのひょうか]
@cindex 自己評価型形式[じこひょうかがたけいしき]

    @dfn{自己評価型形式(self-evaluating form)}とは、リストや
シンボルではない形式のことをいいます。自己評価型形式を
評価するとそれら自身になります。その評価結果は評価したオブジェクトと
同一になります。それゆえ、数25は25と評価され、文字列@code{"foo"}は
文字列@code{"foo"}と評価されます。同様に、ベクタの評価ではベクタ要素の
評価は起こりません。内容の変わらない同じベクタが返ります。

@example
@group
'123               ; @r{オブジェクトを評価抜きで見る。}
     @result{} 123
@end group
@group
123                ; @r{普通に評価する(結果は同じ)。}
     @result{} 123
@end group
@group
(eval '123)        ; @r{「手作業で」評価する ---結果は同じ。}
     @result{} 123
@end group
@group
(eval (eval '123)) ; @r{2回評価しても何も変わらない。}
     @result{} 123
@end group
@end example

    数、文字、文字列、ベクタさえもこれらが自己評価型である利点を活かして、
Lispコードに当たり前に書いています。けれどもリード構文がない型に対してこの
ように書くということは普通は行ないません。なぜならそういったものをテキストで
書く方法がないためです。こういった型を含むLisp式をLispプログラムという
手段によって構築することは可能です。例を挙げます:

@example
@group
;; @r{バッファ・オブジェクトを含む式を作る。}
(setq buffer (list 'print (current-buffer)))
     @result{} (print #<buffer eval.texi>)
@end group
@group
;; @r{それを評価する。}
(eval buffer)
     @print{} #<buffer eval.texi>
     @result{} #<buffer eval.texi>
@end group
@end example

@node Symbol Forms, Classifying Lists, Self-Evaluating Forms, Forms
@subsection シンボル形式
@cindex symbol evaluation
@cindex シンボルの評価[しんぼるのひょうか]

    シンボルが評価されるときは、変数として扱われます。結果は、あるとすれば
変数の値です。値がない場合(その値セルがvoidの場合)は、
エラーが通知されます。変数の使い方についてこれ以上の話は、
@ref{Variables}を参照してください。

    以下の例では、シンボルの値を@code{setq}で設定します。その後シンボルを
評価し、@code{setq}が格納した値を取り戻します。

@example
@group
(setq a 123)
     @result{} 123
@end group
@group
(eval 'a)
     @result{} 123
@end group
@group
a
     @result{} 123
@end group
@end example

    @code{nil}と@code{t}というシンボルは、特別な扱いを受けます。その結果、
@code{nil}の値は常に@code{nil}であり、@code{t}の値は常に@code{t}になります。
これらをほかの値に設定することも束縛することもできません。したがって、たとえ
@code{eval}がこれらをほかのシンボルのように扱ったとしても、この二つのシンボ
ルは自己評価型形式のように振舞います。

@node Classifying Lists, Function Indirection, Symbol Forms, Forms
@subsection リスト形式の分類
@cindex list form evaluation
@cindex リスト形式の評価[りすとけいしきのひょうか]

    リストという形式は、それが空でないならば、その最初の要素によって、
関数呼出しか、マクロ呼出しか、特殊形式かのいずれかになります。
これら3種の形式は、以下に述べるように異なる方法で評価されます。
リストの残りの要素は、関数、マクロ、特殊形式いずれかの@dfn{引数(argument)}を
構成します。
@c  word    constitute  構成する

    空ではないリストの評価の最初の手順は、その第1要素の検査です。この
要素だけが、そのリストがどの種類の形式であるのかということと、リストの残
りがどのように処理されるかということを決定します。
@c  word    step    手順
Lispの方言によっては、たとえばSchemeでは評価するのですが、
Emacs Lispでは第1要素は評価@emph{しません}。

@node Function Indirection, Function Forms, Classifying Lists, Forms
@subsection シンボル関数間接参照
@cindex symbol function indirection
@cindex indirection
@cindex void function
@cindex シンボル関数間接参照[しんぼるかんすうかんせつさんしょう]
@cindex 間接参照[かんせつさんしょう]
@cindex voidな関数[voidなかんすう]
@c  word    indirection 間接参照
@c  word    void function   voidな関数

    リストの第1要素がシンボルならば、評価においてはそのシンボルの関数セ
ルを検査し、その中身を元のシンボルの代わりに使用します。
@c  word    contents    中身; あれ、さっきまでと違う。
その中身がほかのシンボルならば、この@dfn{シンボル関数間接参照
(symbol function indirection)}と呼ぶ処理を非シンボルを得るまで繰り返します。
シンボルの関数セルに格納された関数の名前として、
そのシンボルを使うことについてのこれ以上の話は、@xref{Function Names}。

    この処理の結果として無限ループになることもあります。それは、
シンボルの関数セルが同じシンボルを参照しているときに起こります。
@c  word    infinite loop   無限ループ
あるいは、シンボルがvoidな関数セルを持ち、そのためにサブルーチン
@code{symbol-function}が@code{void-function}エラーを通知するかも知れません。
このいずれも起こらない場合は、最終的には非シンボルを得ます。
その非シンボルは関数またはほかの適当なオブジェクトになっているはずです。

@kindex invalid-function
@cindex invalid function
@cindex 無効な関数[むこうなかんすう]
@c  word    invalid function    無効な関数
    もっと精確に書くと、Lisp関数(ラムダ式)、バイトコード関数、
プリミティブ関数、Lispマクロ、特殊形式、自動ロード・オブジェクトのいずれかに
なっていないとおかしいでしょう。
@c  word    autoload    自動ロード
これらの型のそれぞれは以下のどれかの節で説明します。オブジェクトがこれ
ら型のいずれでもない場合、@code{invalid-function}エラーが通知されます。

    以下の例は、シンボル間接参照処理を図解しています。@code{fset}を使っ
てシンボルの関数セルを設定し、@code{symbol-function}で先の関数セルの内容
を取り出しています(@pxref{Function Cells})。具体的には、シンボル@code{car}を
@code{first}の関数セルに格納し、シンボル@code{first}を@code{erste}の関数
セルに格納しています。

@smallexample
@group
;; @r{この関数セルのリンクを作る:}
;;   -------------       -----        -------        -------
;;  | #<subr car> | <-- | car |  <-- | first |  <-- | erste |
;;   -------------       -----        -------        -------
@end group
@end smallexample

@smallexample
@group
(symbol-function 'car)
     @result{} #<subr car>
@end group
@group
(fset 'first 'car)
     @result{} car
@end group
@group
(fset 'erste 'first)
     @result{} first
@end group
@group
(erste '(1 2 3))   ; @r{@code{erste}が参照する関数を呼び出す。}
     @result{} 1
@end group
@end smallexample

    対照的に、次の例では関数をシンボル関数間接参照なしで呼び出しています。とい
うのも、最初の要素が匿名Lisp関数であり、シンボルではないからです。
@c  word    anonymous   匿名

@smallexample
@group
((lambda (arg) (erste arg))
 '(1 2 3)) 
     @result{} 1
@end group
@end smallexample

@noindent
この関数自身の実行がこの本体を評価します。これには、
@code{erste}を呼び出す時のシンボル関数間接参照がともないます。

    組込み関数@code{indirect-function}は、明示的に関数のシンボル関数間接参照
を簡単に行なう方法を提供しています。

@c Emacs 19 feature
@defun indirect-function function
この関数は、@var{function}の関数としての意味を返します。@var{function}が
シンボルならば、@var{function}の関数定義を見つけ、その値を用いて最初から
やり直します。@var{function}がシンボルではないならば、@var{function}自身を
返します。

@smallexample
(defun indirect-function (function)
  (if (symbolp function)
      (indirect-function (symbol-function function))
    function))
@end smallexample
@end defun

@node Function Forms, Macro Forms, Function Indirection, Forms
@subsection 関数形式の評価
@cindex function form evaluation
@cindex function call
@cindex 関数形式評価[かんすうけいしきひょうか]
@cindex 関数呼出し[かんすうよびだし]

    評価しているリストの第1要素がLisp関数オブジェクトの場合、
バイトコード・オブジェクトの場合、あるいはプリミティブ関数オブジェクトの
場合は、そのリストは@dfn{関数呼出し(function call)}です。たとえば、
これは関数@code{+}の呼出しです:

@example
(+ 1 x)
@end example

@c  word    actual argument 実引数
@c  word    argument variable   仮引数
    関数呼出しを評価する第1手順は、残りのリスト要素を左から右に評価する
ことです。結果は実引数の値であり、一つの値がリスト要素一つに対応します。
次の手順はこの引数のリストを持って関数を呼び出すことで、事実上関数
@code{apply}を使用します(@pxref{Calling Functions})。
この関数がLispで書かれていたならば、実引数で関数の仮引数を束縛します
(@pxref{Lambda Expressions})。
その後関数本体内の形式が順序どおりに評価され、最後の本体形式が関数呼出しの
値になります。

@node Macro Forms, Special Forms, Function Forms, Forms
@subsection Lispマクロの評価
@cindex macro call evaluation
@cindex マクロ呼出しの評価[まくろよびだしのひょうか]

    評価中のリストの第1要素がマクロ・オブジェクトならば、リストは
@dfn{マクロ呼出し(macro call)}です。マクロ呼出しが評価されると、
リストの残りの要素ははじめは評価@emph{されません}。代わりに、これら要素自身が
マクロの引数として使われます。マクロ定義はマクロの@dfn{展開(expansion)}と
呼ばれる置換形式を計算し、これが元の形式の代わりに評価されます。
展開はあらゆる種類の形式となり得ます。自己評価型定数、シンボル、リストです。
展開自身がマクロ呼出しならば、この展開処理をほかの種類の形式が結果となるまで
繰り返します。

    マクロ呼出しの評価は、普通はその展開を評価することで終了します。
しかしマクロ展開をすぐに評価する必要はありませんし、全く評価しなくても
構いません。なぜならほかのプログラムも同じようにマクロ呼出しを展開し、それらも
その展開を評価することもしないこともあるからです。

    普通、引数に現れる式は、マクロ展開の計算の一部としては評価されず、
代わりにその展開の一部として現れ、その結果、それらはその展開を計算するときに
計算されます。

    たとえば、次のようにマクロを定義します:
@example
@group
(defmacro cadr (x)
  (list 'car (list 'cdr x)))
@end group
@end example

@noindent
@code{(cadr (assq 'handler list))}のような式は、マクロ呼出しで、
その展開はこうなります:

@example
(car (cdr (assq 'handler list)))
@end example

@noindent
引数の@code{(assq 'handler list)}が展開の中に現れていることに注意しましょう。

Emacs Lispマクロの完全な説明は、@xref{Macros}。

@node Special Forms, Autoloading, Macro Forms, Forms
@subsection 特殊形式
@cindex special form evaluation
@cindex 特殊形式の評価[とくしゅけいしきのひょうか]

@c  word    mark    設計; というか、ねえ、印づけというか。
    @dfn{特殊形式(special form)}とはその引数の全てが評価されないように
設計された関数です。特殊形式のほとんどが、制御構造を定義したり変数の束縛、
関数がやれないこと、を行ないます。

    特殊形式のそれぞれが固有の規則を持っていて、どの引数を評価し、
どの引数は評価しないで使うかを決めます。特定の引数が評価されるか否かが、
ほかの引数を評価した結果に依存することもあります。

@table @code
@item and
@pxref{Combining Conditions}

@item catch
@pxref{Catch and Throw}

@item cond
@pxref{Conditionals}

@item condition-case
@pxref{Handling Errors}

@item defconst
@pxref{Defining Variables}

@item defmacro
@pxref{Defining Macros}

@item defun
@pxref{Defining Functions}

@item defvar
@pxref{Defining Variables}

@item function
@pxref{Anonymous Functions}

@item if
@pxref{Conditionals}

@item interactive
@pxref{Interactive Call}

@item let
@itemx let*
@pxref{Local Variables}

@item or
@pxref{Combining Conditions}

@item prog1
@itemx prog2
@itemx progn
@pxref{Sequencing}

@item quote
@pxref{Quoting}

@item save-excursion
@pxref{Excursions}

@item save-restriction
@pxref{Narrowing}

@item save-window-excursion
@pxref{Window Configurations}

@item setq
@pxref{Setting Variables}

@item setq-default
@pxref{Creating Buffer-Local}

@item track-mouse
@pxref{Mouse Tracking}

@item unwind-protect
@pxref{Nonlocal Exits}

@item while
@pxref{Iteration}

@item with-output-to-temp-buffer
@pxref{Temporary Displays}
@end table

@cindex CL note---special forms compared
@cindex CL注意書き---特殊形式の比較[CLちゅういがき---とくしゅけいしきのひかく]
@quotation
@b{Common Lisp注意書き:} GNU Emacs LispとCommon Lispとの特殊形式の
比較をします。@code{setq}, @code{if}, @code{catch}は、Emacs Lispと
Common Lispとの双方において特殊形式です。@code{defun}はEmacs Lispでは
特殊形式ですが、Common Lispではマクロです。@code{save-excursion}は
Emacs Lispにおいては特殊形式ですが、Common Lispには存在しません。
@code{throw}はCommon Lispでは特殊形式(複数の値をthrowできるようにするため)
ですが、Emacs Lispでは関数です(複数の値は持たない)。@refill
@end quotation

@node Autoloading,  , Special Forms, Forms
@subsection 自動ロード

    @dfn{自動ロード(autoload)}機能によって、まだEmacsにその定義が
ロードされてないような関数やマクロを呼び出すことができます。これによって、
どのファイルがその定義を含むかを指定します。自動ロード・オブジェクトが
シンボルの関数定義として現れたとき、そのシンボルを関数として呼び出すことで
自動的に指定されたファイルがロードされます。その後、ファイルからロードされた
実際の定義を呼び出します。@xref{Autoload}。

@node Quoting,  , Forms, Evaluation
@section quoteする
@cindex quoting
@cindex quoteする[quoteする]

    特殊形式@code{quote}は、一つの引数を、書かれたとおり、評価をせずに
返します。これによって、定数シンボルやリストなど、
自己評価型ではないオブジェクトをプログラムに含める手段が用意されています
(数、文字列、ベクタなど、自己評価型オブジェクトをquoteする必要はありません)。
@c  word    provide; 用意している(我乍ら意外な訳)

@defspec quote object
この特殊形式は@var{object}を評価せずに返します。
@end defspec

@cindex @samp{'} for quoting
@cindex quoting using apostrophe
@cindex apostrophe for quoting
@cindex @samp{'}でquoteする[@samp{'}でquoteする]
@cindex アポストロフィでquoteする[アポストロフィでquoteする]
@cindex quoteのためのアポストロフィ[quoteのためのアポストロフィ]
@code{quote}はしょっちゅうプログラムで使われるので、Lispはそれを便利にする
リード構文を用意しています。アポストロフィ文字(@samp{'})に続く一つのLisp
オブジェクト(リード構文において)は、第1要素が@code{quote}で、2番目の要素
が先のオブジェクトというリストに展開されます。したがって、リード構文@code{'x}
は、@code{(quote x)}の省略形です。
@c  word    abbreviation    省略形

@code{quote}を使う式の例を挙げます:

@example
@group
(quote (+ 1 2))
     @result{} (+ 1 2)
@end group
@group
(quote foo)
     @result{} foo
@end group
@group
'foo
     @result{} foo
@end group
@group
''foo
     @result{} (quote foo)
@end group
@group
'(quote foo)
     @result{} (quote foo)
@end group
@group
['foo]
     @result{} [(quote foo)]
@end group
@end example

    そのほかのquoteを行なう構文要素には、Lispで書かれた匿名ラムダ式が
コンパイルされるようになる@code{function}(@pxref{Anonymous Functions})、
ほかの部分の計算や置換をする間、リストの一部だけをquoteするために使用する
@code{`}(@pxref{Backquote})があります。
