@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 jp-draft
@c 複製の条件はelisp-jp.texiに書いてあります。

@c 2.3 -> 2.4 patch applied.

@setfilename ../info/functions-jp
@node Functions, Macros, Variables, Top
@chapter 関数
@c jp-draft

@c jp-draft
Lispプログラムは、主にLisp関数で構成されます。この章では、関数と
いう概念、引数の処理方法、関数の定義方法について説明します。

@menu
@c jp-draft
* What Is a Function::    Lisp関数とプリミティブ (用語)。
* Lambda Expressions::    Lispオブジェクトとしての関数の表現方法。
* Function Names::        関数の名前として使えるシンボル。
* Defining Functions::    関数を定義するためのLisp式。
* Calling Functions::     既存の関数の使い方。
* Mapping Functions::     リストの各要素への関数の適用。
* Anonymous Functions::   名前を持たない関数 - ラムダ式。
* Function Cells::        シンボルの関数定義へのアクセスと設定。
* Inline Functions::	  コンパイラがコードを埋め込む関数の定義。
* Related Topics::        関数の動作に特別な影響がある特定のLispプリミティ
                          ブへの相互参照。
@end menu

@node What Is a Function, Lambda Expressions, Functions, Functions
@section 関数とは
@c jp-draft

@c jp-draft
一般に、関数とは、@dfn{引数(argument)}と呼ばれる与えられたいく
つかの値に対して計算を実行するための規則です。計算の結果は、関数
の値と呼ばれます。計算には、副作用がともなう場合もあります。副作
用には、変数の値の変化や、データ構造の内容の変化があります。

@c jp-draft
Emacs Lispの関数や関数に準ずるオブジェクトに関する重要な用語をいくつか説明
します。

@table @dfn
@c jp-draft
@item 関数
@cindex function
@cindex 関数[かんすう]
Emacs Lispでは、@dfn{関数(function)}とは、Lispプログラムにおい
て引数に適用可能なものすべてを指します。場合によっては、Lispで書
かれた関数を特に意味する場合もあります。特殊形式やマクロは関数で
はありません。

@c jp-draft
@item プリミティブ
@cindex primitive
@cindex subr
@cindex built-in function
@cindex プリミティブ[ぷりみてぃぶ]
@cindex subr[subr]
@cindex 組込み関数[くみこみかんすう]
@dfn{プリミティブ(primitive)}とは、@code{car}や@code{append}のよ
うに、Cで書かれた、Lispから呼び出せる関数です。プリミティブは、
@dfn{組込み(built-in)}関数または@dfn{subr}とも呼ばれます(特殊
形式もプリミティブとみなされます)。

@c jp-draft
通常、関数をプリミティブにする理由には、関数が基本的なものである
こと、オペレーティング・システムのサービスへの低レベル・インター
フェースを実現するものであること、高速に実行する必要があること、
などがあります。プリミティブを修正したり追加するには、Cのソース
を変更して、エディタをコンパイルしなおさなければなりません。
@ref{Writing Emacs Primitives}を参照してください。

@c jp-draft
@item ラムダ式
@dfn{ラムダ式(lambda expression)}とは、Lispで書かれた関数です。
ラムダ式については、次に示す節で説明しています。
@ifinfo
@xref{Lambda Expressions}。
@end ifinfo

@c jp-draft
@item 特殊形式
@dfn{特殊形式(special form)}は、関数に似ていますが、すべての引数
を評価する方法が通常の形式とは異なります。特殊形式は、一部の引数だけを
評価したり、通常とは異なる順番で引数を評価したり、同じ引数を何度
も評価する場合があります。@ref{Control Structures}では、たくさん
の特殊形式について説明しています。

@c jp-draft
@item マクロ
@cindex macro
@cindex マクロ[まくろ]
@dfn{マクロ(macro)}とは、プログラマがLispで定義する構文要素です。マクロが関
数とは異なるのは、マクロは、プログラマが書いたLisp式を評
価せずに、そのまま等価な式に変換する点です。マクロを使えば、特殊形式と同
様のことをLispプログラムで実現できます。マクロの定義方法や使い方
については、@xref{Macros}。

@c jp-draft
@item コマンド
@cindex command
@cindex コマンド[こまんど]
@dfn{コマンド(command)}とは、@code{command-execute}が起動できるオブジェク
トであり、通常はキー操作の定義内容として使われます。一部の関数は
コマンドです。Lispで書かれた関数は、対話的コマンド宣言を含んで
いればコマンドになります(@pxref{Defining Commands})。コマンド関
数は、ほかの関数と同様にLisp式から呼び出せます。その場合、その関数が
コマンドであることに意味はありません。

@c jp-draft
キーボード・マクロ(文字列とベクタ)も、関数ではありませんがコマ
ンドです。コマンドを関数定義にもつシンボルもコマンドです。このよ
うなシンボルは、@kbd{M-x}で起動できます。同様に、シンボルの定義
が関数ならば、そのシンボルは関数です。@xref{Command Overview}。

@c jp-draft
@item キーストローク・コマンド
@cindex keystroke command
@cindex キーストローク・コマンド[きーすとろーくこまんど]
@dfn{キーストローク・コマンド(keystroke command)}とは、キー・シー
ケンス(通常は一つから三つのキーストローク) にバインドされたコマン
ドです。キーストローク・コマンドとコマンドの違いをここで説明して
いるのは、Emacs以外のエディタでの``コマンド''と混同しないように
するためだけです。通常、Lispプログラムでは、キーストローク・コマ
ンドとコマンドの違いは重要ではありません。

@c jp-draft
@item バイトコード関数
@dfn{バイトコード関数(byte-code function)}とは、バイトコンパイラ
でコンパイルされた関数です。@xref{Byte-Code Type}。
@end table

@defun subrp object
@c jp-draft
この関数は、@var{object}が組込み関数(Lispプリミティブ)ならば
@code{t}を返します。

@c jp-draft
@example
@group
(subrp 'message)            ; @r{@code{message}はシンボルです。}
     @result{} nil                 ;   @r{subrオブジェクトではありません。}
@end group
@group
(subrp (symbol-function 'message))
     @result{} t
@end group
@end example
@end defun

@c jp-draft
@defun byte-code-function-p object
この関数は、@var{object}がバイトコード関数ならば@code{t}を返しま
す。例を次に示します。

@example
@group
(byte-code-function-p (symbol-function 'next-line))
     @result{} t
@end group
@end example
@end defun

@node Lambda Expressions, Function Names, What Is a Function, Functions
@section ラムダ式
@c jp-draft
@cindex lambda expression
@cindex ラムダ式[らむだしき]

@c jp-draft
Lispで書かれた関数は、次のようなリストです。

@example
(lambda (@var{arg-variables}@dots{})
  @r{[}@var{documentation-string}@r{]}
  @r{[}@var{interactive-declaration}@r{]}
  @var{body-forms}@dots{})
@end example

@noindent
@c jp-draft
このようなリストは、@dfn{ラムダ式(lambda expression)}と呼ばれて
います。Emacs Lispでは、ラムダ式は実際には式として有効であり、評
価されるとそれ自体になります。一部のLisp方言では、ラムダ式は有効
な式ではありません。どちらの場合も、ラムダ式は式として評価するた
めではなく、関数として呼び出すために主に使われます。

@menu
@c jp-draft
* Lambda Components::       ラムダ式の各部分。
* Simple Lambda::           簡単な例。
* Argument List::           引数リストの詳細と特殊機能。
* Function Documentation::  関数の説明を関数内に置く方法。
@end menu

@node Lambda Components, Simple Lambda, Lambda Expressions, Lambda Expressions
@subsection ラムダ式の構成要素
@c jp-draft

@ifinfo

@c jp-draft
Lispで書かれた関数 (``ラムダ式'') は、次のようなリストです。

@example
(lambda (@var{arg-variables}@dots{})
  [@var{documentation-string}]
  [@var{interactive-declaration}]
  @var{body-forms}@dots{})
@end example
@end ifinfo

@c jp-draft
@cindex lambda list
@cindex ラムダ・リスト[らむだりすと]
ラムダ式の最初の要素は、つねにシンボル@code{lambda}です。
@code{lambda}は、リストが関数を表現していることを示します。関数
の定義を@code{lambda}で始めるのは、ほかの用途に使われるリストを
誤って関数として有効にしてしまわないためです。

@c jp-draft
2 番目の要素は、シンボル (引数変数の名前) のリストです。このリス
トは、@dfn{ラムダ・リスト(lambda list)}と呼ばれます。Lisp関数が呼
び出されると、ラムダ・リスト内の各変数に対して引数の値が対応つけら
れます。そして、各変数には、渡された値がローカルに束縛されます。
@xref{Local Variables}。

@c jp-draft
説明文字列は、関数定義内に置かれたLisp文字列オブジェクト
で、Emacsヘルプ機能での関数の説明として使われます。@xref{Function
Documentation}。

@c jp-draft
interactive宣言は、@code{(interactive @var{code-string})}と
いう形式のリストです。interactive宣言は、関数が対話的に使わ
れたときの引数の供給方法を宣言します。この宣言をもつ関数は、
@dfn{コマンド(command)}と呼ばれます。コマンドは、@kbd{M-x}を使っ
て呼び出したり、キーにバインドできます。このような方法で(対話的
に)呼び出すべきでない関数には、interactive宣言を入れないで
ください。interactive宣言の書き方については、@xref{Defining
Commands}。

@c jp-draft
@cindex body of function
@cindex 本体、関数の[ほんたい、かんすうの]
残りの要素は、関数の@dfn{本体(body)}です。関数の本体とは、関数の
実際の作業を行う Lispコードです(Lisp プログラミングの観点からは、
``評価される Lisp形式のリスト''ともいえます)。関数が返す値は、
本体の最後の要素が返す値です。

@node Simple Lambda, Argument List, Lambda Components, Lambda Expressions
@subsection 簡単なラムダ式の例
@c jp-draft

@c jp-draft
次のような関数を例にとって考えます。

@example
(lambda (a b c) (+ a b c))
@end example

@noindent
@c jp-draft
この関数を呼び出すには、次のように、式の@sc{car}にこの関数を書きます。


@example
@group
((lambda (a b c) (+ a b c))
 1 2 3)
@end group
@end example

@noindent
@c jp-draft
この呼出しは、変数@code{a}を1に、変数@code{b}を2に、変数
@code{c}を3に束縛して、ラムダ式の本体を評価します。本体が評価され
ると、この三つの数が加算され、結果は6になります。このため、この関
数の呼出しは6を返します。


@c jp-draft
また、次の例のように、ある関数呼出しの結果をさらに別の関数の引数にするこ
ともできます。

@example
@group
((lambda (a b c) (+ a b c))
 1 (* 2 3) (- 5 4))
@end group
@end example

@noindent
@c jp-draft
この式は、引数の@code{1}、@code{(* 2 3)}、@code{(- 5 4)}を左から右に評価し
ます。次に、引数の1と6と1にラムダ式が適用され、結果は8になります。

@c jp-draft
通常は、このように形式の@sc{car}としてラムダ式を書くのは不便です。特殊
形式@code{let}を使ってローカル変数を作成し、その変数に値を設定すれば、同じ
結果を得ることができます(@pxref{Local Variables})。また、@code{let}の方が
わかりやすく、使うのも簡単です。実際には、ラムダ式は、シンボルの関数定義とし
て格納して名前をもつ関数を作成したり、ほかの関数の引数として渡すために使われ
ます(@pxref{Anonymous Functions})。

@c jp-draft
しかし、特殊形式@code{let}が発明されるまでの以前のLispでは、明示
的なラムダ式への呼出しはよく使われていました。当時は、ローカル
変数に値を束縛して初期化するには、この方法を使うしかありませんで
した。

@node Argument List, Function Documentation, Simple Lambda, Lambda Expressions
@subsection 引数リストの高度な機能
@c jp-draft
@kindex wrong-number-of-arguments
@cindex argument binding
@cindex binding arguments
@cindex 引数の束縛[ひきすうのそくばく]
@cindex 束縛、引数の[そくばく、ひきすうの]

@c jp-draft
この例の@code{(lambda (a b c) (+ a b c))}という簡単な関数では、三つの引数変数を指定しているため、この関数は三つの引数を指定して呼
び出さなければなりません。引数を二つだけしか指定せずに、あるいは、四
つも指定してこの関数を呼び出そうとすると、
@code{wrong-number-of-arguments}エラーが発生します。

@c jp-draft
一部の引数を省略できる関数を書いた方が便利な場合もよくあります。
たとえば、@code{substring}関数は、文字列、開始インデックス、終了
インデックスの三つの引数を受けつけます。しかし、3番目の引数は、省
略すると文字列の@var{length}になります。また、@code{list}関数や
@code{+}関数のように、関数が不定個の引数を受けつけるようにすると
便利な場合もあります。

@c jp-draft
@cindex optional arguments
@cindex rest arguments
@cindex オプション引数[おぷしょんひきすう]
@cindex 残余引数[ざんよひきすう]
@kindex &optional
@kindex &rest
関数を呼び出す時に省略できる引数を指定するには、
@code{&optional}キーワードをオプション引数の前につけます。余っ
ている0個以上の引数を要素とするリストを指定するには、最後の引数
の前に@code{&rest}キーワードをつけます。

@c jp-draft
したがって、引数リストの完全な構文は次のようになります。

@example
@group
(@var{required-vars}@dots{}
 @r{[}&optional @var{optional-vars}@dots{}@r{]}
 @r{[}&rest @var{rest-var}@r{]})
@end group
@end example

@noindent
@c jp-draft
角括弧は、@code{&optional}節と@code{&rest}節、およびそれらの後の変
数が省略可能であることを示しています。

@c jp-draft
関数を呼び出す時は、@var{required-vars}のそれぞれについて実引数
を一つずつ指定しなければなりません。@var{optional-vars}には実引数
を指定しなくてもかまいません。また、ラムダ・リストで@code{&rest}
が使われていなければ、仮引数の個数を超える実引数を指定することは
できません。@code{&rest}が使われている場合は、余分な実引数をいく
つでも指定できます。

@c jp-draft
オプション引数や残余引数に対する実引数を省略した場合のデフォルト値
は、つねに@code{nil}です。明示的に@code{nil}が引数に指定されたの
か、それとも引数が省略されたのかを呼び出された関数から区別するこ
とはできません。ただし、呼び出された関数の本体は、@code{nil}を別
の意味を示す省略値として扱うこともできます。たとえば、
@code{substring}は、3番目の引数に@code{nil}が指定されている場合、
指定されている文字列の長さを使います。

@c jp-draft
@cindex CL note---default optional arg
@cindex CL注意書き---デフォルトの省略可能引数[CLちゅういがき---でふぉるとのしょうりゃくかのうひきすう]
@quotation
@b{Common Lisp注意書き:} Common Lispでは、オプション引数が省略され
ている場合に使われるデフォルト値を関数に指定できます。Emacs Lisp
では、常に@code{nil}が使われます。
@end quotation

@c jp-draft
たとえば、次のような引数リストがあるとします。

@example
(a b &optional c d &rest e)
@end example

@c jp-draft
この引数リストは、@code{a}と@code{b}を最初の二つの引数に束縛しま
す。この二つの引数は必須です。引数がさらに一つまたは二つ指定されて
いる場合は、@code{c}と@code{d}はそれぞれ対応する引数に束縛されま
す。最初の四つの引数の後の引数はすべて一つのリストにまとめられ、
@code{e}はそのリストに束縛されます。引数が二つしか指定されていな
い場合は、@code{c}は@code{nil}になります。引数が二つまたは三つの場
合は、@code{d}は@code{nil}になります。引数が四つ以下の場合は、
@code{e}は@code{nil}になります。

@c jp-draft
オプション引数の後に必須引数を置くことはできません (無意味です)。
その理由を考えるため、上記の例の@code{c}が省略可能で、@code{d}が
必須であると仮定してみます。実引数を三つ与えたとすると、三つめの引
数はどの変数に束縛されるでしょうか?同様に、@code{&rest}引数の後
にさらに(必須やオプションの)引数を置くのも無意味です。

@c jp-draft
引数リストと正しい呼出しの例をいくつか示します。

@c jp-draft
@smallexample
((lambda (n) (1+ n))                ; @r{必須引数が一つ:}
 1)                                 ; @r{引数は一つだけで、省略不可能}
     @result{} 2
((lambda (n &optional n1)           ; @r{必須引数が一つ、オプション引数が一つ:}
         (if n1 (+ n n1) (1+ n)))   ; @r{引数は1個または2個}
 1 2)
     @result{} 3
((lambda (n &rest ns)               ; @r{必須引数が一つ、残余引数が一つ:}
         (+ n (apply '+ ns)))       ; @r{引数は1個以上}
 1 2 3 4 5)
     @result{} 15
@end smallexample

@node Function Documentation,  , Argument List, Lambda Expressions
@subsection 関数の説明文字列
@c jp-draft
@cindex documentation of function
@cindex 説明、関数の[せつめい、かんすうの]

@c jp-draft
ラムダ式のラムダ・リストの直後には、@dfn{説明文字列(documentation
string)}を置くこともできます。この文字列は、関数の実行には影響を
与えません。この文字列は一種のコメントですが、Lisp環境内に実際に
存在する系統だったコメントであり、Emacsのヘルプ機能によって利用
できます。@var{documentation-string}のアクセス方法については、
@xref{Documentation}。

@c jp-draft
たとえ、自分のプログラムからしか呼び出されない関数でも、プログラ
ムのすべての関数には説明文字列を用意しておくのがよいでしょう。 
説明文字列はコメントのようなものですが、コメントよりも調べやす
いという特徴があります。

@c jp-draft
@code{apropos}は説明文字列の1行目だけを表示します。このため、説明文
字列の1行目はそれだけで完結していなければなりません。説明文字
列の1行目には、関数の用途を要約した一つか二つの文を置いてください。

@c jp-draft
通常、説明文字列の先頭はソース・ファイル内で字下げしますが、
この字下げのための空白は開き二重引用符の前であるため、説明
文字列には含まれません。テキストがプログラム・ソースと揃うように、
残りの行を字下げする人もいますが、@emph{それは間違いです。}2
行目以降の字下げは、説明文字列内に含まれます。ソース・コード
ではきれいに見えても、ヘルプ・コマンドで表示すると乱れてしまいます。

@c jp-draft
説明文字列の後には関数の必須要素(本体)があるのに、説明文字列を省
略可能にできるのには理由があります。文字列を評価すると、副作用な
しでその文字列自体が返されるため、文字列が関数の本体の最後の要素
でなければ問題はありません。このように、実際には、本体の1番目の
部分と説明文字列が混同される恐れはありません。本体が文字列だけな
らば、その文字列は戻り値と説明の両方になります。

@node Function Names, Defining Functions, Lambda Expressions, Functions
@section 関数の命名
@c jp-draft
@cindex function definition
@cindex named function
@cindex function name
@cindex 関数定義[かんすうていぎ]
@cindex 名前つき関数[なまえつきかんすう]
@cindex 関数の名前[かんすうのなまえ]

@c jp-draft
ほとんどのコンピュータ言語では、関数にはかならず名前があり、名前
を持たない関数というのは無意味です。Lispでは、厳密な意味での関数
には名前はありません。関数は、最初の要素が@code{lambda}であるリ
ストか、プリミティブなsubrオブジェクトです。

@c jp-draft
しかし、関数の名前としてシンボルを使うこともできます。この場合、
シンボルの@dfn{関数セル(function cell)}(@pxref{Symbol
Components})に関数を置きます。すると、シンボル自体が有効で呼出し可能な関数になり、関数セルが参照するリストまたはsubrオブジェク
トに等価になります。関数セルの内容は、シンボルの@dfn{関数定義
(function definition)}とも呼ばれます。シンボルのかわりにシンボル
の関数定義を使う方法として、@dfn{シンボル関数間接参照(symbol
function indirection)}という方法があります。@ref{Function Indirection}を
参照してください。

@c jp-draft
実際には、ほとんどすべての関数にこのように名前が与えられ、その名
前によって参照されます。たとえば、シンボル@code{car}の関数セルに
はプリミティブsubrオブジェクトの@code{#<subr car>}が格納されてい
るため、シンボル@code{car}は、関数と同
様に機能します。

@c jp-draft
関数に名前を与えるのは、Lisp式で関数を参照しやすくするためです。
@code{#<subr car>}などのプリミティブsubrオブジェクトの場合、名前
でしか参照できません。このようなオブジェクトには、可読の構文はあ
りません。Lispで書かれた関数を呼び出す場合も、明示的なラムダ式を
記述するより名前を使ったほうが便利です。また、名前をもつ関数は、
自分自身を参照できます(再帰呼出しが可能です)。関数の定義にその
関数の名前を記述するほうが、関数定義が自分自身を指すようにするよ
りも簡単です(関数定義が自分自身を指すようにすることは不可能では
ありませんが、実際にはさまざまな短所があります)。

@c jp-draft
関数を示すのに、その関数の名前であるシンボルを使うことがよくあり
ます。たとえば、シンボル@code{car}とその関数定義に格納されている
プリミティブsubrオブジェクトを区別せずに、``関数@code{car}''と表
現することがよくあります。ほとんどの場合、この二つを区別する必要
はありません。

@c jp-draft
ただし、関数に一意な名前を与える必要はないことを覚えておいてくだ
さい。ある特定の関数オブジェクトは、@emph{通常は}一つのシンボルの
関数セルだけに格納されていますが、単に便宜上そうなっているだけで
す。@code{fset}を使えば、複数のシンボルに一つの関数オブジェクトを
簡単に格納できます。この場合、どのシンボルも、同じ関数の名前とし
て同様に通用します。

@c jp-draft
また、関数名として使われているシンボルを変数として使うこともでき
ます。シンボルのこの二つの使い方は独立しており、衝突しません。

@node Defining Functions, Calling Functions, Function Names, Functions
@section 関数の定義方法
@c jp-draft
@cindex defining a function
@cindex 定義、関数の[ていぎ、かんすうの]

@c jp-draft
通常、関数をはじめて作成するときは、関数に名前を与えます。@dfn{関
数を定義する(defining a function)}とは、このことであり、関数を定義
するには@code{defun}特殊形式を使います。

@defspec defun name argument-list body-forms
@c jp-draft
通常、新しいLisp関数を定義するには、@code{defun}を使います。
@code{defun}は、シンボル@var{name}を次のような関数として定義しま
す。

@example
(lambda @var{argument-list} . @var{body-forms})
@end example

@c jp-draft
@code{defun}は、このラムダ式を@var{name}の関数セルに格納します。
返される値は@var{name}ですが、通常はこの値を使うことはありません。

@c jp-draft
以前に説明したように(@pxref{Lambda Expressions})、
@var{argument-list}は引数の名前のリストであり、キーワードの
@code{&optional}と@code{&rest}が使えます。また、@var{body-forms}
の最初の二つの部分は、説明文字列とinteractive宣言にすることも
できます。

@c jp-draft
シンボルの値セルと関数セルは独立しているため、同じシンボル
@var{name}を変数として使っても衝突は発生しません(@xref{Symbol
Components})。

例をいくつか示します。

@example
@group
(defun foo () 5)
     @result{} foo
@end group
@group
(foo)
     @result{} 5
@end group

@group
(defun bar (a &optional b &rest c)
    (list a b c))
     @result{} bar
@end group
@group
(bar 1 2 3 4 5)
     @result{} (1 2 (3 4 5))
@end group
@group
(bar 1)
     @result{} (1 nil nil)
@end group
@group
(bar)
@error{} Wrong number of arguments.
@end group

@group
(defun capitalize-backwards ()
@c jp-draft
  "単語の最後の文字を大文字にします。"
  (interactive)
  (backward-word 1)
  (forward-word 1)
  (backward-char 1)
  (capitalize-word 1))
     @result{} capitalize-backwards
@end group
@end example

@c jp-draft
既存の関数を誤って再定義してしまわないように注意してください。
@code{defun}は、@code{car}などのプリミティブ関数でも何の忠告もな
しに再定義してしまいます。 Lispでは不注意な再定義と意図的な再定
義を区別できないため、すでに定義されている関数の再定義は慎重に行っ
てください。

@end defspec

@defun defalias name definition
@c jp-draft
この特殊形式は、シンボル@var{name}を、定義@var{definition} (任意
の有効なLisp関数が使えます)をもつ関数として定義します。

@code{defalias}は、特定の関数名が定義されている箇所(とくに、ロー
ドされるソース・ファイルに関数名が明示的に現れる箇所)で使ってくだ
さい。これは、@code{defalias}が@code{defun}と同様に関数を定義し
ているファイルを記録するためです(@pxref{Unloading})。

これに対して、ほかの目的で関数の定義を操作するプログラムでは、定義
されているファイルを記録しない@code{fset}を使ってください。

@code{defun}と同様に、関数を定義し、コードを展開するようにLispコン
パイラに指示する@code{defsubst}も参照してください。@xref{Inline Functions}。
@end defun

@node Calling Functions, Mapping Functions, Defining Functions, Functions
@section 関数の呼出し
@c jp-draft
@cindex function invocation
@cindex calling a function
@cindex 関数の起動[かんすうのきどう]
@cindex 呼出し、関数の[よびだし、かんすうの]

@c jp-draft
関数の定義は、作業の半分でしかありません。関数は、@dfn{呼び出す
(call)} (動作するように指示する)までは何もしません。関数の呼出しは、@dfn{起動(invocation)}ともよばれます。

@c jp-draft
関数を起動するための最も一般的な方法は、リストを評価することです。 
たとえば、@code{(concat "a" "b")}というリストを評価することは、
@code{"a"}と@code{"b"}を引数として関数@code{concat}を呼び出すこ
とです。評価の説明については、@xref{Evaluation}。

@c jp-draft
プログラム中の式としてこのリストを書くと、関数の名前はプログラム
の一部になります。つまり、呼び出される関数とその関数に与える引数
を、プログラムを書く時に選択することになります。通常は、これで十
分です。しかし、呼び出される関数を実行時に決定しなければならない
場合もあります。そのためには、@code{funcall}関数と@code{apply}関
数を使います。

@defun funcall function &rest arguments
@c jp-draft
@code{funcall}は、@var{arguments}を引数として@var{function}を呼
び出し、@var{function}が返した値を返します。

@c jp-draft
@code{funcall}は関数であるため、@var{function}を含めたすべての引
数は、@code{funcall}が呼び出される前に評価されます。つまり、任意
の式を使って、呼び出される関数を指定できます。また、
@code{funcall}は、@var{arguments}に書かれている式ではなく、その
値だけを使います。これらの値は、@var{function}が呼び出されるとき、
再び@emph{評価されることはありません}。@code{funcall}は、引数が
評価された時点で、関数を呼び出すための通常の手順に入ります。

@c jp-draft
@var{function}引数は、Lispの関数か、プリミティブ関数でなければな
りません。特殊形式とマクロは``評価されていない''引数式が与えられ
た場合だけ意味をもつため、ここでは使えません。上記のように、
@code{funcall}は未評価の引数を知ることができないためです。

@example
@group
(setq f 'list)
     @result{} list
@end group
@group
(funcall f 'x 'y 'z)
     @result{} (x y z)
@end group
@group
(funcall f 'x 'y '(z))
     @result{} (x y (z))
@end group
@group
(funcall 'and t nil)
@error{} Invalid function: #<subr and>
@end group
@end example

@c jp-draft
上記の例と@code{apply}の例を比較してください。
@end defun

@defun apply function &rest arguments
@c jp-draft
@code{apply}は、@code{funcall}と同様に@var{arguments}を引数とし
て@var{function}を呼び出しますが、一つだけ違いがあります。
@var{arguments}の最後の要素が、単一の引数ではなく、
@var{function}に渡される引数のリストになっています。また、
@code{apply}は、このリストの各要素がそれぞれ一つの引数になるよう
に、リストを@dfn{散開(spread)}します。

@c jp-draft
@code{apply}は、@var{function}を呼び出した結果を返します。
@code{apply}でも、@code{funcall}と同様に、@var{function}はLispの関
数またはプリミティブ関数でなければなりません。@code{apply}では特
殊形式とマクロは無効です。

@example
@group
(setq f 'list)
     @result{} list
@end group
@group
(apply f 'x 'y 'z)
@error{} Wrong type argument: listp, z
@end group
@group
(apply '+ 1 2 '(3 4))
     @result{} 10
@end group
@group
(apply '+ '(1 2 3 4))
     @result{} 10
@end group

@group
(apply 'append '((a b c) nil (x y z) nil))
     @result{} (a b c x y z)
@end group
@end example

@c jp-draft
@code{apply}のおもしろい使い方に関する例は、@ref{Mapping
Functions}の@code{mapcar}の説明を参照してください。
@end defun

@c jp-draft
@cindex functionals
@cindex ファンクショナル[ふぁんくしょなる]
Lisp関数の場合、(フック変数や属性リストのように)引数とし
て関数を受け取ったり、データ構造内に関数を置き、@code{funcall}ま
たは@code{apply}を使ってその関数を呼び出すことがよくあります。関
数引数を受けつける関数は、@dfn{ファンクショナル(functional)}とも呼ば
れます。

@c jp-draft
ファンクショナルを呼び出す場合、何もしない関数を引数として指定でき
ると便利な場合があります。何もしない関数を二つ紹介します。

@defun identity arg
@c jp-draft
この関数は@var{arg}を返すだけで、副作用はありません。
@end defun

@defun ignore &rest args
@c jp-draft
この関数は、引数を無視して@code{nil}を返します。
@end defun

@node Mapping Functions, Anonymous Functions, Calling Functions, Functions
@section マッピング関数
@c jp-draft
@cindex mapping functions
@cindex マッピング関数[まっぴんぐかんすう]

@c jp-draft
@dfn{マッピング関数(mapping function)}は、ある関数をリストなどの各要素に適用します。Emacs Lispには、マッピング関数が三つあります。ここで
説明する@code{mapcar}と@code{mapconcat}は、リストをスキャンしま
す。もう一つのマッピング関数である@code{mapatoms}については、
@ref{Creating Symbols}を参照してください。

@defun mapcar function sequence
@c jp-draft
@code{mapcar}は、@var{sequence}の各要素に@var{function}を順番に
適用し、その結果のリストを返します。

@c jp-draft
@var{sequence}引数には、リスト、ベクタ、または文字列を指定できま
す。結果は常にリストになります。結果のリストの要素数は、 @var{sequence}の
要素数と同じです。

@smallexample
@group
@c jp-draft
@exdent @r{例:}

(mapcar 'car '((a b) (c d) (e f)))
     @result{} (a c e)
(mapcar '1+ [1 2 3])
     @result{} (2 3 4)
(mapcar 'char-to-string "abc")
     @result{} ("a" "b" "c")
@end group

@group
@c jp-draft
;; @r{@code{my-hooks}に含まれる各関数を呼び出します。}
(mapcar 'funcall my-hooks)
@end group

@group
(defun mapcar* (f &rest args)
@c jp-draft
  "すべての引数のcarに関数を順番に適用し、
結果のリストを返します。"
@c jp-draft
  ;; @r{リストの要素がまだ残っていれば、}
  (if (not (memq 'nil args))              
@c jp-draft
      ;; @r{それぞれの@sc{CAR}に関数を適用します。}
      (cons (apply f (mapcar 'car args))  
            (apply 'mapcar* f             
@c jp-draft
                   ;; @r{残りの要素について再帰実行します。}
                   (mapcar 'cdr args)))))
@end group

@group
(mapcar* 'cons '(a b c) '(1 2 3 4))
     @result{} ((a . 1) (b . 2) (c . 3))
@end group
@end smallexample
@end defun

@defun mapconcat function sequence separator
@c jp-draft
@code{mapconcat}は、@var{sequence}の各要素に@var{function}を適用
します。@var{function}が返す値は文字列でなければならず、結果は連
結されます。@code{mapconcat}は、各要素について返された文字列の間
に、文字列@var{separator}を挿入します。通常、@var{separator}には、
スペース、カンマほかの適当な句読点を指定します。

@c jp-draft
@var{function}引数は、引数を一つ取り、文字列を一つ返す関数でなけれ
ばなりません。
  
@smallexample
@group
(mapconcat 'symbol-name
           '(The cat in the hat)
           " ")
     @result{} "The cat in the hat"
@end group

@group
(mapconcat (function (lambda (x) (format "%c" (1+ x))))
           "HAL-8000"
           "")
     @result{} "IBM.9111"
@end group
@end smallexample
@end defun

@node Anonymous Functions, Function Cells, Mapping Functions, Functions
@section 匿名関数
@c jp-draft
@cindex anonymous function
@cindex 匿名関数[とくめいかんすう]

@c jp-draft
Lispでは、関数は、@code{lambda}で始まるリストか、そのようなリス
トからコンパイルされたバイトコード関数か、プリミティブなsubrオブ
ジェクトです。名前は``おまけ''です。通常、関数は@code{defun}を使っ
て定義し、同時に名前も与えますが、明示的にラムダ式(匿名関数)を使っ
たほうがわかりやすい場合もあります。ラムダ式であるリストは、間数
名が使えるところならばどこでも使えます。

@c jp-draft
ラムダ式リストは、どのような手段で作成しても有効な関数になります。 
たとえば、次のような例も有効です。

@smallexample
@group
(setq silly (append '(lambda (x)) (list (list '+ (* 3 4) 'x))))
@result{} (lambda (x) (+ 12 x))
@end group
@end smallexample

@noindent
@c jp-draft
上記の例は、@code{(lambda (x) (+ 12 x))}のようなリストを評価し、
それを@code{silly}の(関数定義@emph{ではなく})値にします。

@c jp-draft
この関数を呼び出す方法を次に示します。

@example
@group
(funcall silly 1)
@result{} 13
@end group
@end example

@noindent
@c jp-draft
(@code{silly}は@code{silly}の@emph{関数定義}ではないため、
@code{(silly 1)}のように書いても@emph{動作しません}。
@code{silly}には関数定義は設定されておらず、変数としての値が与え
られているだけです。)

@c jp-draft
ほとんどの場合、匿名関数は、プログラム中に固定的に書かれます。た
とえば、リストの各要素に関数を適用する@code{mapcar}関数に匿名関
数を引数として渡すとします。数値を2倍する匿名関数を渡す例を次に
示します。

@example
@group
(defun double-each (list)
  (mapcar '(lambda (x) (* 2 x)) list))
@result{} double-each
@end group
@group
(double-each '(2 11))
@result{} (4 22)
@end group
@end example

@noindent
@c jp-draft
このような場合、通常は、単なるクォートを使って匿名関数をクォート
せずに、特殊形式@code{function}を使います。

@defspec function function-object
@c jp-draft
@cindex function quoting
@cindex 関数のクォート[かんすうのくぉーと]
この特殊形式は、@var{function-object}を評価せずに返します。上記の
例では、@code{quote}と等価です。しかし、この特殊形式は.
@var{function-object}が関数としてだけ使われることをEmacs Lispコ
ンパイラに伝えるため、コンパイルが安全に行なわれるようになります。
@ref{Quoting}の@code{quote}と比較してみてください。
@end defspec

@c jp-draft
@code{quote}の代わりに@code{function}を使うと、
コンパイルしようとする関数またはマクロの内部で違いがあります。
例を示しましょう。

@example
@group
(defun double-each (list)
  (mapcar (function (lambda (x) (* 2 x))) list))
@result{} double-each
@end group
@group
(double-each '(2 11))
@result{} (4 22)
@end group
@end example

@noindent
@c jp-draft
この@code{double-each}の定義をコンパイルすると、匿名関数もコンパ
イルされます。一方、通常の@code{quote}を使った前の例の場合、
@code{mapcar}に渡される引数は、次に示すリストになります。

@example
(lambda (x) (* x 2))
@end example

@noindent
@c jp-draft
このリストは関数の形をしていますが、Lispコンパイラは、
@code{mapcar}がリストに対して行う処理を知らないため、このリスト
が関数であることを仮定できません。第3要素の@sc{car}がシンボル
@code{*}であることを@code{mapcar}が調べる可能性もあるためです。
@code{function}の利点は、変化しない関数をコンパイルしても問題が
ないことをコンパイラに伝えられることにあります。

@c jp-draft
関数の名前をクォートするときに、@code{quote}ではなく
@code{function}と書く場合もありますが、これは単にわかりやすくす
るためだけです。

@example
(function @var{symbol}) @equiv{} (quote @var{symbol}) @equiv{} '@var{symbol}
@end example

@code{function}と匿名関数を使った実例については、@ref{Accessing
Documentation}の@code{documentation}を参照してください。

@node Function Cells, Inline Functions, Anonymous Functions, Functions
@section 関数セルの内容へのアクセス
@c jp-draft

@c jp-draft
シンボルの@dfn{関数定義(function definition)}は、シンボルの関数
セルに格納されているオブジェクトです。ここでは、シンボルの関数セ
ルをアクセス、テスト、設定する関数について説明します。

@c jp-draft
@ref{Function Indirection}の@code{indirect-function}関数も参照し
てください。

@defun symbol-function symbol
@kindex void-function
@c jp-draft
この関数は、@var{symbol}の関数セルに格納されているオブジェクトを
返します。シンボルの関数セルがvoidならば、@code{void-function}エラー
が発生します。

この関数は、返されるオブジェクトが有効な関数かどうかはチェックし
ません。

@example
@group
(defun bar (n) (+ n 2))
     @result{} bar
@end group
@group
(symbol-function 'bar)
     @result{} (lambda (n) (+ n 2))
@end group
@group
(fset 'baz 'bar)
     @result{} bar
@end group
@group
(symbol-function 'baz)
     @result{} bar
@end group
@end example
@end defun

@c jp-draft
@cindex void function cell
@cindex voidな関数セル[voidなかんすうせる]
シンボルに関数定義をまったく与えていない場合、そのシンボルの関数セル
が@dfn{void}であるといいます。つまり、関数セルにはLisp
オブジェクトが入っていない状態です。このようなシンボルを呼び出そ
うとすると、@code{void-function}エラーが発生します。


@c jp-draft
voidは、@code{nil}やシンボル@code{void}とは異なります。シンボル
の@code{nil}と@code{void}はLispオブジェクトであり、ほかのオブジェ
クトと同様、関数セルに格納できます(さらに、@code{defun}を使って
定義すれば有効な関数になります)。voidな関数セルには、オブジェ
クトがまったく入っていません。

@c jp-draft
シンボルの関数定義がvoidかどうかを調べるには、@code{fboundp}を使います。
いったん関数定義を与えたシンボルをもう一度voidにするには、@code{fmakunbound}を
使います。

@defun fboundp symbol
@c jp-draft
この関数は、シンボルの関数セルにオブジェクトがあれば@code{t}を返
し、そうでなければ@code{nil}を返します。オブジェクトが有効な関数
かどうかはチェックしません。
@end defun

@defun fmakunbound symbol
@c jp-draft
この関数は、@var{symbol}の関数セルをvoidにします。この関数を呼び
出した後、関数セルにアクセスしようとすると、@code{void-function}
エラーが発生します(@ref{Local Variables}の@code{makunbound}を
参照してください)。

@example
@group
(defun foo (x) x)
     @result{} x
@end group
@group
(foo 1)
     @result{}1
@end group
@group
(fmakunbound 'foo)
     @result{} x
@end group
@group
(foo 1)
@error{} Symbol's function definition is void: foo
@end group
@end example
@end defun

@defun fset symbol object
@c jp-draft
この関数は、@var{symbol}の関数セルに@var{object}を格納し、
@var{object}を返します。通常、@var{object}は関数または関数名です
が、チェックは行なわれません。

@c jp-draft
この関数には、主に三つの使い方があります:

@itemize @bullet
@item
@c jp-draft
あるシンボルの関数定義を別のシンボルにコピーする場合(つまり、関
数の別名を作る場合)

@item
@c jp-draft
リストではないため@code{defun}で作成できない関数定義をシンボルに
与える場合。たとえば、@code{fset}を使って、シンボル@code{s1}に別
のシンボル@code{s2}を関数定義として与えると、@code{s1}は、
@code{s2}の現在の定義とまったく同じものの別名になります。

@item
@c jp-draft
関数を定義したり変更する構文要素内。@code{defun}がプリミティブでない
としたら、@code{fset}を使ってLispで(マクロとして)書くことになる
はずです。
@end itemize

@c jp-draft
最初の二つの場合の例を示します:

@example
@group
@c jp-draft
;; @r{@code{car}と同じ定義を@code{first}に与えます。}
(fset 'first (symbol-function 'car))
     @result{} #<subr car>
@end group
@group
(first '(1 2 3))
     @result{} 1
@end group

@group
@c jp-draft
;; @r{シンボル@code{car}を@code{xfirst}の関数定義にします。}
(fset 'xfirst 'car)
     @result{} car
@end group
@group
(xfirst '(1 2 3))
     @result{} 1
@end group
@group
(symbol-function 'xfirst)
     @result{} car
@end group
@group
(symbol-function (symbol-function 'xfirst))
     @result{} #<subr car>
@end group

@group
@c jp-draft
;; @r{名前つきのキーボード・マクロを定義します。}
(fset 'kill-two-lines "\^u2\^k")
     @result{} "\^u2\^k"
@end group
@end example

@c jp-draft
@ref{Defining Functions}の@code{defalias}関数も参照してください。
@end defun

@c jp-draft
すでに定義されている関数を拡張する関数を作成する場合、次に示す常
套手段がときどき使われます。

@example
(fset 'old-foo (symbol-function 'foo))
(defun foo ()
@c jp-draft
  "more-soを除いてold-fooと同じ。"
@group
  (old-foo)
  (more-so))
@end group
@end example

@noindent
@c jp-draft
@code{foo}が自動ロードされるように定義されている場合、この方法は
うまくいきません。そのような場合、@code{foo}が@code{old-foo}を呼
び出すと、Lispシステムはファイルをロードして@code{old-foo}を定義
しようとします。ファイルをロードすると、おそらく@code{old-foo}で
はなく@code{foo}が定義されてしまい、適切な結果が得られません。こ
の問題を避けるには、ファイルをロードしてから@code{foo}の以前の定
義を置き換えるしかありません。

しかし、ほかの箇所で定義されている関数をLispファイルで再定義するの
は、どちらにしろモジュール化に反し、きれいではありません。

@node Inline Functions, Related Topics, Function Cells, Functions
@section インライン関数
@c jp-draft
@cindex inline functions
@cindex インライン関数[いんらいんかんすう]

@findex defsubst
@c jp-draft
@dfn{インライン関数(inline function)}を定義するには、
@code{defun}ではなく@code{defsubst}を使います。インライン関数
は普通の関数と同様に動作します。ただし、インライン関数への呼出しを
コンパイルすると、関数の定義が呼び出し側に展開されます。

@c jp-draft
関数をインラインにすると、明示的な呼出しが高速に実行されるよう
になります。しかし、欠点もあります。まず、柔軟性が低下します。関
数の定義を変更しても、すでにインライン展開されている呼出しには
再コンパイルするまで古い定義が使われます。関数の再定義の柔軟性は
Emacsの重要な特徴であるため、実行速度が本当に重要でなければ、関
数をインラインにしないでください。

@c jp-draft
もう一つの欠点は、大きな関数をインラインにすると、コンパイルされ
たコードのファイル・サイズとメモリ・サイズが増加することです。イ
ンライン関数の速度面での利点は小さな関数の場合にもっとも発揮され
るので、通常は大きな関数をインラインにしないでください。

@c jp-draft
インライン関数が実行するのと同じコードに展開されるマクロを定義す
ることもできます。しかし、マクロには限界があります。マクロは明示
的にしか使うことができず、@code{apply}や@code{mapcar}などで呼び
出すことはできません。また、通常の関数をマクロに書き換えるには手
間がかかります(@xref{Macros})。通常の関数をインライン関数に書き
換えるのは非常に簡単で、@code{defun}を@code{defsubst}で置き換え
るだけです。インライン関数に書く引数は一度だけ評価されるため、マ
クロのように本体内での引数の使用回数を気にする必要はありません
(@xref{Argument Evaluation})。

@c jp-draft
インライン関数を使うと、マクロと同様に、その定義にしたがって同じ
ファイル内のその関数の呼出しが展開されます。

@c jp-draft
@c バージョン19よりも前のEmacsには、インライン関数はありません。

@node Related Topics,  , Inline Functions, Functions
@section 関数に関するほかの項目
@c jp-draft

関数の呼出しと定義に関する機能をもつ関数をいくつか次の表に示し
ます。これらの関数は別のところでも触れられていますが、クロスリファ
レンスを示しておきます。

@table @code
@item apply
@c jp-draft
@ref{Calling Functions}を参照。

@item autoload
@c jp-draft
@ref{Autoload}を参照。

@item call-interactively
@c jp-draft
@ref{Interactive Call}を参照。

@item commandp
@c jp-draft
@ref{Interactive Call}を参照。

@item documentation
@c jp-draft
@ref{Accessing Documentation}を参照。

@item eval
@c jp-draft
@ref{Eval}を参照。

@item funcall
@c jp-draft
@ref{Calling Functions}を参照。

@item ignore
@c jp-draft
@ref{Calling Functions}を参照。

@item indirect-function
@c jp-draft
@ref{Function Indirection}を参照。

@item interactive
@c jp-draft
@ref{Using Interactive}を参照。

@item interactive-p
@c jp-draft
@ref{Interactive Call}を参照。

@item mapatoms
@c jp-draft
@ref{Creating Symbols}を参照。

@item mapcar
@c jp-draft
@ref{Mapping Functions}を参照。

@item mapconcat
@c jp-draft
@ref{Mapping Functions}を参照。

@item undefined
@c jp-draft
@ref{Key Lookup}を参照。
@end table
