This is the GNU Emacs Lisp Reference Manual corresponding to Emacs version 29.3.

Published by the Free Software Foundation
51 Franklin St, Fifth Floor
Boston, MA 02110-1301
USA
ISBN 1-882114-74-4

Emacs Lisp

This is the GNU Emacs Lisp Reference Manual corresponding to Emacs version 29.3.

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with the Invariant Sections being “GNU General Public License,” with the Front-Cover Texts being “A GNU Manual,” and with the Back-Cover Texts as in (a) below. A copy of the license is included in the section entitled “GNU Free Documentation License.”

(a) The FSF’s Back-Cover Text is: “You have the freedom to copy and modify this GNU manual. Buying copies from the FSF supports it in developing GNU and promoting software freedom.”


1 イントロダクション		イントロダクションと使用される慣習。
2 Lispのデータ型		Emacs Lispでのオブジェクトのデータタイプ。
3 数値		数値と算術関数。
4 文字列と文字		文字列とそれらを処理する関数。
5 リスト		リスト、コンスセルと関連する関数。
6 シーケンス、配列、ベクター		リスト、文字列、ベクターはシーケンスと呼ばれる。特定の関数は任意の種類のシーケンスに機能する。ここではベクターの説明も行う。
7 レコード		Compound objects with programmer-defined types.
8 ハッシュテーブル		非常に高速な照会テーブル。
9 シンボル		名前を一意に表すシンボル。

10 評価		Lisp式が評価される方法。
11 制御構造		条件文、ループ、非ローカル脱出。
12 変数		プログラムで値を表すためにシンボルを使用する。
13 関数		関数とは別の関数から呼び出せるLispプログラムである。
14 マクロ		マクロとはLisp言語を拡張する手段である。
15 カスタマイゼーション設定		変数やフェイスをカスタマイズ可能にする。

16 ロード		LispコードのファイルをLispに読み込む。
17 バイトコンパイル		プログラム実行を高速にするコンパイル。
18 Lispからネイティブコードへのコンパイル		Compile Lisp into native machine code.
19 Lispプログラムのデバッグ		Lispプログラムのデバッグのためのツールとヒント。

20 Lispオブジェクトの読み取りとプリント		Lispオブジェクトからテキストへの変換と逆変換。
21 ミニバッファー		入力を読み取るためにミニバッファーを使用する。
22 コマンドループ		エディターコマンドループが機能する方法と、そのサブルーチンを呼び出す方法。
23 キーマップ		キーをコマンドにバインドするための定義。
24 メジャーモードとマイナーモード		メジャーモードとマイナーモードの定義。
25 ドキュメント		ドキュメント文字列の記述と使用。

26 ファイル		ファイルへのアクセス。
27 バックアップと自動保存		バックアップファイルト自動保存ファイルの作成方法の制御。
28 バッファー		バッファーオブジェクトの作成と使用。
29 ウィンドウ		ウィンドウの操作とバッファーの表示。
30 フレーム		システムレベルウィンドウを複数作成する。
31 ポジション		バッファー位置と移動関数。
32 マーカー		マーカーは位置を表し、テキスト変更時に自動的に更新される。

33 テキスト		バッファー内のテキストの調査と変更。
34 非ASCII文字		バッファーと文字列内の非ASCIIテキスト。
35 検索とマッチング		バッファー内の文字列や正規表現の検索。
36 構文テーブル		単語やリストの解析を制御する構文テーブル。
37 プログラムソースの解析		Generate syntax tree for program sources.
38 abbrevとabbrev展開		Abbrevモードが機能する方法と、そのデータ構造。

39 スレッド		Concurrency in Emacs Lisp.
40 プロセス		サブプロセスの実行と対話。
41 Emacsのディスプレイ表示		スクリーン表示を制御するための機能。
42 オペレーティングシステムのインターフェース		ユーザーID、システムタイプ、環境変数、その他類似項目の取得。

43 配布用Lispコードの準備		配布用にLispコードを準備する。
Appendices
Appendix A Emacs 28のアンチニュース		Info for users downgrading to Emacs 28.
Appendix B GNU Free Documentation License		このドキュメントのライセンス。
Appendix C GNU General Public License		GNU Emacsの複製と変更を行うための条件。
Appendix D ヒントと規約		Emacs Lispのコーディング規約にたいするアドバイス。
Appendix E GNU Emacsの内部		Emacsのビルドとダンプ、内部的な構造。
Appendix F 標準的なエラー		いくつかの標準的なエラーシンボルのリスト。
Appendix G 標準的なキーマップ		いくつかの標準的なキーマップのリスト。
Appendix H 標準的なフック		いくつかの標準的なフック変数のリスト。

Index		概念、関数、変数、その他用語のインデックス。

— 詳細ノードリスト — ——————————— 以下はすでにリストしたもののサブノードであるようなノードのリストです。1ステップで移動できるようにここに記します: Introduction
1.1 注意事項		不備な点と、助けを求める方法。
1.2 Lispの歴史		Emacs LispはMaclispの子孫です。
1.3 Lispの歴史		このマニュアルのフォーマット方法。
1.4 バージョンの情報		実行中のEmacsのバージョンは?
1.5 謝辞		このマニュアルの著者、編集者、スポンサー。
Conventions
1.3.1 Lispの歴史		このマニュアルで使用する用語の説明。
1.3.2 `nil`と`t`		シンボル`nil`と`t`の使用方法。
1.3.3 評価の表記		評価の例で使用するフォーマット。
1.3.4 プリントの表記		テキストのプリント例で使用するフォーマット。
1.3.5 エラーメッセージ		エラー例で使用するフォーマット。
1.3.6 バッファーテキストの表記		例のバッファー内容で使用するフォーマット。
1.3.7 説明のフォーマット		関数や変数などの説明にたいする表記。
Format of Descriptions
1.3.7.1 関数の説明例		架空の関数`foo`にたいする記述例。
1.3.7.2 変数の説明例		架空の変数`electric-future-map`にたいする記述例。
Lisp Data Types
2.1 プリント表現と読み取り構文		Lispオブジェクトがテキストとして表現される方法。
2.2 特別な読み取り構文		An overview of all the special sequences.
2.3 コメント		コメントとコメント書式の慣例。
2.4 プログラミングの型		すべてのLispシステムに存在する型。
2.5 編集用の型		Emacs固有の型。
2.6 循環オブジェクトの読み取り構文		循環構造にたいする入力構文。
2.7 型のための述語		型に関連するテスト。
2.8 同等性のための述語		2つのオブジェクトが等しいかのテスト。
2.9 可変性		Some objects should not be modified.
Programming Types
2.4.1 整数型		小数部のない数字。
2.4.2 浮動小数点数型		広い範囲をもつ、小数部をもつ数字。
2.4.3 文字型		文字、数字、コントロール文字にたいする表現。
2.4.4 シンボル型		関数、変数、プロパティリストを参照する、一意に識別される多目的オブジェクト。
2.4.5 シーケンス型		リストと配列はどちらもシーケンスに分類される。
2.4.6 コンスセルとリスト型		コンスセル、および(コンスセルにより作られる)リスト。
2.4.7 配列型		配列には文字列とベクターが含まれる。
2.4.8 文字列型		(効率的な)文字の配列。
2.4.9 ベクター型		1次元の配列。
2.4.10 文字テーブル型		文字によりインデックスされる1次元の疎な配列。
2.4.11 ブールベクター型		`t`と`nil`からなる、1次元の配列。
2.4.12 ハッシュテーブル型		とても高速な参照用のテーブル。
2.4.13 関数型		他の場所から呼び出せる実行可能なコードの断片。
2.4.14 マクロ型		より基本的だが少し見栄えの悪い、式を他の式に展開する手法。
2.4.15 プリミティブ関数型		Lispから呼び出せる、Cで記述された関数。
2.4.16 バイトコード関数型		Lispで記述されてからコンパイルされた関数。
2.4.17 レコード型		Compound objects with programmer-defined types.
2.4.18 型記述子		Objects holding information about types.
2.4.19 autoload型		頻繁に使用されない関数を自動的にロードするために使用される型。
2.4.20 ファイナライザー型		Runs code when no longer reachable.
Character Type
2.4.3.1 基本的な文字構文		標準的な文字の構文。
2.4.3.2 一般的なエスケープ構文		文字をコードにより指定する方法。
2.4.3.3 コントロール文字構文		コントロール文字の構文。
2.4.3.4 メタ文字構文		メタ文字の構文。
2.4.3.5 その他の文字修飾ビット		ハイパー、スーパー、アルト文字の構文。
Cons Cell and List Types
2.4.6.1 ボックスダイアグラムによるリストの描写		リストを絵で書いたら。
2.4.6.2 ドットペア表記		コンスセルの一般的な構文。
2.4.6.3 連想リスト型		コンスセルの一般的な構文。
String Type
2.4.8.1 文字列の構文		Lisp文字列を指定する方法。
2.4.8.2 文字列内の非ASCII文字		文字列内の国際化文字。
2.4.8.3 文字列内の非プリント文字		文字列内の印刷不可能なリテラル文字。
2.4.8.4 文字列内のテキストプロパティ		テキストプロパティをともなう文字列。
Editing Types
2.5.1 バッファー型		編集のための基本オブジェクト。
2.5.2 マーカー型		バッファー内の位置。
2.5.3 ウィンドウ型		バッファーはウィンドウ内に表示する。
2.5.4 フレーム型		ウィンドウはフレームを細分化する。
2.5.5 端末型		フレームを表示する端末デバイス。
2.5.6 ウィンドウ構成型		フレームが細分化された方法を記録する。
2.5.7 フレーム構成型		すべてのフレームの状態を記録する。
2.5.8 プロセス型		背後のOS上で実行されるEmacsのサブプロセス。
2.5.9 スレッド型		A thread of Emacs Lisp execution.
2.5.10 ミューテックス型		An exclusive lock for thread synchronization.
2.5.11 状態変数型		Condition variable for thread synchronization.
2.5.12 ストリーム型		文字の受信と送信。
2.5.13 キーマップ型		キーストロークがどの関数を呼び出すか。
2.5.14 オーバーレイ型		オーバーレイが表示される方法。
2.5.15 フォント型		テキストを表示するフォント。
2.5.16 Xwidget型		Embeddable widgets.
Numbers
3.1 整数の基礎		整数の表現と範囲。
3.2 浮動小数点数の基礎		浮動小数の表現と範囲。
3.3 数値のための述語		数にたいするテスト。
3.4 数値の比較		同一性と非同一性の述語。
3.5 数値の変換		浮動小数点数から整数、またはその逆の変換。
3.6 算術演算		加減乗除の方法。
3.7 丸め処理		浮動小数点数の明示的な丸め。
3.8 整数にたいするビット演算		論理的なand、or、not、shift。
3.9 標準的な数学関数		三角関数、指数、対数関数。
3.10 乱数		予測可能または不可能な乱数の取得。
Strings and Characters
4.1 文字列と文字の基礎		文字列と文字の基本的なプロパティ。
4.2 文字列のための述語		オブジェクトが文字列か文字かをテストする。
4.3 文字列の作成		新しい文字列を割り当てる関数。
4.4 文字列の変更		既存の文字列の内容を変更する。
4.5 文字および文字列の比較		文字または文字列を比較する。
4.6 文字および文字列の変換		文字から文字列、文字から文字列への変換。
4.7 文字列のフォーマット		`format`: `printf`’のEmacsバージョン。
4.9 Lispでの大文字小文字変換		case変換関数。
4.10 caseテーブル		case変換のカスタマイズ。
Lists
5.1 リストとコンスセル		コンスセルからリストが作られる方法。
5.2 リストのための述語		このオブジェクトはリストか? 2つのリストを比較する。
5.3 リスト要素へのアクセス		リストの一部を抽出する。
5.4 コンスセルおよびリストの構築		リスト構造の作成。
5.5 リスト変数の変更		変数に保存されたリストにたいする変更。
5.6 既存のリスト構造の変更		既存のリストに新しい要素を保存する。
5.7 集合としてのリストの使用		リストは有限な数学集合を表現できる。
5.8 連想リスト		リストは有限な関係またはマッピングを表現できます。
5.9 プロパティリスト		要素ペアのリスト。
Modifying Existing List Structure
5.6.1 `setcar`によるリスト要素の変更		リスト内の要素の置き換え。
5.6.2 リストのCDRの変更		リストの根幹部分の置き換え。これは要素の追加や削除に使用される。
5.6.3 リストを再配置する関数		リスト内の要素の再配置、リストの合成。
Property Lists
5.9.1 プロパティリストと連想リスト		プロパティリストと連想リストの利点の比較。
5.9.2 プロパティリストと外部シンボル		他の場所に保管されたプロパティリストへのアクセス。
Sequences, Arrays, and Vectors
6.1 シーケンス		任意の種類のシーケンスを許す関数。
6.2 配列		Emacs Lispの配列の特徴。
6.3 配列を操作する関数		Emacs Lispの配列の特徴。
6.4 ベクター		Emacs Lispベクターの特質。
6.5 ベクターのための関数		ベクターのための特別な関数。
6.6 文字テーブル		文字テーブルを扱う方法。
6.7 ブールベクター		ブールベクターを扱う方法。
6.8 オブジェクト用固定長リングの管理		オブジェクトの固定サイズのリングを管理する。
Records
7.1 レコード関数		Functions for records.
7.2 後方互換		Compatibility for cl-defstruct.
Hash Tables
8.1 ハッシュテーブルの作成		ハッシュテーブルを作成する関数。
8.2 ハッシュテーブルへのアクセス		ハッシュテーブルの内容の読み書き。
8.3 ハッシュの比較の定義		新たな比較方法の定義。
8.4 ハッシュテーブルのためのその他関数		その他。
Symbols
9.1 シンボルの構成要素		シンボルは名前、値、関数定義、プロパティリストをもつ。
9.2 シンボルの定義		定義は、シンボルが使用される方法を示す。
9.3 シンボルの作成とintern		シンボルが一意に保たれる方法。
9.4 シンボルのプロパティ		さまざまな情報を記録するために、各シンボルはプロパティリストをもつ。
9.5 ショートハンド		Properly organize your symbol names but type less of them.
9.6 位置をもつシンボル		Symbol variants containing integer positions
Symbol Properties
9.4.1 シンボルのプロパティへのアクセス		シンボルプロパティへのアクセス。
9.4.2 シンボルの標準的なプロパティ		シンボルプロパティの標準的な意味。
Evaluation
10.1 評価の概要		事の在り方における評価。
10.2 フォームの種類		さまざまなオブジェクト類が評価される方法。
10.3 クォート		(プログラム内に定数を配すための)評価の回避。
10.4 バッククォート		リスト構造の、より簡単な構築。
10.5 evalについて		Lispインタープリターを明示的に呼び出す方法。
10.6 遅延されたLazy評価		Deferred and lazy evaluation of forms.
Kinds of Forms
10.2.1 自己評価を行うフォーム		自分自身を評価するフォーム。
10.2.2 シンボルのフォーム		変数として評価されるシンボル。
10.2.3 リストフォームの分類		さまざまな種類のリストフォームを区別する方法。
10.2.4 シンボル関数インダイレクション		シンボルがリストのcarにある場合、そのシンボルを通じて実際の関数を見つける。
10.2.5 関数フォームの評価		関数を呼び出すフォーム。
10.2.6 Lispマクロの評価		マクロを呼び出すフォーム。
10.2.7 スペシャルフォーム		Special forms are idiosyncratic primitives, most of them extremely important.
10.2.8 自動ロード		実際の定義を含むファイルのロードをセットアップする関数。
Control Structures
11.1 順序		テキスト順の評価。
11.2 条件		`if`、`cond`、`when`、`unless`。
11.3 組み合わせ条件の構築		`and`、`or`、`not`。
11.4 パターンマッチングによる条件		How to use `pcase` and friends.
11.5 繰り返し		`while`ループ。
11.6 ジェネレーター		Generic sequences and coroutines.
11.7 非ローカル脱出		シーケンスの外へジャンプ。
Nonlocal Exits
11.7.1 明示的な非ローカル脱出: `catch`と`throw`		プログラム自身の目的による非ローカル脱出。
11.7.2 `catch`と`throw`の例		このような非ローカル脱出が記述される方法。
11.7.3 エラー		エラーがシグナル・処理される方法。
11.7.4 非ローカル脱出のクリーンアップ		エラーが発生した場合のクリーンアップフォーム実行のアレンジ。
Errors
11.7.3.1 エラーをシグナルする方法		エラーを報告する方法。
11.7.3.2 Emacsがエラーを処理する方法		エラーを報告するときEmacsが何を行なうか。
11.7.3.3 エラーを処理するコードの記述		エラーをトラップして実行を継続する方法。
11.7.3.4 エラーシンボルとエラー条件		エラートラッピングのために、エラーをクラス分けする方法。
Variables
12.1 グローバル変数		どの場所でも永続的に存在する変数の値。
12.2 変更不可な変数		Variables that never change.
12.3 ローカル変数		一時的にのみ存在する存在する変数の値。
12.4 変数がvoidのとき		値を持たないシンボル。
12.5 グローバル変数の定義		シンボルが変数として使用されていることを宣言する定義。
12.6 堅牢な変数定義のためのヒント		変数を定義するときに考慮すべき事項。
12.7 変数の値へのアクセス		実行時に判明する名前をもつ変数の値を確認する。
12.8 変数の値のセット		変数に新しい値を格納する。
12.9 変数が変更されたときに実行される関数。		Running a function when a variable is changed.
12.10 変数のバインディングのスコーピングルール		Lispがローカル値とグローバル値を選択する方法。
12.11 バッファーローカル変数		1つのバッファーないだけで効果をもつ変数の値。
12.12 ファイルローカル変数		ファイル内にリストされたローカル変数の処理。
12.13 ディレクトリーローカル変数		ディレクトリー内のすべてのファイルで共通のローカル変数。
12.14 接続ローカル変数		Local variables common for remote connections.
12.15 変数のエイリアス		他の変数のエイリアスとなる変数。
12.16 値を制限された変数		任意のLispオブジェクトを値とすることができない、定数ではない変数。
12.17 ジェネリック変数		変数の概念の拡張。
12.18 マルチセッション変数		Variables that survive restarting Emacs.
Scoping Rules for Variable Bindings
12.10.1 ダイナミックバインディング		Emacs内でのローカル変数にたいするデフォルトのバインディング。
12.10.2 ダイナミックバインディングの正しい使用		ダイナミックバインディングによる問題を回避する。
12.10.3 レキシカルバインディング		ローカル変数にたいする他の種類のバインディング。
12.10.4 レキシカルバインディングの使用		レキシカルバインディングを有効にする方法。
12.10.5 レキシカルバインディングへの変換		Convert existing code to lexical binding.
Buffer-Local Variables
12.11.1 バッファーローカル変数の概要		イントロダクションと概念。
12.11.2 バッファーローカルなバインディングの作成と削除
12.11.3 バッファーローカル変数のデフォルト値		自身ではバッファーローカルな値をもたないバッファーで参照されるデフォルト値。
Generalized Variables
12.17.1 `setf`マクロ
12.17.2 新たな`setf`フォーム		新たな`setf`フォームの定義。
Multisession Variables
12.18 マルチセッション変数		Variables that survive restarting Emacs.
Functions
13.1 関数とは?		Lisp関数 vs. プリミティブ。専門用語。
13.2 ラムダ式		関数がLispオブジェクトとして表現される方法。
13.3 関数の命名		シンボルは関数を名づける役割を果たすことができる。
13.4 関数の定義		関数定義のためのLisp式。
13.5 関数の呼び出し		既存の関数を使う方法。
13.6 関数のマッピング		リストの各要素などに関数を適用する。
13.7 無名関数		ラムダ式、それは無名の関数。
13.8 ジェネリック関数		Polymorphism, Emacs-style.
13.9 関数セルの内容へのアクセス		シンボルの関数定義へのアクセスとセット。
13.10 クロージャ		レキシカル環境に囲まれた関数。
13.11 オープンクロージャ		Function objects with meta-data.
13.12 Emacs Lisp関数にたいするアドバイス		Adding to the definition of a function.
13.13 関数の陳腐化の宣言		関数を陳腐と宣言する。
13.14 インライン関数Inli		コンパイラーによりインライン展開される関数。
13.15 `declare`フォーム		関数についての補足的な情報の追加。
13.16 コンパイラーへの定義済み関数の指示		関数が定義されていることをコンパイラーに知らせる。
13.17 安全に関数を呼び出せるかどうかの判断		呼び出しても安全な関数なのか判断する。
13.18 関数に関するその他トピック		関数が動作する方法において特別な意味をもつ、特定のLispプリミティブのクロスリファレンス。
Lambda Expressions
13.2.1 ラムダ式の構成要素		ラムダ式のパーツ。
13.2.2 単純なラムダ式の例		シンプルな例。
13.2.3 引数リストの機能		引数リストの詳細と特別な機能。
13.2.4 関数のドキュメント文字列		関数内にドキュメントを記述する方法。
Advising Emacs Lisp Functions
13.12.1 アドバイスを操作するためのプリミティブ		Primitives to manipulate advice.
13.12.2 名前つき関数にたいするアドバイス		Advising named functions.
13.12.3 アドバイスの構築方法		Ways to compose advice.
13.12.4 古いdefadviceを使用するコードの改良		Adapting code using the old defadvice.
13.12.5 アドバイスとバイトコード		Not all functions can be advised.
Macros
14.1 単純なマクロの例		基本的な例。
14.2 マクロ呼び出しの展開		いつ、なぜ、どのようにしてマクロが展開されるか。
14.3 マクロとバイトコンパイル		コンパイラーによりマクロが展開される方法。
14.4 マクロの定義		マクロ定義を記述する方法。
14.5 マクロ使用に関する一般的な問題		マクロ引数を何回も評価しないこと。ユーザーの変数を隠さないこと。
14.6 マクロのインデント		マクロ呼び出しのインデント方法の指定。
Common Problems Using Macros
14.5.1 タイミング間違い		マクロ内ではなく展開形で作業を行う。
14.5.2 マクロ引数の多重評価		展開形は各マクロ引数を一度評価すること。
14.5.3 マクロ展開でのローカル変数		展開形でのローカル変数バインディングには特に注意を要する。
14.5.4 展開におけるマクロ引数の評価		評価せずに展開形の中に配置すること。
14.5.5 マクロが展開される回数は?		展開が行われる回数への依存を避ける。
Customization Settings
15.1 一般的なキーワードアイテム		すべての種類のカスタマイズ宣言に共通なキーワード引数。
15.2 カスタマイゼーショングループの定義		カスタマイズグループ定義の記述。
15.3 カスタマイゼーション変数の定義		ユーザーオプションの宣言。
15.4 カスタマイゼーション型		ユーザーオプションの型指定。
15.5 カスタマイゼーションの適用		カスタマイズセッティングを適用する関数。
15.6 Customテーマ		カスタムテーマの記述。
Customization Types
15.4.1 単純型		シンプルなカスタマイズ型(sexp、integerなど)。
15.4.2 複合型		他の型やデータから新しい型を構築する。
15.4.3 リストへのスプライス		`:inline`で要素をリストに結合する。
15.4.4 型キーワード		カスタマイズ型でのキーワード／引数ペアー
15.4.5 新たな型の定義		型に名前をつける。
Loading
16.1 プログラムがロードを行う方法		`load`’関数、その他。
16.2 ロードでの拡張子		`load`’が試みられるサフィックスについての詳細。
16.3 ライブラリー検索		ロードするライブラリーの検索。
16.4 非ASCII文字のロード		Emacs Lispファイル内の非ASCII文字。
16.5 autoload		オートロードのための関数のセットアップ。
16.6 多重ロード		ファイルを2度ロードする場合の配慮。
16.7 名前つき機能		まだロードされていないライブラリーのロード。
16.8 どのファイルで特定のシンボルが定義されているか		特定のシンボルがどのファイルで定義されているかの検索。
16.9 アンロード		ロードされたライブラリーをunloadする方法。
16.10 ロードのためのフック		特定のライブラリーがロードされたとき実行されるコードの提供。
16.11 Emacsのダイナミックモジュール		Modules provide additional Lisp primitives.
Byte Compilation
17.1 バイトコンパイル済みコードのパフォーマンス		バイトコンパイルによるスピードアップ例。
17.2 バイトコンパイル関数
17.3 ドキュメント文字列とコンパイル		ドキュメント文字列のダイナミックロード。
17.4 個々の関数のダイナミックロード
17.5 コンパイル中の評価		コンパイル時に評価されるコード。
17.6 コンパイラーのエラー		コンパイラーのエラーメッセージの扱い。
17.7 バイトコード関数オブジェクト		バイトコンパイル済み関数に使用されるデータ型。
17.8 逆アセンブルされたバイトコード		バイトコードの逆アセンブル。バイトコードの読み方。
Native Compilation
18.1 ネイティブコンパイル関数		Functions to natively-compile Lisp.
18.2 ネイティブコンパイル関数		Variables controlling native compilation.
Debugging Lisp Programs
19.1 Lispデバッガ		Emacs Lisp評価機能にたいするデバッガ。
19.2 Edebug		Emacs Lispソースレベルデバッガ。
19.3 無効なLisp構文のデバッグ		シンタックスエラーを見つける方法。
19.4 カバレッジテスト		プログラムのすべての分岐を確実にテストする。
19.5 プロファイリング		あなたのコードが使用するリソースの計測。
The Lisp Debugger
19.1.1 エラーによるデバッガへのエンター		エラー発生時にデバッガにエンターする。
19.1.3 無限ループのデバッグ		exitしないプログラムの停止デバッグ。
19.1.4 関数呼び出しによるデバッガへのエンター		特定の関数が呼び出されたときにデバッガにエンターする。
19.1.5 変数の変更時にデバッガにエンターする。		Entering it when a variable is modified.
19.1.6 明示的なデバッガへのエントリー		プログラム内の特定箇所でデバッガにエンターする。
19.1.7 デバッガの使用		What the debugger does.
19.1.8 バックトレース		What you see while in the debugger.
19.1.9 デバッガのコマンド		デバッガで使用するコマンド。
19.1.10 デバッガの呼び出し		関数`debug`の呼び出し方。
19.1.11 デバッガの内部		デバッガのサブルーチン、およびグローバル変数。
Edebug
19.2.1 Edebugの使用		Edebug使用のための手引き。
19.2.2 Edebugのためのインストルメント		Edebugでデバッグするために、コードをインストルメント(計装)しなければならないe
19.2.3 Edebugの実行モード		多かれ少なかれ、ストップする実行モード。
19.2.4 ジャンプ		特定の位置にジャンプするコマンド。
19.2.5 その他のEdebugコマンド		さまざまなコマンド。
19.2.6 ブレーク		プログラムをストップさせるbreakpointのセット。
19.2.7 エラーのトラップ		Edebugでのエラーのトラップ。
19.2.8 Edebugのビュー		Edebugの内側と外側のビュー。
19.2.9 評価		Edebugでの式の評価。
19.2.10 評価リストバッファー		Edebugにエンターするたびに値が表示される式。
19.2.11 Edebugでのプリント		プリントのカスタマイズ。
19.2.12 トレースバッファー		バッファー内で採れを生成する方法。
19.2.13 カバレッジテスト		評価をカバレッジテストする方法。
19.2.14 コンテキスト外部		Edebugが保存およびリストアするデータ。
19.2.15 Edebugとマクロ		マクロ呼び出しをハンドルする方法の指定。
19.2.16 Edebugのオプション		Edebugをカスタマイズするオプション変数。
Breaks
19.2.6.1 Edebugのブレークポイント		ストップポイントのbreakpoint。
19.2.6.2 グローバルなブレーク条件		イベントによるbreak。
19.2.6.3 ソースブレークポイント		ソースコードに埋め込まれたbreakpoint。
The Outside Context
19.2.14.1 停止するかどうかのチェック		何を行うかをEdebugが決定するタイミング。
19.2.14.2 Edebugの表示の更新		Edebugがディスプレイを更新するタイミング。
19.2.14.3 Edebugの再帰編集		Edebugが実行をストップするタイミング。
Edebug and Macros
19.2.15.1 マクロ呼び出しのインストルメント		基本的な問題点。
19.2.15.2 仕様リスト		式の複雑なパターンを指定する方法。
19.2.15.3 仕様でのバックトレース		マッチに失敗したときEdebugが行なうこと。
19.2.15.4 仕様の例		Edebug仕様を理解するために。
Debugging Invalid Lisp Syntax
19.3.1 過剰な開カッコ		誤った開カッコと閉カッコを探す方法。
19.3.2 過剰な閉カッコ		誤った閉カッコと開カッコを探す方法。
Reading and Printing Lisp Objects
20.1 読み取りとプリントの概念		ストリーム、読み取り、プリントの概観。
20.2 入力ストリーム		入力ストリームとして使用できる、さまざまなデータ型。
20.3 入力関数		テキストからLispオブジェクトを読み取る関数。
20.4 出力ストリーム		出力ストリームとして使用できる、さまざまなデータ型。
20.5 出力関数		テキストとしてLispオブジェクトをプリントする関数。
20.6 出力に影響する変数		プリント関数が何を行うか制御する変数。
20.7 出力変数のオーバーライド		Overriding output variables.
Minibuffers
21.1 ミニバッファーの概要		ミニバッファーに関する基本的な情報。
21.2 ミニバッファーでのテキスト文字列の読み取り		そのままのテキスト文字列を読み取る方法。
21.3 ミニバッファーでのLispオブジェクトの読み取り		Lispオブジェクトや式を読み取る方法。
21.4 ミニバッファーのヒストリー		ユーザーが再利用できるように以前のミニバッファー入力は記録される。
21.5 入力の初期値		ミニバッファーにたいして初期内容を指定する。
21.6 補完		補完の呼び出しとカスタマイズ方法。
21.7 Yes-or-Noによる問い合わせ		問いにたいし単純な答えを求める。
21.8 複数の問いを尋ねる		一連の似たような問いに答える。
21.9 パスワードの読み取り		端末からパスワードを読み取る。
21.10 ミニバッファーのコマンド		ミニバッファー内でキーバインドとして使用されるコマンド。
21.11 ミニバッファーのウィンドウ		特殊なミニバッファーウィンドウを処理する。
21.12 ミニバッファーのコンテンツ		どのようなコマンドがミニバッファーのテキストにアクセスするか。
21.13 再帰的なミニバッファー		ミニバッファーへの再帰的なエントリーが許容されるかどうか。
21.14 対話の抑止		Running Emacs when no interaction is possible.
21.15 ミニバッファー、その他の事項		カスタマイズ用のさまざまなフックや変数。
Completion
21.6.1 基本的な補完関数		文字列を補完する低レベル関数。
21.6.2 補完とミニバッファー		補完つきでミニバッファーを呼び出す。
21.6.3 補完を行うミニバッファーコマンド
21.6.4 高レベルの補完関数		特別なケースに有用な補完(バッファー名や変数名などの読み取り)。
21.6.5 ファイル名の読み取り		ファイル名やシェルコマンドの読み取りに補完を使用する。
21.6.6 補完変数		補完の挙動を制御する変数。
21.6.7 プログラムされた補完		独自の補完関数を記述する。
21.6.8 通常バッファーでの補完		通常バッファー内でのテキスト補完。
Command Loop
22.1 コマンドループの概要		コマンドループがコマンドを読み取る方法。
22.2 コマンドの定義		関数が引数を読み取る方法を指定する。
22.3 インタラクティブな呼び出し		引数を読み取るようにコマンドを呼び出す。
22.4 インタラクティブな呼び出しの区別		インタラクティブな呼び出しとコマンドを区別する。
22.5 コマンドループからの情報		検証用にコマンドループによりセットされる変数。
22.6 コマンド後のポイントの調整		コマンドの後にポイント位置を調整する。
22.7 入力イベント		入力を読み取るとき、入力がどのように見えるか。
22.8 入力の読み取り		キーボードやマウスからの入力イベントを読み取る方法。
22.9 スペシャルイベント		即座かつ個別に処理されるイベント。
22.10 時間の経過や入力の待機		ユーザー入力または経過時間の待機。
22.11 quit		`C-g`’が機能する方法。quitをcatchまたは延期する方法。
22.12 プレフィクスコマンド引数		コマンドがプレフィクス引数が機能するようにセットするための方法。
22.13 再帰編集		再帰編集へのエンター、なぜ通常は再帰編集を行うべきでないのか。
22.14 コマンドの無効化		コマンドループが無効なコマンドを扱う方法。
22.15 コマンドのヒストリー		コマンドヒストリーがセットアップされる方法と、どのようにアクセスされるか。
22.16 キーボードマクロ		キーボードマクロが実装される方法。
Defining Commands
22.2.1 `interactive`の使用		`interactive`’にたいする一般的なルール。
22.2.2 `interactive`にたいするコード文字		さまざまな方法で引数を読み取る標準的な文字のコード。
22.2.3 `interactive`の使用例		インタラクティブ引数を読み取る方法の例。
22.2.4 コマンドにたいするモード指定		Specifying that commands are for a specific mode.
22.2.5 コマンド候補からの選択
Input Events
22.7.1 キーボードイベント		Ordinary characters – keys with symbols on them.
22.7.2 ファンクションキー		Function keys – keys with names, not symbols.
22.7.3 マウスイベント		マウスイベントの概観。
22.7.4 クリックイベント		マウスボタンのプッシュとリリース。
22.7.5 ドラッグイベント		ボタンをリリースする前のマウス移動。
22.7.6 ボタンダウンイベント		ボタンがプッシュされて、まだリリースされていない状態。
22.7.7 リピートイベント		ダブル、トリプルのクリック(またはドラッグ、ダウン)
22.7.8 モーションイベント		ボタンを押さずに、マウスだけを移動する。
22.7.10 フォーカスイベント		フレーム間のマウス移動。
22.7.12 その他のシステムイベント		システムが生成可能なその他のイベント。
22.7.13 イベントの例		マウスイベントの例。
22.7.14 イベントの分類		イベントシンボル内の修飾キーを見つける。イベント型。
22.7.15 マウスイベントへのアクセス		マウスイベントから情報抽出する関数。
22.7.16 スクロールバーイベントへのアクセス		スクロールバーイベントから情報取得する関数。
22.7.17 文字列内へのキーボードイベントの配置		文字列内にキーボード文字イベントを配すための特別な配慮。
Reading Input
22.8.1 キーシーケンス入力		キーシーケンスを読み取る方法。
22.8.2 単一イベントの読み取り		イベントを1つだけ読み取る方法。
22.8.3 入力イベントの変更と変換		Emacsが読み取られたイベントを変更する方法。
22.8.4 入力メソッドの呼び出し		入力メソッドを使用するイベントを読み取る方法。
22.8.5 クォートされた文字の入力		文字の指定をユーザーに問い合わせる。
22.8.6 その他のイベント入力の機能		入力イベントの最読み取りや破棄の方法。
Keymaps
23.1 キーシーケンス		Lispオブジェクトとしてのキーシーケンス。
23.2 キーマップの基礎		キーマップの基本概念。
23.3 キーマップのフォーマット		キーマップはLispオブジェクトとしてどのように見えるか。
23.4 キーマップの作成		キーマップを作成、コピーする関数。
23.5 継承とキーマップ		キーマップが他のキーマップのバインディングを継承する方法。
23.6 プレフィクスキー		キーマップの定義としてキーを定義する。
23.7 アクティブなキーマップ		Emacsがアクティブなキーマップでキーバインディングを探す方法。
23.8 アクティブなキーマップの検索		アクティブなマップ検索のLisp処理概要。
23.9 アクティブなキーマップの制御		各バッファーは標準(グローバル)のバインディングをオーバーライドするためのキーマップをもつ。マイナーモードもそれらをオーバーライドできる。
23.10 キーの照合		1つのキーマップから、あるキーのバインディングを探す。
23.11 キー照合のための関数		キールックアップを要求する方法。
23.12 キーバインディングの変更		キーマップ内でのキーの再定義。
23.13 低レベルなキーバインディング		Legacy key syntax description.
23.14 コマンドのリマップ		キーマップはあるコマンドを他のコマンドに変換できる。
23.15 イベントシーケンス変換のためのキーマップ		イベントシーケンスを変換するキーマップ。
23.16 キーのバインドのためのコマンド		キーの再定義にたいするインタラクティブなインターフェイス。
23.17 キーマップのスキャン		ヘルプをプリントするためにすべてのキーマップを走査する。
23.18 メニューキーアップ		キーマップとしてキーマップを定義する。
Menu Keymaps
23.18.1 メニューの定義		メニューを定義するキーマップを作成する方法。
23.18.2 メニューとマウス		ユーザーがマウスでメニューを操作する方法。
23.18.3 メニューとキーボード		ユーザーがキーボードでメニューを操作する方法。
23.18.4 メニューの例		シンプルなメニューの作成。
23.18.5 メニューバー		メニューバーのカスタマイズ方法。
23.18.6 ツールバー		イメージ行のツールバー。
23.18.7 メニューの変更		メニューへ新たなアイテムを追加する方法。
23.18.8 easy-menu		メニュー作成のための便利なマクロ。
Defining Menus
23.18.1.1 単純なメニューアイテム		単純なメニューのキーバインディング。
23.18.1.2 拡張メニューアイテム		複雑なメニューアイテムの定義。
23.18.1.3 メニューセパレーター		メニューに水平ラインを描画する。
23.18.1.4 メニューアイテムのエイリアス		メニューアイテムにコマンドエイリアスを使用する。
Major and Minor Modes
24.1 フック		フックの使い方と、フックを提供するコードの記述方法。
24.2 メジャーモード		メジャーモードの定義。
24.3 マイナーモード		マイナーモードの定義。
24.4 モードラインのフォーマット		モードラインに表示されるテキストのカスタマイズ。
24.5 Imenu		バッファーで作成された定義のメニューを提供する。
24.6 Font Lockモード		モードが構文に応じてテキストをハイライトする方法。
24.7 コードの自動インデント		メジャーモードにたいするインデントをEmacsに伝える方法。
24.8 Desktop Saveモード		Emacsセッション間でモードがバッファー状態を保存する方法。
Hooks
24.1.1 フックの実行		フックの実行方法。
24.1.2 フックのセット		関数をフックに登録、削除する方法。
Major Modes
24.2.1 メジャーモードの慣習		キーマップなどにたいするコーディング規約。
24.2.2 Emacsがメジャーモードを選択する方法		Emacsが自動的にメジャーモードを選択する方法。
24.2.3 メジャーモードでのヘルプ入手		モードの使用方法の探し方。
24.2.4 派生モードの定義		他のメジャーモードにもとづき新たなメジャーモードを定義する。
24.2.5 基本的なメジャーモード		他のモードからよく派生元とされるモード。
24.2.6 モードフック		メジャーモード関数の最後に実行されるフック。
24.2.7 Tabulated Listモード		表形式データを含むバッファーにたいする親モード。
24.2.8 ジェネリックモード		コメント構文とFont
24.2.9 メジャーモードの例		TextモードとLispモード。
Minor Modes
24.3.1 マイナーモード記述の規約		マイナーモードを記述するためのTips。
24.3.2 キーマップとマイナーモード		マイナーモードが自身のキーマップをもつための方法。
24.3.3 マイナーモードの定義		マイナーモードを定義するための便利な機能。
Mode Line Format
24.4.1 モードラインの基礎		モードライン制御の基本概念。
24.4.2 モードラインのデータ構造		モードラインを制御するデータ構造。
24.4.3 モードライン制御のトップレベル		トップレベル変数、mode-line-format。
24.4.4 モードラインで使用される変数		そのデータ構造で使用される変数。
24.4.5 モードラインでの`%`構文		モードラインへの情報の配置。
24.4.6 モードラインでのプロパティ		モードライン内でのテキストプロパティの使用。
24.4.7 ウィンドウのヘッダーライン		モードラインに類似した最上部のライン。
24.4.8 モードラインのフォーマットのエミュレート		モードラインのようにテキストをフォーマットする。
Font Lock Mode
24.6.1 Font Lockの基礎		Font Lockカスタマイズの概要。
24.6.2 検索ベースのフォント化		正規表現にもとづくフォント表示。
24.6.3 検索ベースのフォント化のカスタマイズ		検索ベースフォント表示のカスタマイズ。
24.6.4 Font Lockのその他の変数		追加のカスタマイズ機能。
24.6.5 Font Lockのレベル		多なりとも少ユーザーが選択できるように、それぞれのモードは代替レベルを定義できる。
24.6.6 事前計算されたフォント化		バッファーコンテンツを生成するLispプログラムが、どのようにしてそれをフォント表示する方法も指定できるか。
24.6.7 Font Lockのためのフェイス		Font Lockにたいする具体的な特殊フェイス。
24.6.8 構文的なFont Lock		構文テーブルにもとづくフォント表示。
24.6.9 複数行のFont Lock構造		Font Lockに複数行構成の正しいハイライトを強制する方法。
24.6.10 パーサーベースのFont Lock		Use parse data for fontification.
Multiline Font Lock Constructs
24.6.9.1 複数行のFont Lock		テキストプロパティで複数行塊をマークする。
24.6.9.2 バッファー変更後のリージョンのフォント化		バッファー変更後にどのリージョンを再フォント表示するかを制御する。
Automatic Indentation of code
24.7.1 SMIE: 無邪気なインデントエンジン		SMIE: Simple Minded Indentation Engine(純真なインデントエンジン)。
24.7.2 パーサーベースのインデント		Parser-based indentation engine.
Simple Minded Indentation Engine
24.7.1.1 SMIEのセットアップと機能
24.7.1.2 演算子順位文法		非常にシンプルなパース技術。
24.7.1.3 言語の文法の定義		言語の文法を定義する。
24.7.1.4 トークンの定義
24.7.1.5 非力なパーサーと歩む		パーサー制限の回避策。
24.7.1.6 インデントルールの指定
24.7.1.7 インデントルールにたいするヘルパー関数
24.7.1.8 インデントルールの例
24.7.1.9 インデントのカスタマイズ
Documentation
25.1 ドキュメントの基礎		ドキュメント文字列が定義、格納される場所。
25.2 ドキュメント文字列へのアクセス		Lispプログラムがドキュメント文字列にアクセスする方法。
25.3 ドキュメント内でのキーバインディングの置き換え		カレントキーバインディングの置き換え。
25.4 テキストのクォートスタイル		Quotation marks in doc strings and messages.
25.5 ヘルプメッセージの文字記述		非プリント文字やキーシーケンスをプリント可能な記述にする。
25.6 ヘルプ関数		Emacsヘルプ機能により使用されるサブルーチン。
Files
26.1 ファイルのvisit		編集のためにEmacsバッファーにファイルを読み込む。
26.2 バッファーの保存		変更されたバッファーをファイルに書き戻す。
26.3 ファイルからの読み込み		ファイルをvisitせずにバッファーに読み込む。
26.4 ファイルへの書き込み		バッファーの一部から新たなファイルに書き込む。
26.5 ファイルのロック		複数名による同時編集を防ぐためにファイルをlockまたはunlockする。
26.6 ファイルの情報		ファイルの存在、アクセス権、サイズのテスト。
26.7 ファイルの名前と属性の変更		ファイル名のリネームやパーミッションの変更など。
26.9 ファイルの名前		ファイル名の分解と展開。
26.10 ディレクトリーのコンテンツ		ディレクトリーないのファイルリストの取得。
26.11 ディレクトリーの作成・コピー・削除		ディレクトリーの作成と削除。
26.12 特定のファイル名の“Magic”の作成		特定のファイル名にたいする特別な処理。
26.13 ファイルのフォーマット変換		さまざまなファイルフォーマットへ/からの変換。
Visiting Files
26.1.1 ファイルをvisitする関数		visit用の通常のインターフェイス関数。
26.1.2 visitのためのサブルーチン		通常のvisit関数が使用する低レベルのサブルーチン。
Information about Files
26.6.1 アクセシビリティのテスト		そのファイルは読み取り可能か？書き込み可能か？
26.6.2 ファイル種別の区別		それはディレクトリー？それともシンボリックリンク？
26.6.3 本当の名前		シンボリックリンクが行き着くファイル名。
26.6.4 ファイルの属性		ファイルのサイズ？更新日時など。
26.6.5 拡張されたファイル属性		アクセス制御にたいするファイル属性の拡張。
26.6.6 標準的な場所へのファイルの配置		標準的な場所でファイルを見つける方法。
File Names
26.9.1 ファイル名の構成要素		ファイル名のディレクトリー部分と、それ以外。
26.9.2 絶対ファイル名と相対ファイル名		カレントディレクトリーにたいして相対的なファイル名。
26.9.3 ディレクトリーの名前		ディレクトリーとしてのディレクトリー名と、ファイルとしてのファイル名の違い。
26.9.4 ファイル名を展開する関数		相対ファイル名から絶対ファイル名への変換。
26.9.5 一意なファイル名の生成		一時ファイル用の名前の生成。
26.9.6 ファイル名の補完		与えられたファイル名にたいする補完を探す。
26.9.7 標準的なファイル名		パッケージが固定されたファイル名を使用する際に、種々のオペレーティングシステムをシンプルに処理する方法。
File Format Conversion
26.13.1 概要		`insert-file-contents`と`write-region`。
26.13.2 ラウンドトリップ仕様		`format-alist`の使用。
26.13.3 漸次仕様		非ペアー変換の指定。
Backups and Auto-Saving
27.1 ファイルのバックアップ		バックアップファイルの作成と名前選択の方法。
27.2 自動保存		auto-saveファイルの作成と名前選択の方法。
27.3 リバート		`revert-buffer`とその動作のカスタマイズ方法。
Backup Files
27.1.1 バックアップファイルの作成		Emacsがバックアップファイルを作成する方法とタイミング。
27.1.2 リネームかコピーのどちらでバックアップするか?		2つの選択肢: 古いファイルのリネームとコピー。
27.1.3 番号つきバックアップファイルの作成と削除		ソースファイルごとに複数のバックアップを保持する。
27.1.4 バックアップファイルの命名		バックアップファイル名の計算方法とカスタマイズ。
Buffers
28.1 バッファーの基礎		バッファーとは?
28.2 カレントバッファー		バッファーをカレントに指定することにより、プリミティブはバッファーのコンテンツにアクセスする。
28.3 バッファーの名前		バッファー名にたいするアクセスと変更。
28.4 バッファーのファイル名		バッファーファイル名は、どのファイルをvisitしているかを示す。
28.5 バッファーの変更		保存が必要なら、バッファーは“変更されている(modified)”。
28.6 バッファーの変更時刻		Determining whether the visited file was changed behind Emacs’s back.
28.7 読み取り専用のバッファー		読み取り専用バッファーでのテキスト変更は許されない。
28.8 バッファーリスト		すべての既存バッファーを閲覧する方法。
28.9 バッファーの作成		バッファーを作成する関数。
28.10 バッファーのkill		明示的にkillされるまで、バッファーは存在する。
28.11 インダイレクトバッファー		インダイレクトバッファーは、他のバッファーとテキストを共有する。
28.12 2つのバッファー間でのテキストの交換
28.13 バッファーのギャップ		バッファー内のギャップ。
Windows
29.1 Emacsウィンドウの基本概念		ウィンドウ使用についての基本情報。
29.2 ウィンドウとフレーム		ウィンドウとそれらが表示されるフレームとの関連。
29.3 ウィンドウの選択		選択されたウィンドウとは、編集を行っているウィンドウである。
29.4 ウィンドウのサイズ		ウィンドウのサイズへのアクセス。
29.5 ウィンドウのリサイズ		ウィンドウのサイズの変更。
29.6 ウィンドウサイズの保持		Preserving the size of windows.
29.7 ウィンドウの分割		新たなウィンドウの作成。
29.8 ウィンドウの削除		フレームからのウィンドウの削除。
29.9 ウィンドウの再結合		ウィンドウの分割や削除時のフレームレイアウトの保存。
29.10 ウィンドウのサイクル順		既存のウィンドウ間の移動。
29.11 バッファーとウィンドウ		それぞれのウィンドウは、バッファーのコンテンツを表示する。
29.12 ウィンドウ内のバッファーへの切り替え		バッファー切り替えのための、より高レベルな関数。
29.13 適切なウィンドウへのバッファーの表示		Displaying a buffer in a suitable window.
29.14 ウィンドウのヒストリー		それぞれのウィンドウは、表示されていたバッファーを記憶する。
29.15 専用のウィンドウ		特定のウィンドウ内で他のバッファーの表示を無効にする。
29.16 ウィンドウのquit		以前に表示していたバッファーの状態をリストアする方法。
29.17 サイドウィンドウ		Special windows on a frame’s sides.
29.18 アトミックウィンドウ		Preserving parts of the window layout.
29.19 ウィンドウとポイント		それぞれのウィンドウは、自身の位置とポイントをもつ。
29.20 ウィンドウの開始位置と終了位置		ウィンドウ内でスクリーン表示されるテキストを表すバッファー位置。
29.21 テキスト的なスクロール		ウィンドウを通じたテキストの上下移動。
29.22 割り合いによる垂直スクロール		ウィンドウ上のコンテンツの上下移動。
29.23 水平スクロール		ウィンドウ上のコンテンツの横移動。
29.24 座標とウィンドウ		座標からウィンドウへの変換。
29.25 マウスによるウィンドウの自動選択		Automatically selecting windows with the mouse.
29.26 ウィンドウの構成		スクリーンの情報の保存とリストア。
29.27 ウィンドウのパラメーター		ウィンドウへの追加情報の割り当て。
29.28 ウィンドウのスクロールと変更のためのフック		スクロール、ウィンドウのサイズ変更、ある特定のしきい値を超えたときに行われる再表示、ウィンドウ構成の変更にたいするフック。
Displaying Buffers
29.13.1 バッファーを表示するウィンドウの選択		バッファーを表示するウィンドウの選択方法。
29.13.2 バッファー表示用のアクション関数		Support functions for buffer display.
29.13.3 バッファー表示用のアクションalist		Alists for fine-tuning buffer display action functions.
29.13.4 バッファー表示の追加オプション		バッファー表示方法に影響する拡張オプション。
29.13.5 アクション関数の優先順		A tutorial explaining the precedence of buffer display action functions.
29.13.6 バッファー表示の思想		How to avoid that buffers get lost in between windows.
Side Windows
29.17.1 サイドウィンドウへのバッファーの表示		An action function for displaying buffers in side windows.
29.17.2 サイドウィンドウのオプションと関数		Further tuning of side windows.
29.17.3 サイドウィンドウによるフレームのレイアウト		Setting up frame layouts with side windows.
Frames
30.1 フレームの作成		追加のフレームの作成。
30.2 複数の端末		異なる複数デバイス上での表示。
30.3 フレームのジオメトリー		Geometric properties of frames.
30.4 フレームのパラメーター		フレームのサイズ、位置、フォント等の制御。
30.5 端末のパラメーター		端末上のすべてのフレームにたいして一般的なパラメーター。
30.6 フレームのタイトル		フレームタイトルの自動的な更新。
30.7 フレームの削除		明示的に削除されるまでフレームは存続する。
30.8 すべてのフレームを探す		すべての既存フレームを調べる方法。
30.9 ミニバッファーとフレーム		フレームが使用するミニバッファーを見つける方法。
30.10 入力のフォーカス		選択されたフレームの指定。
30.11 フレームの可視性		フレームは可視、不可視、またはアイコン化されているかもしれない。
30.12 フレームのraise、lower、re-stack		Raising, Lowering and Restacking Frames.
30.13 フレーム構成		すべてのフレームの状態の保存。
30.14 子フレーム		Making a frame the child of another.
30.15 マウスの追跡		マウス移動時のイベントの取得。
30.16 マウスの位置		マウスの場所や移動を問い合わせる。
30.17 ポップアップメニュー		ユーザーに選択させるためのメニューの表示。
30.18 ダイアログボックス		yes/noを問い合わせるためのボックスの表示。
30.19 ポインターの形状		マウスポインターのシェイプの指定。
30.20 ウィンドウシステムによる選択		他のXクライアントとのテキストの転送。
30.21 メディアのyank		Yanking things that aren’t plain text.
30.22 ドラッグアンドドロップ		ドラッグアンドドロップの実装の内部。
30.23 カラー名		カラー名定義の取得。
30.24 テキスト端末のカラー		テキスト端末のカラーの定義。
30.25 Xリソース		サーバーからのリソース値の取得。
30.26 ディスプレイ機能のテスト		端末の機能の判定。
Frame Geometry
30.3.1 フレームのレイアウト		Basic layout of frames.
30.3.2 フレームのフォント		The default font of a frame and how to set it.
30.3.3 フレームの位置		The position of a frame on its display.
30.3.4 フレームのサイズ		Specifying and retrieving a frame’s size.
30.3.5 フレームの暗黙的なリサイズ		Implied resizing of frames and how to prevent it.
Frame Parameters
30.4.1 フレームパラメーターへのアクセス		フレームのパラメーターの変更方法。
30.4.2 フレームの初期パラメーター		フレーム作成時に指定するフレームパラメーター。
30.4.3 ウィンドウフレームパラメーター		ウィンドウシステムにたいするフレームパラメーターのリスト。
30.4.4 ジオメトリー		ジオメトリー仕様の解析。
Window Frame Parameters
30.4.3.1 基本パラメーター		基本的なパラメーター。
30.4.3.2 位置のパラメーター		スクリーン上のフレームの位置。
30.4.3.3 サイズのパラメーター		フレームのサイズ。
30.4.3.4 レイアウトのパラメーター		フレームのパーツのサイズと、一部パーツの有効化と無効化。
30.4.3.5 バッファーのパラメーター		表示済みまたは表示されるべきバッファーはどれか。
30.4.3.6 フレームとの相互作用のためのパラメーター		Parameters for interacting with other frames.
30.4.3.7 マウスドラッグのパラメーター		Parameters for resizing and moving frames with the mouse.
30.4.3.8 ウィンドウ管理のパラメーター		ウィンドウマネージャーとの対話。
30.4.3.9 カーソルのパラメーター		カーソルの外見の制御。
30.4.3.10 フォントとカラーのパラメーター		フレームテキストにたいするフォントとカラー。
Positions
31.1 ポイント		編集タスクが行われる特別な位置。
31.2 モーション		ポイントの変更。
31.3 エクスカーション		一時的な移動とバッファーの変更。
31.4 ナローイング		バッファーの一部に編集を限定する。
Motion
31.2.1 文字単位の移動		文字単位での移動。
31.2.2 単語単位の移動		単語単位での移動。
31.2.3 バッファー終端への移動		バッファー先頭または終端への移動。
31.2.4 テキスト行単位の移動		テキスト行単位での移動。
31.2.5 スクリーン行単位の移動		表示される行単位での移動。
31.2.6 釣り合いのとれたカッコを越えた移動		リストやS式の解析による移動。
31.2.7 文字のスキップ		特定の集合に属す文字のスキップ。
Markers
32.1 マーカーの概要		マーカー構成要素と再配置方法。
32.2 マーカーのための述語		オブジェクトがマーカーか否かのテスト。
32.3 マーカーを作成する関数		空マーカーや特定箇所のマーカーの作成。
32.4 マーカーからの情報		マーカーのバッファーや文字位置を探す。
32.5 マーカーの挿入タイプ		マーカーが指す位置への挿入時にマーカーを再配置する2つの方法。
32.6 マーカー位置の移動		新たなバッファーや位置にマーカーを移動する。
32.7 マーク		How the mark is implemented with a marker.
32.8 リージョン		How to access the region.
Text
33.1 ポイント近傍のテキストを調べる		ポイント付近のテキストを調べる。
33.2 バッファーのコンテンツを調べる		一般的な方法によってテキストを調べる。
33.3 テキストの比較		バッファーの部分文字列を比較する。
33.4 テキストの挿入		バッファーへの新たなテキストの追加。
33.5 ユーザーレベルの挿入コマンド		テキスト挿入のためのユーザーレベルコマンド。
33.6 テキストの削除		バッファーからテキストを削除する。
33.7 ユーザーレベルの削除コマンド		テキスト削除のためのユーザーレベルコマンド。
33.8 killリング		テキスト削除時にユーザーのためにそれを保存する場所。
33.9 アンドゥ		バッファーのテキストにたいする変更の取り消し。
33.10 アンドゥリストの保守		undo情報の有効と無効。情報をどれだけ保持するか制御する方法。
33.11 fill		明示的にフィルを行う関数。
33.12 fillのマージン		フィルコマンドにたいしてマージンを指定する方法。
33.13 Adaptive Fillモード		コンテキストからフィルプレフィクスを選択するAdaptive
33.14 オートfill		行ブレークにたいするauto-fillの実装方法。
33.15 テキストのソート		バッファーの一部をソートする関数。
33.16 列を数える		水平位置の計算とその使用方法。
33.17 インデント		インデントの挿入や調整のための関数。
33.18 大文字小文字の変更		バッファーの一部にたいするcase変換。
33.19 テキストのプロパティ		テキスト文字にたいするLispプロパティリストの追加。
33.20 文字コードの置き換え		与ええられた文字の出現箇所を置換する。
33.21 レジスター		レジスターの実装方法。レジスターに格納されたテキストや位置にアクセスする。
33.22 テキストの交換		バッファーの2つの部分を交換する。
33.24 圧縮されたデータの処理		圧縮データの扱い。
33.25 Base 64エンコーディング		Base64エンコーディングとの変換。
33.26 チェックサムとハッシュ		暗号ハッシュの計算。
33.27 不審なテキスト		Determining whether a string is suspicious.
33.28 GnuTLS暗号化		Cryptographic algorithms imported from GnuTLS.
33.29 データベース		Interacting with an SQL database.
33.30 HTMLとXMLの解析		HTMLおよびXMLの解析。
33.33 グループのアトミックな変更		Installing several buffer changes atomically.
33.34 フックの変更		テキスト変更時に実行する関数の指定。
The Kill Ring
33.8.1 killリングの概念		killリング内のテキストがどのように見えるか。
33.8.2 kill用の関数		テキストをkillする関数。
33.8.3 yank		yankが行われる方法。
33.8.4 yank用の関数		killリングにアクセスするコマンド。
33.8.5 低レベルのkillリング		killリングアクセス用の関数および変数。
33.8.6 killリングの内部		killリングのデータを保持する変数。
Indentation
33.17.1 インデント用のプリミティブ		インデントのカウントと挿入に使用される関数。
33.17.2 メジャーモードが制御するインデント		異なるモード用にインデントをカスタマイズする。
33.17.3 リージョン全体のインデント		リージョン内すべての行のインデント。
33.17.4 前行に相対的なインデント		前の行にもとづきカレント行をインデントする。
33.17.5 調整可能なタブストップ		調整可能なタイプライター形式のタブストップ。
33.17.6 インデントにもとづくモーションコマンド		最初の非ブランク文字への移動。
Text Properties
33.19.1 テキストプロパティを調べる		単一の文字のプロパティを調べる。
33.19.2 テキストプロパティの変更		テキスト範囲のプロパティをセットする。
33.19.3 テキストプロパティの検索関数		プロパティが値を変更する場所の検索。
33.19.4 特殊な意味をもつプロパティ		特別な意味をもつ特定のプロパティ。
33.19.5 フォーマットされたテキストのプロパティ		テキストのフォーマットを表すプロパティ。
33.19.6 テキストプロパティの粘着性		挿入されたテキストが隣接するテキストからプロパティを取得する方法。
33.19.7 テキストプロパティのlazyな計算		テキストが調べられる際のみ、ものぐさな方法でテキストプロパティを計算する。
33.19.8 クリック可能なテキストの定義		テキストプロパティを使用して、テキストリージョンがクリック時に何か行うようにする。
33.19.9 フィールドの定義と使用		バッファー内にフィールドを定義する`field`プロパティ。
33.19.10 なぜテキストプロパティはインターバルではないのか		テキストプロパティがLispから可視なテキスト間隔をもたない理由。
Parsing HTML and XML
33.30.1 ドキュメントオブジェクトモデル		Access, manipulate and search the DOM.
Non-ASCII Characters
34.1 テキストの表現方法		Emacsがテキストを表す方法。
34.2 マルチバイト文字の無効化		マルチバイト使用を制御する。
34.3 テキスト表現の変換		ユニバイトとマルチバイトの相互変換。
34.4 表現の選択		バイトシーケンスをユニバイトやマルチバイトとして扱う。
34.5 文字コード		ユニバイトやマルチバイトが個々の文字のコードと関わる方法。
34.6 文字のプロパティ		文字の挙動と処理を定義する文字属性。
34.7 文字セット		利用可能な文字コード空間はさまざまな文字セットに分割される。
34.8 文字セットのスキャン		バッファーで使用されている文字セットは?
34.9 文字の変換		変換に使用される変換テーブル。
34.10 コーディングシステム		コーディングシステムはファイル保存のための変換である。
34.11 入力メソッド		入力メソッドによりユーザーは特別なキーボードなしで非ASCII文字を入力できる。
34.12 locale		POSIX localeとの対話。
Coding Systems
34.10.1 コーディングシステムの基本概念		基本的な概念。
34.10.2 エンコーディングとI/O		ファイル入出力関数がコーディングシステムを扱う方法。
34.10.3 Lispでのコーディングシステム		コーディングシステム名を処理する関数。
34.10.4 ユーザーが選択したコーディングシステム		ユーザーにコーディングシステムの選択を求める。
34.10.5 デフォルトのコーディングシステム		デフォルトの選択の制御。
34.10.6 単一の操作にたいするコーディングシステムの指定		単一ファイル処理にたいして特定のコーディングシステムを要求する。
34.10.7 明示的なエンコードとデコード		入出力を伴わないテキストのエンコードおよびデコード。
34.10.8 端末I/Oのエンコーディング		端末入出力にたいするエンコーディングの使用。
Searching and Matching
35.1 文字列の検索		正確なマッチの検索。
35.2 検索と大文字小文字		case-independentまたはcase-significantな検索。
35.3 正規表現		文字列クラスの記述。
35.4 正規表現の検索		regexpにたいするマッチの検索。
35.5 POSIX正規表現の検索		最長マッチにたいするPOSIXスタイルのマッチ。
35.6 マッチデータ		文字列またはregexp検索後に、テキストがマッチした部分を見つける。
35.7 検索と置換		検索と置換を繰り返すコマンド。
35.8 編集で使用される標準的な正規表現		センテンスやページ等を探すために有用なregexp。
Regular Expressions
35.3.1 正規表現の構文		正規表現の記述ルール。
35.3.2 正規表現の複雑な例		正規表現構文の説明。
35.3.3 `rx`構造化Rgexp表記		An alternative, structured regexp notation.
35.3.4 正規表現の関数		正規表現を操作する関数。
35.3.5 正規表現にまつわるトラブル		Some problems and how they may be avoided.
Syntax of Regular Expressions
35.3.1.1 正規表現内の特殊文字		正規表現内のスペシャル文字。
35.3.1.2 文字クラス		正規表現内で使用される文字クラス。
35.3.1.3 正規表現内のバッククラッシュ構文		正規表現内のバックスラッシュシーケンス。
The Match Data
35.6.1 マッチしたテキストの置換		マッチされた部分文字列の置換。
35.6.2 単純なマッチデータへのアクセス		特定の部分式開始箇所のような、マッチデータの単一アイテムへのアクセス。
35.6.3 マッチデータ全体へのアクセス		リストとしてマッチデータ全体に一度にアクセスする。
35.6.4 マッチデータの保存とリストア
Syntax Tables
36.1 構文テーブルの概念		構文テーブルの基本的概念。
36.2 構文記述子		文字がクラス分けされる方法。
36.3 構文テーブルの関数		構文テーブルを作成、調査、変更する方法。
36.4 構文プロパティ		テキストプロパティによる構文テーブルのオーバーライド。
36.5 モーションと構文		特定の構文による文字間の移動。
36.6 式のパース		構文テーブル使用による釣り合いのとれた式の解析。
36.7 構文テーブルの内部		構文テーブルの情報が格納される方法。
36.8 カテゴリー		文字構文をクラス分けする別の手段。
Parsing Program Source
37.1 tree-sitterの言語グラマー		Loading tree-sitter language grammar.
37.2 tree-sitterパーサーの使用		Introduction to parsers.
37.3 ノードの取得		Retrieving nodes from a syntax tree.
37.4 ノード情報へのアクセス		Accessing node information.
37.5 tree-sitterノードにたいするパターンマッチング		Pattern matching with query patterns.
37.6 複数言語ののパース		Parse text written in multiple languages.
37.7 tree-sitterを用いるメジャーモードの開発		Develop major modes using tree-sitter.
37.8 tree-sitterのC APIとの対応表		Compare the C API and the ELisp API.
Syntax Descriptors
36.2.1 構文クラスのテーブル
36.2.2 構文フラグ		各文字が所有できる追加のフラグ。
Parsing Expressions
36.6.1 パースにもとづくモーションコマンド		パースにより機能する移動関数。
36.6.2 ある位置のパース状態を調べる		ある位置の構文状態を判断する。
36.6.3 パーサー状態		Emacsが構文状態を表す方法。
36.6.4 低レベルのパース		指定されたリージョンを横断するパース。
36.6.5 パースを制御するためのパラメーター		パースに影響するパラメーター。
Abbrevs and Abbrev Expansion
38.1 abbrevテーブル		abbrevテーブルの作成と操作。
38.2 abbrevの定義		略語の指定とそれらの展開。
38.3 ファイルへのabbrevの保存
38.4 略語の照会と展開		展開の制御と展開サブルーチン。
38.5 標準abbrevテーブル		種々メジャーモードに使用されるabbrevテーブル。
38.6 abbrevプロパティ		abbrevプロパティの読み取りとセットを行う方法。どのプロパティが何の効果をもつか。
38.7 abbrevテーブルのプロパティ		abbrevテーブルプロパティの読み取りとセットを行う方法。どのプロパティが効果をもつか。
Threads
39.1 基本的なスレッド関数		Basic thread functions.
39.2 ミューテックス		Mutexes allow exclusive access to data.
39.3 条件変数		Inter-thread events.
39.4 スレッドリスト		Show the active threads.
Processes
40.1 サブプロセスを作成する関数		サブプロセスを開始する関数。
40.2 shell引数		shellに渡すために引数をクォートする。
40.3 同期プロセスの作成		同期サブプロセス使用の詳細。
40.4 非同期プロセスの作成		非同期サブプロセスの起動。
40.5 プロセスの削除		非同期サブプロセスの削除。
40.6 プロセスの情報		実行状態および他の属性へのアクセス。
40.7 プロセスへの入力の送信		非同期サブプロセスへの入力の送信。
40.8 プロセスへのシグナルの送信		非同期サブプロセスの停止、継続、割り込み。
40.9 プロセスからの出力の受信		非同期サブプロセスからの出力の収集。
40.10 センチネル: プロセス状態の変更の検知		プロセスの実行状態変更時に実行されるセンチネル。
40.11 exit前の問い合わせ		exitによりプロセスがkillされる場合に問い合わせるかどうか。
40.12 別のプロセスへのアクセス		そのシステム上で実行中の別プロセスへのアクセス。
40.13 トランザクションキュー		サブプロセスとのトランザクションベースのコミュニケション。
40.14 ネットワーク接続		ネットワーク接続のopen。
40.15 ネットワークサーバー		Emacsによるネット接続のacceptを可能にするネットワークサーバー。
40.16 データグラム		UDPネットワーク接続。
40.17 低レベルのネットワークアクセス		接続およびサーバーを作成するための、より低レベルだがより汎用的な関数。
40.18 その他のネットワーク機能		ネット接続用の追加の関連関数。
40.19 シリアルポートとの対話		シリアルポートでのやり取り。
40.20 バイト配列のpackとunpack		bindatを使用したバイナリーデータのpackとunpack。
Receiving Output from Processes
40.9.1 プロセスのバッファー		デフォルトでは、出力はバッファーに送信される。
40.9.2 プロセスのフィルター関数		フィルター関数はプロセスからの出力を受け取る。
40.9.3 プロセス出力のデコード		フィルターはユニバイトおよびマルチバイトの文字列を取得できる。
40.9.4 プロセスの出力を受け取る		プロセスの出力到着まで待機する方法。
Low-Level Network Access
40.17.1 `make-network-process`		`make-network-process`’の使用。
40.17.2 ネットワークのオプション		更なるネットワーク接続の制御。
40.17.3 ネットワーク機能の可用性のテスト		使用中マシン上で動作するネットワーク機能を判断する。
Packing and Unpacking Byte Arrays
40.20.1 データレイアウトの記述
40.20.2 バイトのunpackとpackを行う関数		unpack化とpack化を行う。
40.20.3 高度なデータレイアウト仕様		Advanced data layout specifications.
Emacs Display
41.1 スクリーンのリフレッシュ		スクリーン上にあるすべてのもののクリアーと再描画。
41.2 強制的な再表示		再描画の強制。
41.3 切り詰め		長いテキストの折り畳みと折り返し。
41.4 エコーエリア		スクリーン最下部へのメッセージ表示。
41.5 警告のレポート		ユーザーへの警告メッセージの表示。
41.6 不可視のテキスト		バッファーのテキストの一部を隠す。
41.7 選択的な表示		バッファーのテキストの一部を隠す(旧来の方式)。
41.8 一時的な表示		自動的に消える表示。
41.9 オーバーレイ		オーバーレイを使用したバッファーの一部のハイライト。
41.10 表示されるテキストのサイズ		表示されたテキストの大きさ。
41.11 行の高さ		行の高さの制御。
41.12 フェイス		テキスト文字のグラフィカルスタイル(フォント、カラー等)を定義するフェイス。
41.13 フリンジ		ウィンドウフリンジの制御。
41.14 スクロールバー		Controlling scroll bars.
41.15 ウィンドウディバイダー		ウィンドウを視覚的に区別する。
41.16 `display`プロパティ		特別な表示機能の有効化。
41.17 イメージ		Emacsバッファー内でのイメージ表示。
41.20 ボタン		Emacsバッファー内へのイメージ表示クリック可能ボタン追加。
41.21 抽象的なディスプレイ		オブジェクトコレクション用のEmacsウィジェット。
41.22 カッコの点滅		Emacsがマッチする開カッコを表示する方法。
41.23 文字の表示		Emacsがマッチする個々の文字を表示する方法。
41.24 ビープ		ユーザーへの可聴シグナル。
41.25 ウィンドウシステム		どのウィンドウシステムが使用されているか。
41.26 ツールチップ		Tooltip display in Emacs.
41.27 双方向テキストの表示		アラビア語やペルシア語のような、双方向スクリプトの表示。
The Echo Area
41.4.1 エコーエリアへのメッセージの表示		エコーエリア内に明示的にテキストを表示する。
41.4.2 処理の進捗レポート		長時間の処理の進行状況をユーザーに知らせる。
41.4.3 `Messages`へのメッセージのロギング		ユーザー用にログされるエコーエリアメッセージ。
41.4.4 エコーエリアのカスタマイズ		エコーエリアの制御。
Reporting Warnings
41.5.1 警告の基礎		警告の概念と、それらを報告するための関数。
41.5.2 警告のための変数		プログラムが警告をカスタマイズするためにバインドする変数。
41.5.3 警告のためのオプション		ユーザーが警告の表示を制御するためにセットする変数。
41.5.4 遅延された警告		コマンド終了まで警告を延期する。
Overlays
41.9.1 オーバーレイの管理		オーバーレイの作成と変更。
41.9.2 オーバーレイのプロパティ		プロパティ読み取りおよびセットの方法。どのプロパティがスクリーン表示に何を行うか。
41.9.3 オーバーレイにたいする検索
Faces
41.12.1 フェイスの属性		フェイスとは?
41.12.2 フェイスの定義		フェイスを定義する方法。
41.12.3 フェイス属性のための関数		フェイス属性の確認およびセットを行う関数。
41.12.4 フェイスの表示		ある文字にたいして指定されたフェイスをEmacsが組み合わせる方法。
41.12.5 フェイスのリマップ		フェイスを別の定義にリマップする。
41.12.6 フェイスを処理するための関数		フェイスの定義、および確認する方法。
41.12.7 フェイスの自動割り当て		自動的にフェイスを割り当てるフック。
41.12.8 基本的なフェイス		デフォルトで定義されるフェイス。
41.12.9 フォントの選択		あるフェイスに最適なフォントを見つける。
41.12.10 フォントの照会		利用可能なフォント名とそれらの情報の照会。
41.12.11 フォントセット		フォントセット、それは文字セットの範囲を処理するフォントコレクションである。
41.12.12 低レベルのフォント表現		文字表示フォントのLisp表現。
Fringes
41.13.1 フリンジのサイズと位置		ウィンドウフリンジを置く場所を指定する。
41.13.2 フリンジのインジケーター		ウィンドウフリンジ内にインジケーターアイコンを表示する。
41.13.3 フリンジのカーソルFrin		右フリンジ内にカーソルを表示する。
41.13.4 フリンジのビットマップ		フリンジインジケーターにたいしてビットマップを指定する。
41.13.5 フリンジビットマップのカスタマイズ		フリンジ内で使用する独自ビットマップの指定。
41.13.6 オーバーレイ矢印		位置を示す矢印の表示。
The `display` Property
41.16.1 テキストを置換するディスプレイ仕様		テキストを置換するディスプレイspec。
41.16.2 スペースの指定		指定された幅に1つのスペースを表示する。
41.16.3 スペースにたいするピクセル指定		ピクセル単位でスペースの幅または高さを指定する。
41.16.4 その他のディスプレイ仕様		イメージの表示。高さ、スペーシング、その他のテキストプロパティの調整。
41.16.5 マージン内への表示		メインテキスト側面へのテキストまたはイメージの表示。
Images
41.17.1 イメージのフォーマット		サポートされるイメージフォーマット。
41.17.2 イメージのディスクリプタ		`:display`内で使用されるイメージの指定方法。
41.17.3 XBMイメージ		XBMフォーマット用の特別な機能。
41.17.4 XPMイメージ		XPMフォーマット用の特別な機能。
41.17.5 ImageMagickイメージ		ImageMagickを通じて利用できる特別な機能。
41.17.7 その他のイメージタイプ		サポートされるその他さまざまなフォーマット。
41.17.8 イメージの定義		後で使用するためにイメージを定義する便利な方法。
41.17.9 イメージの表示		一度定義されたイメージを表示するための便利な方法。
41.17.10 マルチフレームのイメージ		1つ以上のフレームを含むイメージ。
41.17.11 イメージキャッシュ		イメージ表示の内部的メカニズム。
Buttons
41.20.1 ボタンのプロパティ		特別な意味をもつボタンプロパティ。
41.20.2 ボタンのタイプ		ボタンのクラスにたいして一般的なプロパティを定義する。
41.20.3 ボタンの作成		Emacsバッファーへのボタンの追加。
41.20.4 ボタンの操作		ボタンプロパティの取得とセット。
41.20.5 ボタンのためのバッファーコマンド		ボタンにたいするバッファー規模のコマンドとバインディング。
Abstract Display
41.21.1 抽象ディスプレイの関数		Ewocパッケージ内の関数。
41.21.2 抽象ディスプレイの例		Ewocの使用例。
Character Display
41.23.1 通常の表示の慣習		文字の表示にたいする通常の慣習。
41.23.2 ディスプレイテーブル		ディスプレイテーブルの構成要素。
41.23.3 アクティブなディスプレイテーブル		使用するディスプレイテーブルをEmacsが選択する方法。
41.23.4 グリフ		グリフの定義方法とグリフの意味。
41.23.5 グリフなし文字の表示		グリフなしの文字の描画方法。
Operating System Interface
42.1 Emacsのスタートアップ		Customizing Emacs startup processing.
42.2 Emacsからの脱出		(永久または一時的に)exitが機能する方法。
42.3 オペレーティングシステムの環境		システム名と種類の区別。
42.4 ユーザーの識別		そのユーザーの名前とユーザーIDを調べる。
42.5 時刻		カレント時刻の取得。
42.7 時刻の変換		Converting among timestamp forms.
42.8 時刻のパースとフォーマット		Converting timestamps to text and vice versa.
42.9 プロセッサーの実行時間		Emacsによる実行時間の取得。
42.10 時間の計算		時間の加減算、その他。
42.11 遅延実行のためのタイマー		特定時刻に関数を呼び出すためにターマーをセットする。
42.12 アイドルタイマー		Emacsが特定の時間の間アイドル時に関数を呼び出すためにタイマーをセットする。
42.13 端末の入力		端末入力へのアクセスと記録。
42.14 端末の出力		端末出力の制御と記録。
42.15 サウンドの出力		コンピューターのスピーカーでのサウンド再生。
42.16 X11キーシンボルの処理		Xウィンドウにたいするキーシンボルの操作。
42.17 batchモード		端末との対話なしでEmacsを実行する。
42.18 セッションマネージャー		Xセッション管理の保存とリストア。
42.19 デスクトップ通知
42.20 ファイル変更による通知		ファイル通知。
42.21 動的にロードされるライブラリー		サポートライブラリーのオンデマンドロード。
42.22 セキュリティへの配慮		Running Emacs in an unfriendly environment.
Emacsのスタートアップ
42.1.1 要約: スタートアップ時のアクション順序		スタートアップ時にEmacsが行うアクションの順序。
42.1.2 initファイル		initファイル読み込みの詳細。
42.1.3 端末固有の初期化		端末固有のLispファイルの読み込み方法。
42.1.4 コマンドライン引数		コマンドライン引数の処理とカスタマイズの方法。
Getting Out of Emacs
42.2.1 Emacsのkill		Emacsからの不可逆的なexit。
42.2.2 Emacsのサスペンド		Emacsからの可逆的なexit。
Terminal Input
42.13.1 入力のモード		入力の処理方法にたいするオプション。
42.13.2 入力の記録		直近またはすべての入力イベントのヒストリーの保存。
Preparing Lisp code for distribution
43.1 パッケージ化の基礎		Emacs Lispパッケージの基本的概念。
43.2 単純なパッケージ		単一.elファイルをパッケージする方法。
43.3 複数ファイルのパッケージ		複数ファイルをパッケージする方法。
43.4 パッケージアーカイブの作成と保守		パッケージアーカイブの保守。
Tips and Conventions
D.1 Emacs Lispコーディング規約		明快で堅牢なプログラムにたいする慣習。
D.2 キーバインディング規約		どのキーをどのプログラムにバインドすべきか。
D.3 Emacsプログラミングのヒント		Emacsコードを円滑にEmacsに適合させる。
D.4 コンパイル済みコードを高速化ためのヒント		コンパイル済みコードの実行を高速にする。
D.5 コンパイラー警告を回避するためのヒント		コンパイラー警告をオフにする。
D.6 ドキュメント文字列のヒント		読みやすいドキュメント文字列の記述。
D.7 コメント記述のヒント		コメント記述の慣習。
D.8 Emacsライブラリーのヘッダーの慣習		ライブラリーパッケージにたいする標準的なヘッダー。
GNU Emacs Internals
E.1 Emacsのビルド		ダンプ済みEmacsの作成方法。
E.2 純粋ストレージ		その場かぎりの事前ロードされたLisp関数を共有する。
E.3 ガーベージコレクション		Lispオブジェクトの使用されないスペースの回収。
E.4 スタックに割り当てられたオブジェクト		Temporary conses and strings on C stack.
E.5 メモリー使用量		これまでに作成されたLispオブジェクトの総サイズの情報。
E.6 C方言		What C variant Emacs is written in.
E.7 Emacsプリミティブの記述		Emacs用にCコードを記述する。
E.8 動的にロードされるモジュールの記述		Writing loadable modules for Emacs.
E.9 オブジェクトの内部		バッファー、ウィンドウ、プロセスのデーラフォーマット。
E.10 Cの整数型		How C integer types are used inside Emacs.
Writing Dynamic Modules
E.8.1 モジュールの初期化コード
E.8.2 モジュール関数の記述
E.8.3 Lisp・モジュール間の値変換
E.8.4 その他の便利なモジュール用関数
E.8.5 モジュールでの非ローカル脱出
Object Internals
E.9.1 バッファーの内部		バッファー構造体の構成子。
E.9.2 ウィンドウの内部		ウィンドウ構造体の構成子。
E.9.3 プロセスの内部		プロセス構造体の構成子。

1 イントロダクション

GNU Emacsテキストエディターのほとんどの部分は、Emacs Lispと呼ばれるプログラミング言語で記述されています。新しいコードをEmacs Lispで記述して、このエディターの拡張としてインストールできます。しかしEmacs Lispは、単なる拡張言語を越える言語であり、それ自体で完全なコンピュータープログラミング言語です。他のプログラミング言語で行なうすべてのことに、この言語を使用できます。

Emacs Lispはエディターの中で使用するようにデザインされているので、テキストのスキャンやパースのための特別な機能をもち、同様にファイル、バッファー、ディスプレイ、サブプロセスを処理する機能をもちます。Emacs Lispは編集機能と密に統合されています。つまり編集コマンドはLispプログラムから簡単に呼び出せる関数で、カスタマイズのためのパラメーターは普通のLisp変数です。

このマニュアルはEmacs Lispの完全な記述を試みます。初心者のためのEmacs Lispのイントロダクションは、Free Software Foundationからも出版されている、Bob ChassellのAn Introduction to Emacs Lisp Programmingを参照してください。このマニュアルは、Emacsを使用した編集に熟知していることを前提としています。これの基本的な情報については、The GNU Emacs Manualを参照してください。

おおまかに言うと、前の方のチャプターでは多くのプログラミング言語の機能にたいして、Emacs Lispでの対応する機能を説明し、後の方のチャプターではEmacs Lispに特異な機能や、編集に特化した関連する機能を説明します。

これは Emacs 29.3に対応したGNU Emacs Lisp Reference Manualです。

1.1 注意事項

このマニュアルは幾多のドラフトを経てきました。ほとんど完璧ではありますが、不備がないとも言えません。(ほとんどの特定のモードのように)それらが副次的であるとか、まだ記述されていないという理由により、カバーされていないトピックもあります。わたしたちがそれらを完璧に扱うことはできないので、いくつかの部分は意図的に省略しました。

このマニュアルは、それがカバーしている事柄については完全に正しくあるべきあり、故に特定の説明テキスト、チャプターやセクションの順番にたいしての批判にオープンであるべきです。判りにくかったり、このマニュアルでカバーされていない何かを学ぶためにソースを見たり実地から学ぶ必要があるなら、このマニュアルはおそらく訂正されるべきなのかもしれません。どうかわたしたちにそれを教えてください。

このマニュアルを使用するときは、間違いを見つけたらすぐに訂正を送ってください。関数または関数グループの単純な現実例を考えたときは、ぜひそれを記述して送ってください。それが妥当ならコメントでノード名と関数名や変数名を参照してください。あなたが訂正を求めるエディションのバージョンも示してください。

コメントや訂正の送信には、M-x report-emacs-bugを使用するようお願いします。詳細については、 Reporting Bugs in The GNU Emacs Manualを参照してください。

1.2 Lispの歴史

Lisp(LISt Processing language: リスト処理言語)は、MIT(Massachusetts Institute of Technology: マサチューセッツ工科大学)で、AI(artificial intelligence: 人工知能)の研究のために、1950年代末に最初に開発されました。Lisp言語の強力なパワーは、編集コマンドの記述のような、他の目的にも適っています。

長年の間に何ダースものLisp実装が構築されてきて、それらのそれぞれに特異な点があります。これらの多くは、1960年代にMITのProject MACで記述された、Maclispに影響を受けています。最終的に、Maclisp後裔の実装者は共同して、Common Lispと呼ばれる標準のLispシステムを開発しました。その間にMITのGerry SussmanとGuy Steeleにより、簡潔ながらとても強力なLisp方言の、Schemeが開発されました。

GNU Emacs LispはMaclispから多く、Common Lispから少し影響を受けています。Common Lispを知っている場合、多くの類似点に気づくでしょう。しかしCommon Lispの多くの機能は、GNU Emacsが要求するメモリー量を削減するために、省略または単純化されています。ときには劇的に単純化されているために、Common Lispユーザーは混乱するかもしれません。わたしたちは時折GNU Emacs LispがCommon Lispと異なるか示すでしょう。Common Lispを知らない場合、それについて心配する必要はありません。このマニュアルは、それ自体で自己完結しています。

cl-libライブラリーを通じて、Common Lispをかなりエミュレートできます。Overview in Common Lisp Extensionsを参照してください。

Emacs LispはSchemeの影響は受けていません。しかしGNUプロジェクトにはGuileと呼ばれるScheme実装があります。拡張が必要な新しいGNUソフトウェアーでは、Guileを使用します。

1.3 Lispの歴史

このセクションでは、このマニュアルで使用する表記規約を説明します。あなたはこのセクションをスキップして、後から参照したいと思うかもしれません。

1.3.1 Lispの歴史		このマニュアルで使用する用語の説明。
1.3.2 `nil`と`t`		シンボル`nil`と`t`の使用方法。
1.3.3 評価の表記		評価の例で使用するフォーマット。
1.3.4 プリントの表記		テキストのプリント例で使用するフォーマット。
1.3.5 エラーメッセージ		エラー例で使用するフォーマット。
1.3.6 バッファーテキストの表記		例のバッファー内容で使用するフォーマット。
1.3.7 説明のフォーマット		関数や変数などの説明にたいする表記。

1.3.1 Lispの歴史

このマニュアルでは、“Lispリーダー”および“Lispプリンター”という用語で、Lispのテキスト表現を実際のLispオブジェクトに変換したり、その逆を行なうLispルーチンを参照します。詳細については、プリント表現と読み取り構文を参照してください。あなた、つまりこのマニュアルを読んでいる人のことはプログラマーと考えて“あなた”と呼びます。“ユーザー”とは、あなたの記述したものも含めて、Lispプログラムを使用する人を指します。

Lispコードの例は、(list 1 2 3)のようなフォーマットです。メタ構文変数(metasyntactic variables)を表す名前や、説明されている関数の引数名前は、first-numberのようにフォーマットされています。

1.3.2 `nil`と`t`

Emacs Lispでは、シンボルnilには3つの異なる意味があります。1つ目は‘nil’という名前のシンボル、2つ目は論理値のfalse、3つ目は空リスト — つまり要素が0のリストです。変数として使用した場合、nilは常に値nilをもちます。

Lispリーダーに関する限り、‘()’と‘nil’は同一です。これらは同じオブジェクト、つまりシンボルnilを意味します。このシンボルを異なる方法で記述するのは、完全に人間の読み手を意図したものです。Lispリーダーが‘()’か‘nil’のどちらかを読み取った後は、プログラマーが実際にどちらの表現で記述したかを判断する方法はありません。

このマニュアルでは、空リストを意味することを強調したいときは()と記述し、論理値のfalseを意味することを強調したいときはnilと記述します。この慣習はLispプログラムで使用してもよいでしょう。

(cons 'foo ())                ; 空リストを強調
(setq foo-flag nil)           ; 論理値のfalseを強調

論理値が期待されているコンテキストでは、非nilはtrueと判断されます。しかし論理値のtrueを表す好ましい方法はtです。trueを表す値を選択する必要があり、他に選択の根拠がない場合はtを使用してください。シンボルtは、常に値tをもちます。

Emacs Lispでのnilとtは、常に自分自身を評価する特別なシンボルです。そのためプログラムでこれらを定数として使用する場合、クォートする必要はありません。これらの値の変更を試みると、結果はsetting-constantエラーとなります。変更不可な変数を参照してください。

Function: booleanp object ¶: objectが2つの正規のブーリーン値(tかnil)のいずれかなら、非nilをリターンする。

1.3.3 評価の表記

評価できるLisp式のことをフォーム(form)と呼びます。フォームの評価により、これは結果として常にLispオブジェクトを生成します。このマニュアルの例では、これを‘⇒’で表します:

(car '(1 2))
     ⇒ 1

これは“(car '(1 2))を評価すると、1になる”と読むことができます。

フォームがマクロ呼び出しの場合、それは評価されるための新たなLispフォームに展開されます。展開された結果は‘→’で表します。わたしたちは展開されたフォームの評価し結果を示すこともあれば、示さない場合もあります。

(third '(a b c))
     → (car (cdr (cdr '(a b c))))
     ⇒ c

1つのフォームを説明するために、同じ結果を生成する別のフォームを示すこともあります。完全に等価な2つのフォームは、‘≡’で表します。

(make-sparse-keymap) ≡ (list 'keymap)

1.3.4 プリントの表記

このマニュアルの例の多くは、それらが評価されるときにテキストをプリントします。(*scratch*バッファーのような)Lisp Interactionバッファーで閉カッコの後でC-jをタイプすることによりコード例を実行する場合には、プリントされるテキストはそのバッファーに挿入されます。(関数eval-regionでの評価のように)他の方法でコード例を実行する場合、プリントされるテキストはエコーエリアに表示されます。

このマニュアルの例はプリントされるテキストがどこに出力されるかに関わらず、それを‘-|’で表します。フォームを評価することにより戻される値は、‘⇒’とともに後続の行で示します。

(progn (prin1 'foo) (princ "\n") (prin1 'bar))
     -| foo
     -| bar
     ⇒ bar

1.3.5 エラーメッセージ

エラーをシグナルする例もあります。これは通常、エコーエリアにエラーメッセージを表示します。エラーメッセージの行は‘error→’で始まります。‘error→’自体は、エコーエリアに表示されないことに注意してください。

(+ 23 'x)
error→ Wrong type argument: number-or-marker-p, x

1.3.6 バッファーテキストの表記

バッファー内容の変更を説明する例もあます。それらの例では、そのテキストのbefore(以前)とafter(以後)のバージョンを示します。それらの例では、バッファー内容の該当する部分を、ダッシュを用いた2行の破線(バッファー名を含む)で示します。さらに、‘∗’はポイントの位置を表します(もちろんポイントのシンボルはバッファーのテキストの一部ではなく、ポイントが現在配されている2つの文字の間の位置を表す)。

---------- Buffer: foo ----------
This is the ∗contents of foo.
---------- Buffer: foo ----------

(insert "changed ")
     ⇒ nil
---------- Buffer: foo ----------
This is the changed ∗contents of foo.
---------- Buffer: foo ----------

1.3.7 説明のフォーマット

このマニュアルでは関数(function)、変数(variable)、コマンド(command)、ユーザーオプション(user option)、スペシャルフォーム(special form)を、統一されたフォーマットで記述します。記述の最初の行には、そのアイテムの名前と、もしあれば引数(argument)が続きます。そのアイテムの属するカテゴリー(function、variableなど)は、行の先頭に表示します。それ以降の行は説明行で、例を含む場合もあります。

1.3.7.1 関数の説明例

関数の記述では、関数の名前が最初に記述されます。同じ行に引数の名前のリストが続きます。引数の値を参照するために、引数の名前は記述の本文にも使用されます。

引数リストの中にキーワード&optionalがある場合、その後の引数が省略可能であることを示します(省略された引数のデフォルトはnil)。その関数を呼び出すときは、&optionalを記述しないでください。

キーワード&rest(これの後には1つの引数名を続けなければならない)は、その後に任意の引数を続けることができることを表します。&restの後に記述された引数名の値には、その関数に渡された残りのすべての引数がリストとしてセットされます。この関数を呼び出すときは、&restを記述しないでください。

以下はfooという架空の関数(function)の説明です:

Function: foo integer1 &optional integer2 &rest integers ¶

関数fooはinteger2からinteger1を減じてから、その結果に残りすべての引数を加える。integer2が与えられなかった場合、デフォルトして数値19が使用される。

(foo 1 5 3 9)
     ⇒ 16
(foo 5)
     ⇒ 14

より一般的には、

(foo w x y…)
≡
(+ (- x w) y…)

慣例として引数の名前には、(たとえばinteger、integer1、bufferのような)期待されるタイプ名が含まれます。(buffersのような)複数形のタイプは、しばしばその型のオブジェクトのリストを意味します。objectのような引き数名は、それが任意の型であることを表します(EmacsオブジェクトタイプのリストはLispのデータ型を参照)。他の名前をもつ引数(たとえばnew-file)はその関数に固有の引数で、関数がドキュメント文字列をもつ場合、引数のタイプはその中で説明されるべきです(ドキュメントを参照)。

&optionalや&restにより修飾される引数のより完全な説明は、ラムダ式を参照してください。

コマンド(command)、マクロ(macro)、スペシャルフォーム(special form)の説明も同じフォーマットですが、‘Function’が‘Command’、‘Macro’、‘Special Form’に置き換えられます。コマンドはとは単に、インタラクティブ(interactive: 対話的)に呼び出すことができる関数です。マクロは関数とは違う方法(引数は評価されない)で引数を処理しますが、同じ方法で記述します。

マクロとスペシャルフォームにたいする説明には、特定のオプション引数や繰り替えされる引数のために、より複雑な表記が使用されます。なぜなら引数リストが、より複雑な方法で別の引数に分離されるからです。‘[optional-arg]’はoptional-argがオプションであることを意味し、‘repeated-args…’は0個以上の引数を表します。カッコ(parentheses)は、複数の引数をリスト構造の追加レベルにグループ化するのに使用されます。以下は例です:

Special Form: count-loop (var [from to [inc]]) body… ¶

この架空のスペシャルフォームは、 bodyフォームを実行してから変数varをインクリメントするループを実装します。最初の繰り返しでは変数は値fromをもちます。以降の繰り返しでは、変数は1(incが与えられた場合はinc)増分されます。varがtoに等しい場合、bodyを実行する前にループをexitします。以下は例です:

(count-loop (i 0 10)
  (prin1 i) (princ " ")
  (prin1 (aref vector i))
  (terpri))

fromとtoが省略された場合、ループを実行する前にvarにnilがバインドされ、繰り返しの先頭においてvarが非nilの場合は、ループをexitします。以下は例です:

(count-loop (done)
  (if (pending)
      (fixit)
    (setq done t)))

このスペシャルフォームでは、引数fromとtoはオプションですが、両方を指定するか未指定にするかのいずれかでなければなりません。これらの引数が与えられた場合には、オプションでincも同様に指定することができます。これらの引数は、フォームのすべての残りの要素を含むbodyと区別するために、引数varとともにリストにグループ化されます。

1.3.7.2 変数の説明例

変数(variable)とは、オブジェクトにバインド(bind)される名前です(セット(set)とも言う)。変数がバインドされたオブジェクトのことを値(value)と呼びます。このような場合には、その変数が値をもつという言い方もします。ほとんどすべての変数はユーザーがセットすることができますが、特にユーザーが変更できる特定の変数も存在し、これらはユーザーオプション(user options)と呼ばれます。通常の変数およびユーザーオプションは、関数と同様のフォーマットを使用して説明されますが、それらには引数がありません。

以下は架空の変数electric-future-mapの説明です。

Variable: electric-future-map ¶: この変数の値はElectric Command Futureモードで使用される完全なキーマップである。このマップ内の関数により、まだ実行を考えていないコマンドの編集が可能になる。

ユーザーオプションも同じフォーマットをもちますが、‘Variable’が‘User Option’に置き換えられます。

1.4 バージョンの情報

以下の機能は、使用しているEmacsに関する情報を提供します。

Command: emacs-version &optional here ¶

この関数は実行しているEmacsのバージョンを説明する文字列をreturnすす。これはバグレポートにこの文字列を含めるときに有用である。

(emacs-version)
  ⇒ "GNU Emacs 26.1 (build 1, x86_64-unknown-linux-gnu,
             GTK+ Version 3.16) of 2017-06-01"

hereが非nilならテキストをバッファーのポイントの前に挿入して、nilをリターンする。この関数がインタラクティブに呼び出すと、同じ情報をエコーエリアに出力する。プレフィクス引数を与えると、hereが非nilになる。

Variable: emacs-build-time ¶

この変数の値はEmacsがビルドされた日時を示す。値はcurrent-timeの形式(時刻を参照)、その情報が利用できなければnil。

emacs-build-time
     ⇒ (25194 55894 8547 617000)

(Emacsのビルド時にcurrent-time-listがnilなら、タイムスタンプは(1651169878008547617 . 1000000000)になる。)

Variable: emacs-version ¶: この変数の値は実行中のEmacsのバージョンであり、"26.1"のような文字列。"26.0.91"のように3つの数値コンポーネントをもつ値はリリース版ではなくテストバージョンであることを示す(Emacs 26.1より前では"25.1.1"のように文字列の最後に余分な整数コンポーネントが含まれていたが、これは現在はemacs-build-numberに格納される)。

Variable: emacs-major-version ¶: Emacsのメジャーバージョン番号を示す整数。Emacs 23.1では値は23。

Variable: emacs-minor-version ¶: Emacsのマイナーバージョン番号を示す整数。Emacs 23.1では値は1。

Variable: emacs-build-number ¶: これは同一のディレクトリーにおいてEmacsが(クリーニングなしで)ビルドされるたびに増分される整数。これはEmacsの開発時だけに関係のある変数。

Variable: emacs-repository-version ¶: Emacsがビルドされたレポジトリのリビジョン番号を与える文字列。Emacsがリビジョンコントロール外部でビルドされた場合の値はnil。

Variable: emacs-repository-branch ¶: Emacsがビルドされたレポジトリブランチを与える文字列。ほとんどの場合は"master"。Emacsがリビジョンコントロール外部でビルドされた場合の値はnil。

1.5 謝辞

このマニュアルは当初、Robert Krawitz、Bil Lewis、Dan LaLiberte、Richard M. Stallman、Chris Welty、およびGNUマニュアルグループのボランティアにより、数年を費やして記述されました。Robert J. Chassellはこのマニュアルのレビューと編集をDefense Advanced Research Projects Agency、ARPA Order 6082のサポートのもとに手助けしてくれ、Computational Logic, IncのWarren A. Hunt, Jr.によりアレンジされました。それ以降も追加のセクションがMiles Bader、Lars Brinkhoff、Chong Yidong、Kenichi Handa、Lute Kamstra、Juri Linkov、Glenn Morris、Thien-Thi Nguyen、Dan Nicolaescu、Martin Rudalics、Kim F. Storm、Luc Teirlinck、Eli Zaretskii、およびその他の人たちにより記述されました。

Drew Adams、Juanma Barranquero、Karl Berry、Jim Blandy、Bard Bloom、Stephane Boucher、David Boyes、Alan Carroll、Richard Davis、Lawrence R. Dodd、Peter Doornbosch、David A. Duff、Chris Eich、Beverly Erlebacher、David Eckelkamp、Ralf Fassel、Eirik Fuller、Stephen Gildea、Bob Glickstein、Eric Hanchrow、Jesper Harder、George Hartzell、Nathan Hess、Masayuki Ida、Dan Jacobson、Jak Kirman、Bob Knighten、Frederick M. Korz、Joe Lammens、Glenn M. Lewis、K. Richard Magill、Brian Marick、Roland McGrath、Stefan Monnier、Skip Montanaro、John Gardiner Myers、Thomas A. Peterson、Francesco Potortì、Friedrich Pukelsheim、Arnold D. Robbins、Raul Rockwell、Jason Rumney、Per Starbäck、Shinichirou Sugou、Kimmo Suominen、Edward Tharp、Bill Trost、Rickard Westman、Jean White、Eduard Wiebe、Matthew Wilding、Carl Witty、Dale Worley、Rusty Wright、David D. Zuhnにより訂正が提供されました。

より完全な貢献者のリストは、Emacsソースレポジトリの関連する変更ログエントリーを参照してください。

2 Lispのデータ型

Lispのオブジェクト(object)とは、Lispプログラムから操作されるデータです。型(type)やデータ型(data type)とは、可能なオブジェクトの集合を意味します。

すべてのオブジェクトは少なくとも1つの型に属します。同じ型のオブジェクトは同様な構造をもち、通常は同じコンテキストで使用されます。型を重複してもつことができ、オブジェクトは複数の型に属することができます。その結果として、あるオブジェクトが特定の型に属するかどうかを尋ねることはできますが、オブジェクトがその型だけに属するかどうかは決定できません。

Emacsにはいくつかの基本オブジェクト型が組み込まれています。これらの型は他のすべての型を構成するもとであり、プリミティブ型(primitive types: 基本型)と呼ばれます。すべてのオブジェクトはただ1つのプリミティブ型に属します。これらの型には整数(integer)、浮動小数点数(float)、コンス(cons)、シンボル(symbol)、文字列(string)、ベクター(vector)、ハッシュテーブル(hash-table)、サブルーチン(subr)、バイトコード関数(byte-code function)、レコード(record)、およびbufferのような編集に関連した特別な型が含まれます(編集用の型を参照)。

プリミティブ型にはそれぞれ、オブジェクトがその型のメンバーかどうかのチェックを行なうために、それぞれ対応するLisp関数があります。

他の多くの言語とは異なり、Lispのオブジェクトは自己記述(self-typing)的です。オブジェクトのプリミティブ型は、オブジェクト自体に暗に含まれます。たとえばオブジェクトがベクターなら、それを数字として扱うことはできません。Lispはベクターが数字でないことを知っているのです。

多くの言語では、プログラマーは各変数にたいしてデータ型を宣言しなければならず、コンパイラーは型を知っていますが、データの中に型はありません。Emacs Lispには、このような型宣言はありません。Lisp変数は任意の型の値をもつことができ、変数に保存した値と型を記憶します(実際には特定の型の値だけをもつことができる少数のEmacs Lisp変数がある。値を制限された変数を参照されたい)。

このチャプターでは、GNU Emacs Lispの各標準型の意味、プリント表現(printed representation)、入力構文(read syntax)を説明します。これらのデータ型を使用する方法についての詳細は、以降のチャプターを参照してください。

2.1 プリント表現と読み取り構文		Lispオブジェクトがテキストとして表現される方法。
2.2 特別な読み取り構文		すべての特殊なシーケンスの概要。
2.3 コメント		コメントとコメント書式の慣例。
2.4 プログラミングの型		すべてのLispシステムに存在する型。
2.5 編集用の型		Emacs固有の型。
2.6 循環オブジェクトの読み取り構文		循環構造にたいする入力構文。
2.7 型のための述語		型に関連するテスト。
2.8 同等性のための述語		2つのオブジェクトが等しいかのテスト。
2.9 可変性		変更されるべきではないオブジェクト。

2.1 プリント表現と読み取り構文

オブジェクトのプリント表現(printed representation)とは、オブジェクトにたいしてLispプリンター(関数prin1)が生成する出力のフォーマットです。すべてのデータ型は一意なプリント表現をもちます。オブジェクトの入力構文(read syntax)とは、オブジェクトにたいしてLispリーダー(関数read)が受け取る入力のフォーマットです。これは一意である必要はありません。多くの種類のオブジェクトが複数の構文をもちます。Lispオブジェクトの読み取りとプリントを参照してください。

ほとんどの場合、オブジェクトのプリント表現が、入力構文としても使用されます。しかしLispプログラム内の定数とすることに意味が無いいくつかの型には、入力構文がありません。これらのオブジェクトはハッシュ表記(hash notation)でプリントされ、‘#<’、説明的な文字列(典型的には型名にオブジェクトの名前を続けたもの)、‘>’で構成される文字列です(“hash: ハッシュ記号”や“number sign: 番号記号”として知られている‘#’文字で始まることから“ハッシュ表記”と呼ばれる)。たとえば:

(current-buffer)
     ⇒ #<buffer objects-ja.texi>

ハッシュ表記は読み取ることができないので、Lispリーダーは‘#<’に遭遇すると常にエラーinvalid-read-syntaxをシグナルします。

このチャプターの以降のセクションにおいては、そのデータタイプを構成するLispデータタイプそれぞれにたいして読み取り構文とプリント表現を説明していきます。たとえば文字列型とそのサブセクションにおける文字列、ベクター型とそのサブセクションにおけるベクターの読み取り構文とプリント表現を参照してください。

他の言語では式はテキストであり、これ以外の形式はありません。Lispでは式は第一にまずLispオブジェクトであって、オブジェクトの入力構文であるテキストは副次的なものに過ぎません。たいていこの違いを強調する必要はありませんが、このことを心に留めておかないとたまに混乱することがあるでしょう。

インタラクティブに式を評価するとき、Lispインタープリターは最初にそれのテキスト表現を読み取り、Lispオブジェクトを生成してからそのオブジェクトを評価します(評価を参照)。しかし評価と読み取りは別の処理です。読み取りによりテキストにより表現されたLispオブジェクトを読み取り、Lispオブジェクトがリターンされます。後でオブジェクトは評価されるかもしれないし、評価されないかもしれません。オブジェクトを読み取るための基本的な関数readの説明は、入力関数を参照してください。

2.2 特別な読み取り構文

Emacs Lispでは特別なハッシュ表記を通じて多くの特別なオブジェクトと構文を表します。

‘#<…>’

入力構文がないオブジェクトはこのように表される(プリント表現と読み取り構文を参照)。

‘##’

名前が空文字列であるようなインターン済みシンボルのプリント表現(シンボル型を参照)。

‘#'’

functionにたいするショートカット。無名関数を参照のこと。

‘#:’

名前がfooであるようなインターンされていないシンボルのプリント表現は‘#:foo’ (シンボル型を参照)。

‘#N’

循環構造のプリント時には構造が自身をループバックすることを表すためにこの構文が使用される。ここで‘N’リストの開始カウント。

(let ((a (list 1)))
  (setcdr a a))
=> (1 . #0)

‘#N=’

‘#N#’

‘#N=’はオブジェクト名、‘#N#’はそのオブジェクトを表すので、これらはコピーではなく同一オブジェクトになる(循環オブジェクトの読み取り構文を参照)。

‘#xN’

16進表現の‘N’ (‘#x2a’)。

‘#oN’

8進表現の‘N’ (‘#o52’)。

‘#bN’

2進表現の‘N’ (‘#b101010’)。

‘#(…)’

文字列のテキストプロパティ(文字列内のテキストプロパティを参照)。

‘#^’

文字テーブル(文字テーブル型を参照)。

‘#s(hash-table …)’

ハッシュテーブル(ハッシュテーブル型を参照)。

‘?C’

文字(基本的な文字構文を参照)。

‘#$’

バイトコンパイル済みファイルのカレントファイル名(ドキュメント文字列とコンパイルを参照)。これはEmacs Lispソースファイルで使用するためのものではない。

‘#@N’

次の‘N’文字をスキップする(コメントを参照)。バイトコンパイル済みファイル内で使用されるものであって、Emacs Lispソースファイル内で使用するためのものではない。

‘#f’

これに続くフォームがEmacs Lispリーダーで読み取れないことを示す。これは表示されることを意図したテキストだけに出現する読み取り構文(読み取れないフォームを示すための他の選択肢よりも見栄えがよくなると思われる場合)、でありLispファイル中に出現することは決してない。

2.3 コメント

コメント(comment)はプログラム中に記述されたテキストであり、そのプログラムを読む人間ためだけに存在するものであって、プログラムの意味には何の影響ももちません。Lispではそれが文字列や文字定数にある場合をのぞき、エスケープされていないセミコロン(‘;’)でコメントが開始されます。行の終端までがコメントになります。Lispリーダーはコメントを破棄します。コメントはLispシステム内でプログラムを表すLispオブジェクトの一部にはなりません。

‘#@count’構成は、次のcount個の文字をスキップします。これはプログラムにより生成されたバイナリーデータを含むコメントにたいして有用です。Emacs Lispバイトコンパイラーは出力ファイルにこれを使用します(バイトコンパイルを参照)。しかしソースファイル用ではありません。

コメントのフォーマットにたいする慣例は、コメント記述のヒントを参照してください。

2.4 プログラミングの型

Emacs Lispには2種類の一般的な型があります。1つはLispプログラミングに関わるもので、もう1つは編集に関わるものです。前者はさまざまな形で多くのLisp実装に存在します。後者はEmacs Lispに固有です。


2.4.1 整数型		小数部のない数字。
2.4.2 浮動小数点数型		広い範囲をもつ、小数部をもつ数字。
2.4.3 文字型		文字、数字、コントロール文字にたいする表現。
2.4.4 シンボル型		関数、変数、プロパティリストを参照する、一意に識別される多目的オブジェクト。
2.4.5 シーケンス型		リストと配列はどちらもシーケンスに分類される。
2.4.6 コンスセルとリスト型		コンスセル、および(コンスセルにより作られる)リスト。
2.4.7 配列型		配列には文字列とベクターが含まれる。
2.4.8 文字列型		(効率的な)文字の配列。
2.4.9 ベクター型		1次元の配列。
2.4.10 文字テーブル型		文字によりインデックスされる1次元の疎な配列。
2.4.11 ブールベクター型		`t`と`nil`からなる1次元の配列。
2.4.12 ハッシュテーブル型		非常に高速な参照用のテーブル。
2.4.13 関数型		他の場所から呼び出せる実行可能なコード断片。
2.4.14 マクロ型		より基本的だが少し見栄えの悪い、式を他の式に展開する手法。
2.4.15 プリミティブ関数型		Lispから呼び出せるCで記述された関数。
2.4.16 バイトコード関数型		Lispで記述されてコンパイルされた関数。
2.4.17 レコード型		プログラーが定義する合成オブジェクト型。
2.4.18 型記述子		型に関する情報を保持するオブジェクト。
2.4.19 autoload型		頻繁に使用されない関数を自動的にロードするために使用される型。
2.4.20 ファイナライザー型		オブジェクトが到達不能になった際に実行するコード。

2.4.1 整数型

内部にはfixnumsと呼ばれる小さい整数、およびbignumsという大きい整数という2種類の整数が存在します。

fixnumの値の範囲はマシンに依存します、最小のレンジは-536,870,912から536,870,911(30ビットでは -2**29 から 2**29 - 1) しかし多くのマシンはより広い範囲を提供します。

bignumは任意の精度をもつことができます。fixnumのオーバーフローする処理では、かわりにbignumをリターンされます。

eqlや=ですべての数値、fixnumならeqで比較することができます。整数がfixnumかbignumをテストするにはmost-negative-fixnumとmost-positive-fixnumで比較するか、便利な述語fixnumpとbignumpを任意のオブジェクトに使用できます。

整数にたいする入力構文は、(10を基数とする)数字のシーケンスで、オプションで先頭に符号、最後にピリオドがつきます。Lispインタープリターにより生成されるプリント表現には、先頭の ‘+’や最後の‘.’はありません。

-1               ; 整数の-1
1                ; 整数の1
1.               ; これも整数の1
+1               ; これも整数の1

詳細は数値を参照してください。

2.4.2 浮動小数点数型

浮動小数点数は、コンピューターにおける科学表記に相当するものです。浮動小数点数を10の指数をともなう有理数として考えることができます。正確な有効桁数と可能な指数はマシン固有です。Emacsは値の保存にCデータ型のdoubleを使用し、内部的には10の指数ではなく、2の指数として記録します。

浮動小数点数のプリント表現には、(後に最低1つの数字をともなう)小数点と、指数のどちらか一方、または両方が必要です。たとえば‘1500.0’、‘+15e2’、‘15.0e+2’、‘+1500000e-3’、‘.15e4’は、いずれも浮動小数点数の1500を記述し、これらはすべて等価です。

詳細は数値を参照してください。

2.4.3 文字型

Emacs Lispでの文字(character)は、整数以外の何者でもありません。言い換えると、文字は文字コードで表現されます。たとえば文字Aは、整数の65として表現されます。これも通常のプリント表現です。基本的な文字構文を参照してください。

プログラムで文字を個別に使用するのは稀であり、文字のシーケンスとして構成される文字列(strings)として扱われるのがより一般的です。文字列型を参照してください。

文字列やバッファーの中の文字は、現在のところ0から4194303の範囲 — つまり22ビットに制限されています(文字コードを参照)。0から127のコードはASCIIコードで、残りは非ASCIIです(非ASCII文字を参照)。キーボード入力を表す文字はコントロール(Control)、メタ(Meta)、シフト(Shift)などの修飾キーをエンコードするために、より広い範囲をもちます。

文字から可読なテキスト記述を生成する、メッセージ用の特別な関数が存在します。ヘルプメッセージの文字記述を参照してください。

2.4.3.1 基本的な文字構文

文字は実際には整数なので、文字のプリント表現は10進数です。文字にたいする入力構文も利用可能ですが、Lispプログラムでこの方法により文字を記述するのは、明解なプログラミングではありません。文字にたいしては、Emacs Lispが提供する、特別な入力構文を常に使用するべきです。これらの構文フォーマットはクエスチョンマークで開始されます。

英数字にたいする通常の入力構文は、クエスチョンマークと、その後にその文字を記述します。したがって文字Aは‘?A’、文字Bは‘?B’、文字aは‘?a’となります。

たとえば:

?Q ⇒ 81     ?q ⇒ 113

区切り文字(punctuation characters)にも同じ構文を使用できますが、区切り文字がLispで特別な意味をもつ場合には‘\’でクォートしなければなりません。たとえば‘?\(’が開カッコを記述する方法であり、同様に文字が‘\’なら、‘?\\’のようにクォートするために2つ目の‘\’を使用しなければなりません。

Ctrl+g(control-g)、バックスペース(backspace)、タブ(tab)、改行(newline)、垂直タブ(vertical tab)、フォームフィード(formfeed)、スペース(space)、キャリッジリターン(return)、デリート(del)、エスケープ(escape)はそれぞれ‘?\a’、‘?\b’、‘?\t’、‘?\n’、‘?\v’、‘?\f’、‘?\s’、‘?\r’、‘?\d’、‘?\e’と表すことができます(後にダッシュのついた‘?\s’は違う意味をもつ — これは後続の文字にたいしてスーパーによる修飾を適用する)。したがって、

?\a ⇒ 7                 ; control-g、C-g
?\b ⇒ 8                 ; バックスペース、BS、C-h
?\t ⇒ 9                 ; タブ、TAB、C-i
?\n ⇒ 10                ; 改行、C-j
?\v ⇒ 11                ; 垂直タブ、C-k
?\f ⇒ 12                ; フォームフィード文字、C-l
?\r ⇒ 13                ; キャリッジリターン、RET、C-m
?\e ⇒ 27                ; エスケープ文字、ESC、C-[
?\s ⇒ 32                ; スペース文字、SPC
?\\ ⇒ 92                ; バックスラッシュ文字、\
?\d ⇒ 127               ; デリート文字、DEL

バックスラッシュがエスケープ文字の役割を果たすので、これらのバックスラッシュで始まるシーケンスはエスケープシーケンス(escape sequences)とも呼ばれます。この用語法は文字ESCとは関係ありません。‘\s’は文字定数としての使用を意図しており、文字定数の内部では単にスペースを記述します。

エスケープという特別な意味を与えずに、任意の文字の前にバックスラッシュの使用することは許されていて害もありません。したがって‘?\+’は‘?+’と等価です。ほとんどの文字の前にバックスラッシュを追加することに理由はありません。しかし文字‘()[]\;"’の前にはバックスラッシュを追加しなければならず、Lispコードを編集するEmacsコマンドが混乱するのを避けるために‘|'`#.,’の前にもバックスラッシュを追加するべきです。コードを読む人の混乱を避けるために、前に言及したASCII文字と類似したUnicode文字の前にもバックスラッシュを追加する必要があります。これを奨励するために、‘‘’のような一般的には混乱を招くエスケープされていない文字をハイライトします。スペース、タブ、改行、フォームフィードのような空白文字の前にもバックスラッシュを追加できます。しかしタブやスペースspaceのような実際の空白文字のかわりに、‘\t’や‘\s’のような可読性のあるエスケープシーケンスを使用するほうが明解です(スペースを後にともなうバックスラッシュを記述する場合、後続のテキストと区別するために、文字定数の後に余分なスペースを記述すること)。

2.4.3.2 一般的なエスケープ構文

特に重要なコントロール文字にたいする特別なエスケープシーケンスに加えて、Emacsは非ASCIIテキスト文字の指定に使用できる、何種類かのエスケープ構文を提供します。

もしあればUnicode名で文字を指定できる。?\N{NAME}はNAMEという名前のUnicode文字を表す。したがって‘?\N{LATIN SMALL LETTER A WITH GRAVE}’は?àと等価でありUnicode文字のU+00E0を意味する。名前中のスペースを空白文字(改行)の非空のシーケンスにして複数行文字列の入力を簡略化できる。
Unicode値で文字を指定できる。?\N{U+X}はUnicodeコードポイントX (16進数値)を表す。また?\uxxxxと?\Uxxxxxxxxはそれぞれコードポイントxxxxとxxxxxxxxを表すxは(1つの16進数字)。たとえば?\N{U+E0}、?\u00e0、?\U000000E0は?àと‘?\N{LATIN SMALL LETTER A WITH GRAVE}’に等しい。Unicode標準は‘U+10ffff’以下のコードポイントだけを定義するので、これより大きいコードポイントではEmacsはエラーをシグナルする。
文字を16進の文字コードで指定できる。16進エスケープシーケンスはバックスラッシュ、‘x’、および16進の文字コードにより構成される。したがって‘?\x41’は文字A、‘?\x1’は文字C-a、?\xe0は文字à (グレイブアクセントつきのa)になる。‘x’の後に1つ以上の16進数を使用できるので、この方法で任意の文字を表すことができる。
8進の文字コードにより文字を指定できる。8進エスケープシーケンスは3桁までの8進数字をともなうバックスラッシュにより形成される。したがって‘?\101’は文字A、‘?\001’は文字C-a、?\002は文字C-bを表す。この方法で指定できるのは8進コード777までの文字のみ。

これらのエスケープシーケンスは文字列内でも使用されます。文字列内の非ASCII文字を参照してください。

2.4.3.3 コントロール文字構文

他の入力構文を使用してコントロール文字を表すことができます。これは後にバックスラッシュ、カレット、対応する非コントロール文字(大文字か小文字)をともなうクエスチョンマークから構成されます。たとえば‘?\^I’と‘?\^i’はどちらも、値が9である文字C-iの有効な入力構文です。

‘^’のかわりに‘C-’を使用することもできます。したがって‘?\C-i’は‘?\^I’や‘?\^i’と等価です。

?\^I ⇒ 9     ?\C-I ⇒ 9

文字列やバッファーの中ではASCIIのコントロール文字だけが許されますが、キーボード入力にたいしては‘C-’により任意の文字をコントロール文字にすることができます。これらの非ASCIIのコントロール文字にたいするコントロール文字には非コントロール文字にたいするコードと同様に、2**26 ビットが含まれます。すべてのテキスト端末が非ASCIIコントロール文字を生成できる訳ではありませんが、Xやその他のウィンドウシステムを使用すれば直接生成することができます。

歴史的な理由により、EmacsはDEL文字を?のコントロール文字として扱います:

?\^? ⇒ 127     ?\C-? ⇒ 127

結果として、Xでは有意な入力文字であるControl-?文字を、‘\C-’を使用して表現することは今のところできません。さまざまなLispファイルがこの方法でDELを参照するので、これを変更するのは簡単ではないのです。

コントロール文字の表現はファイルや文字列内で見ることができますが、わたしたちは‘^’構文を推奨します。キーボード入力にたいするコントロール文字に好ましいのは、‘C-’構文です。どちらを使用するかはプログラムの意味に影響しませんが、プログラムを読む人の理解を助けるでしょう。

2.4.3.4 メタ文字構文

メタ文字(meta character)とは、META修飾キーとともにタイプされた文字です。そのような文字を表す整数には 2**27 のビットがセットされています。基本的な文字コードの広い範囲を利用可能にするために、メタやその他の修飾にたいしては上位ビットを使用します。

文字列では、メタ文字を示すASCII文字に、 2**7 ビットが付加されます。したがって文字列に含めることができるメタ文字のコードは128から255の範囲となり、メタ文字は通常のASCII文字のメタ修飾されたバージョンとなります。文字列内でのMETA処理の詳細については、文字列内へのキーボードイベントの配置を参照してください。

メタ文字の入力構文には‘\M-’を使用します。たとえば‘?\M-A’はM-Aを意味します。8進文字コード(以下参照)や、‘\C-’、その他の文字にたいする他の構文とともに‘\M-’を使用できます。したがって、M-Aは‘?\M-A’や‘?\M-\101’と記述できます。同様にC-M-bは‘?\M-\C-b’、‘?\C-\M-b’、‘?\M-\002’と記述することができます。

2.4.3.5 その他の文字修飾ビット

グラフィック文字(graphic character)のcaseは文字コードで示されます。たとえばASCIIでは、文字‘a’と文字‘A’は区別されます。しかしASCIIにはコントロール文字が大文字なのか小文字なのかを表現する方法がありません。コントロール文字がタイプされたときシフトキーが使用されたかを示すために、Emacsは 2**25 のビットを使用します。この区別はX上でのGUIディスプレイのようなグラフィカルディスプレイでのみ利用できます。通常のテキスト端末はこれらの違いを報告しません。シフトをあらわすビットのためのLisp構文は‘\S-’です。したがって‘?\C-\S-o’や‘?\C-\S-O’は、Shift+Ctrl+o文字を表します。

Xウィンドウシステムは文字にセットするために、他にも3つ修飾ビット — ハイパー(hyper)、スーパー(super)、アルト(alt)を定義します。これらのビットにたいする構文は、‘\H-’、‘\s-’、‘\A-’です(これらのプレフィクスでは、caseは意味がある)。したがって‘?\H-\M-\A-x’はAlt-Hyper-Meta-xを表します(‘-’が後にない‘\s’はスペース文字を表すことに注意)。数値としてはビット値2**22はアルト、2**23はスーパー、2**24はハイパーです。

2.4.4 シンボル型

GNU Emacs Lispでのシンボル(symbol)とは、名前をもつオブジェクトです。シンボル名は、そのシンボルのプリント表現としての役割があります。Lispの通常の使用では、1つのobarray(シンボルの作成とinternを参照)により、シンボル名は一意です — 2つのシンボルが同じ名前をもつことはありません。

シンボルは変数や関数名としての役割、プロパティリストを保持する役割をもつことができます。データ構造内にそのようなシンボルが存在することが確実に認識できるように、他のすべてのLispオブジェクトから区別するためだけの役割をもつ場合もあります。与えられたコンテキストにおいて、通常はこれらのうちの1つの使用だけが意図されます。しかし3つすべての方法で、1つのシンボルを独立して使用することもできます。

名前がコロン(‘:’)で始まるシンボルはキーワードシンボル(keyword symbol)と呼ばれます。これらのシンボルは自動的に定数として振る舞い、通常は未知のシンボルといくつかの特定の候補を比較することだけに使用されます。変更不可な変数を参照してください。

シンボル名にはどんな文字でも含めることができます。ほとんどのシンボル名は英字、数字、‘-+=*/’などの区切り文字で記述されます。このような名前には特別な区切り文字は必要ありません。名前が数字のように見えない限り、名前にはどのような文字も使用できます(名前が数字のように見える場合は、名前の先頭に‘\’を記述して強制的にシンボルとして解釈させる)。文字‘_~!@$%^&:<>{}?’はあまり使用されませんが、これらも特別な句読点文字を必要としません。他の文字も、バックスラッシュでエスケープすることにより、シンボル名に含めることができます。しかし文字列内でのバックスラッシュの使用とは対照的に、シンボル名でのバックスラッシュは、バックスラッシュの後の1文字をエスケープするだけです。たとえば文字列内では、‘\t’はタブ文字を表します。しかしシンボル名の中では、‘\t’は英字‘t’をクォートするに過ぎません。名前にタブ文字をもつシンボルを記述するには、(バックスラッシュを前置した)実際のタブを使用しなければなりません。しかし、そのようなことを行なうことは稀です。

Common Lispに関する注意:Common Lispでは明示的にエスケープされない限り、小文字は常に大文字に“フォールド(folded)”される。Emacs Lispでは大文字と小文字は区別される。

以下はシンボル名の例です。4つ目の例の中の‘+’は、シンボルが数字として読み取られるのを防ぐためにエスケープされていることに注意してください。6つ目の例では、名前の残りの部分により数字としては不正なのでエスケープの必要はありません。

foo                 ; ‘foo’という名前のシンボル
FOO                 ; ‘foo’とは別の、‘FOO’という名前のシンボル

1+                  ; ‘1+’という名前のシンボル
                    ;   (整数の‘+1’ではない)

\+1                 ; ‘+1’という名前のシンボル
                    ;   (判読しにくい名前)

\(*\ 1\ 2\)         ; ‘(* 1 2)’という名前のシンボル(悪い名前)
+-*/_~!@$%^&=:<>{}  ; ‘+-*/_~!@$%^&=:<>{}’という名前のシンボル
                    ;   これらの文字のエスケープは不要

シンボル名がプリント表現としての役割をもつというルールの例外として、‘##’があります。これは、名前が空文字列のinternされたシンボルのプリント表現です。さらに‘#:foo’は、internされていないfooという名前のシンボルにたいするプリント表現です(通常、Lispリーダーはすべてのシンボルをinternする。シンボルの作成とinternを参照されたい)。

2.4.5 シーケンス型

シーケンス(sequence)とは、要素の順序セットを表現するLispオブジェクトです。Emacs Lispには2種類のシーケンス — リスト(lists)と配列(arrays)があります。

リストはもっとも一般的に使用されるシーケンスです。リストは任意の型の要素を保持でき、要素の追加と削除により簡単に長さを変更できます。リストについては、次のサブセクションを参照してください。

配列は固定長のシーケンスです。配列はさらに文字列(strings)、ベクター(vectors)、文字テーブル(char-tables)、ブールベクター(bool-vectors)に細分されます。ベクターは任意の型の要素を保持できますが、文字列の要素は文字でなければならず、ブールベクターの要素はtかnilでなければなりません。文字テーブルはベクターと似ていますが、有効な文字によりインデックスづけされる点が異なります。文字列内の文字は、バッファー内の文字のようにテキストプロパティをもつことができます(テキストのプロパティを参照)。しかしベクターはその要素が文字のときでも、テキストプロパティをサポートしません。

リスト、文字列、およびその他の配列型も、重要な類似点を共有します。たとえば、それらはすべて長さlをもち、要素は0からl-1でインデックスづけされます。いくつかの関数はシーケンス関数と呼ばれ、これらは任意の種類のシーケンスを許容します。たとえば、関数lengthは、任意の種類のシーケンスの長さを報告します。シーケンス、配列、ベクターを参照してください。

シーケンスは読み取りにより常に新たに作成されるため、同じシーケンスを2回読み取るのは一般的に不可能です。シーケンスにたいする入力構文を2回読み取った場合には、内容が等しい2つのシーケンスを得ます。これには1つ例外があります。空リスト()は、常に同じオブジェクトnilを表します。

2.4.6 コンスセルとリスト型

コンスセル(cons cell)はCARスロット、CDRスロットと呼ばれる2つのスロットから構成されるオブジェクトです。それぞれのスロットはには、任意のLispオブジェクトを保持できます。そのときCARスロットに保持されるオブジェクトが何であれ、わたしたちは“このコンスセルのCAR”のような言い方をします。これはCDRの場合も同様です。

リスト(list)はコンスセルの連続するシリーズで、各コンスセルのCDRスロットは次のコンスセル、または空リストを保持します。空リストは実際にはシンボルnilです。詳細については、リストを参照してください。ほとんどのコンスセルはリストの一部として使用されるので、わたしたちはコンスセルにより構成される任意の構造を、リスト構造(list structure)という用語で参照します。

Cプログラマーにたいする注意: Lispのリストはコンスセルにより構築されるリンクリスト(linked list)として機能する。Lispではポインターは暗黙的なので、コンスセルのスロットが値を“保持(hold)”するのか、それとも値を“指す(point)”のかは区別しない。

コンスセルはLispの中核なので、コンスセルではないオブジェクトにたいする用語もあります。これらのオブジェクトはアトム(atoms)と呼ばれます。

リストにたいする入力構文とプリント表現は同じで左カッコ、任意の数の要素、右カコから構成されます。以下はリストの例です:

(A 2 "A")            ; 3要素のリスト
()                   ; 要素がないリスト(空リスト)
nil                  ; 要素がないリスト(空リスト)
("A ()")             ; 1要素のリスト: 文字列"A ()"
(A ())               ; 2要素のリスト: Aと空リスト
(A nil)              ; 同上
((A B C))            ; 1要素のリスト
                     ;   (この要素は、3要素のリスト)

読み取りではカッコの内側はリストの要素になります。つまりコンスセルは各要素から作成されます。コンスセルのCARスロットは要素を保持し、CDRスロットはリスト内の次のコンスセル(このコンスセルはリスト内の次の要素をする)を参照します。最後のコンスセルのCDRスロットはnilを保持するようにセットされます。

CARやCDRという名称はLispの歴史に由来します。オリジナルのLisp実装はIBM 704コンピューターで実行されていました。ワードを2つの部分、つまり“address”と呼ばれる部分と、“decrement”と呼ばれる部分に分割していて、その際CARはaddress部から内容を取り出す命令で、CDRはdecrement部から内容を取り出す命令でした。これとは対照的に“cons cells”は、これらを作成する関数consから命名されました。この関数は関数の目的、すなわちセルを作る(construction of cells)という目的から命名されました。

2.4.6.1 ボックスダイアグラムによるリストの描写

コンスセルを表現するドミノのような1対のボックスによる図で、リストを説明することができます(Lispリーダーがこのような図を読み取ることはできない。人間とコンピューターが理解できるテキスト表記と異なり、ボックス図は人間だけが理解できる)。この図は3要素のリスト(rose violet buttercup)を表したものです:

    --- ---      --- ---      --- ---
   |   |   |--> |   |   |--> |   |   |--> nil
    --- ---      --- ---      --- ---
     |            |            |
     |            |            |
      --> rose     --> violet   --> buttercup

この図では、ボックスは任意のLispオブジェクトへの参照を保持できるスロットを表します。ボックスのペアーはコンスセルを表します。矢印はLispオブジェクト(アトム、または他のコンスセル)への参照を表します。

この例では、1番目のボックスは1番目のコンスセルで、それのCARはrose(シンボル)を参照または保持します。2番目のボックスは1番目のコンスセルのCDRを保持し、次のボックスペアすなわち2番目のコンスセルを参照します。2番目のコンスセルのCARはvioletで、CDRは3番目のコンスセルです。(最後の)3番目のコンスセルのCDRはnilです。

同じリスト(rose violet buttercup)を、違うやり方で描いた別の図で表してみましょう:

 ---------------       ----------------       -------------------
| car   | cdr   |     | car    | cdr   |     | car       | cdr   |
| rose  |   o-------->| violet |   o-------->| buttercup |  nil  |
|       |       |     |        |       |     |           |       |
 ---------------       ----------------       -------------------

要素がないリストは空リスト(empty list)で、これはシンボルnilと同じです。言い換えるとnilはシンボルであり、かつリストでもあります。

以下はリスト(A ())、または等価な(A nil)をボックスと矢印で描いたものです:

    --- ---      --- ---
   |   |   |--> |   |   |--> nil
    --- ---      --- ---
     |            |
     |            |
      --> A        --> nil

以下はもっと複雑な例です。これは1番目の要素が2要素のリストであるような、3要素のリスト((pine needles) oak maple)を表します:

    --- ---      --- ---      --- ---
   |   |   |--> |   |   |--> |   |   |--> nil
    --- ---      --- ---      --- ---
     |            |            |
     |            |            |
     |             --> oak      --> maple
     |
     |     --- ---      --- ---
      --> |   |   |--> |   |   |--> nil
           --- ---      --- ---
            |            |
            |            |
             --> pine     --> needles

同じリストを2番目のボックス表記で表すと、以下のようになります:

 --------------       --------------       --------------
| car   | cdr  |     | car   | cdr  |     | car   | cdr  |
|   o   |   o------->| oak   |   o------->| maple |  nil |
|   |   |      |     |       |      |     |       |      |
 -- | ---------       --------------       --------------
    |
    |
    |        --------------       ----------------
    |       | car   | cdr  |     | car     | cdr  |
     ------>| pine  |   o------->| needles |  nil |
            |       |      |     |         |      |
             --------------       ----------------

2.4.6.2 ドットペア表記

ドットペア表記(dotted pair notation)は、CARとCDRが明示的に表されたコンスセルの一般的な構文です。この構文では(a . b)がCARがオブジェクトa、CDRがオブジェクトbという意味になります。CDRがリストである必要がないので、ドットペア表記はより一般的なリスト構文です。しかしリスト構文が機能するような場合には、より扱いにくくなります。ドットペア表記では、リスト‘(1 2 3)’は‘(1 . (2 . (3 . nil)))’と記述されます。nilで終端されたリストにたいしては、どちらの表記法も使用できますが、リスト表記の方が通常は明解で便利です。リストをプリントする場合には、コンスセルのCDRがリストでないときだけドットペア表記が使用されます。

以下はボックスを使用してドットペア表記を表した例です。これはペア(rose . violet)を表します:

    --- ---
   |   |   |--> violet
    --- ---
     |
     |
      --> rose

最後のCDRが非nilのコンスセルのチェーンを表すので、ドットペア表記とリスト表記を組み合わせることができます。リストの最後の要素の後にドットを記述して、その後に最後のコンスセルのCDRを記述します。たとえば(rose violet . buttercup)は、(rose . (violet . buttercup))と等価です。オブジェクトは以下のようになります:

    --- ---      --- ---
   |   |   |--> |   |   |--> buttercup
    --- ---      --- ---
     |            |
     |            |
      --> rose     --> violet

構文(rose . violet . buttercup)は無効です。なぜならこれは何も意味していないからです。何か意味があるとしても、violetのためにCDRがすでに使用されているコンスセルのCDRに、buttercupを置くということになります。

リスト(rose violet)は(rose . (violet))と等価であり、以下のようになります:

    --- ---      --- ---
   |   |   |--> |   |   |--> nil
    --- ---      --- ---
     |            |
     |            |
      --> rose     --> violet

同様に3要素のリスト(rose violet buttercup)は、(rose . (violet . (buttercup)))と等価です。これは以下のようになります:

    --- ---      --- ---      --- ---
   |   |   |--> |   |   |--> |   |   |--> nil
    --- ---      --- ---      --- ---
     |            |            |
     |            |            |
      --> rose     --> violet   --> buttercup

2.4.6.3 連想リスト型

連想リスト(association list)またはalistは、要素がコンスセルであるように特別に構成されたリストです。各要素においては、CARがキー(key)で、CDRが連想値(associated value)であると考えます(連想値がCDRのCARに保存される場合もある)。リストの先頭への連想値の追加と削除は簡単なので、連想リストはスタック(stack)にしばしば使用されます。

たとえば、

(setq alist-of-colors
      '((rose . red) (lily . white) (buttercup . yellow)))

これは変数alist-of-colorsに3要素のalistをセットします。最初の要素では、roseがキーでredが値になります。

alistとalist関数についての詳細な説明は連想リストを参照してください。(多くのキーの操作をより高速に行なう)テーブルを照合する他の手段についてはハッシュテーブルを参照してください。

2.4.7 配列型

配列(array)は、他のLispオブジェクトを保持または参照する任意の数のスロットから構成され、メモリーの連続ブロックに配列されます。配列の任意の要素へのアクセス時間は大体同じです。対照的にリストの要素にたいするアクセスは、リスト内でのその要素の位置に比例した時間を要します(リストの最後の要素にアクセスするにはリストの最初の要素にアクセスするより長い時間が必要)。

Emacsは文字列(strings)、ベクター(vectors)、ブールベクター(bool-vectors)、文字テーブル(char-tables)という4種の配列を定義します。

文字列は文字の配列であり、ベクターは任意のオブジェクトの配列です。ブールベクターはtかnilだけを保持できます。この種の配列はシステムアーキテクチャー制限と利用可能なメモリーにしたがったもっとも大きいfixnumまでの任意の長さをもつことができます。文字テーブルは、任意の有効な文字コードによりインデックスづけされる疎な配列であり、任意のオブジェクトを保持することができます。

配列の最初の要素はインデックス0、2番目の要素はインデックス1、...となります。これは0基準(zero-origin)のインデックスづけと呼ばれます。たとえば、4要素の配列はインデックス0、1、2、3をもちます。利用できる最大のインデックス値は、配列の長さより1つ小さくなります。▼一度配列が作成されると、長さは固定されます。

Emacs Lispのすべての配列は、1次元です(他のほとんどのプログラミング言語は多次元配列をサポートするが、これらは必須ではない。ネストされた1次元配列により同じ効果を得ることが可能)。各種の配列は独自の入力構文をもちます。詳細は以降のセクションを参照してください。

配列型はシーケンス型のサブセットであり文字列型、ベクター型、ブールベクター型、文字テーブル型が含まれます。

2.4.8 文字列型

文字列(string)とは文字の配列です。Emacsがテキストエディターであることから予想できるように、文字列はたとえばLispシンボルの名前、ユーザーへのメッセージ、バッファーから抽出されたテキストの表現など多くの目的のために使用されます。Lispの文字列は定数です。文字列を評価すると、それと同じ文字列がリターンされます。

文字列を操作する関数については文字列と文字を参照してください。

2.4.8.1 文字列の構文

文字列にたいする入力構文は"like this"のようにダブルクォート、任意個数の文字、もう1つのダブルクォートから構成されます。文字列内にダブルクォートを含める場合は、それの前にバックスラッシュを記述します。したがって"\""は1つのダブルクォート文字だけを含む文字列です。同様にバックスラッシュを含める場合は、"this \\ is a single embedded backslash"のように、それの前にもう1つのバックスラッシュを記述します。

文字列とは文字の配列のことなので、文字の読み取り構文を用いて先頭のクエスチョンマークなしで文字列を指定できます。これは自分自身を意味しないような文字を文字列に含める際に役に立ちます。たとえばコントロール文字はバックスラッシュで始まるエスケープシーケンスで指定できるので、"foo\r"とすれば‘foo’の後にキャリッジリターンを指定できます。その他のコントロール文字のエスケープシーケンスについては基本的な文字構文を参照してください。同様に"foo\^Ibar"のようにタブ文字を生成する特別な読み取り構文を用いて、文字列内にコントロール文字を埋め込むことができます(コントロール文字構文を参照)。"\N{LATIN SMALL LETTER A WITH GRAVE}"や"\u00e0"のようにして、一般的なエスケープ構文で記したような非ASCII文字用のエスケープシーケンスを用いることもできます(ただし文字列内の非ASCII文字の非ASCII文字にたいする注意事項を参照のこと)。

文字列にたいする入力構文では、改行(newline)は特別ではありません。ダブルクォートの間に改行を記述すれば、その改行は文字列内の文字となります。しかしエスケープされた改行 — 前に‘\’をともなう改行 — は文字列の一部とはなりません。同様にエスケープされたスペース‘\ ’も無視されます。

"It is useful to include newlines
in documentation strings,
but the newline is \
ignored if escaped."
     ⇒ "It is useful to include newlines
in documentation strings,
but the newline is ignored if escaped."

2.4.8.2 文字列内の非ASCII文字

Emacsの文字列内の非ASCII文字にたいしては2つのテキスト表現 — マルチバイト(multibyte)とユニバイト(unibyte)があります(テキストの表現方法を参照)。大まかに言うとユニバイト文字列にはraw(生)バイトが保存され、マルチバイト文字列には人間が読めるテキストが保存されます。ユニバイト文字列内の各文字はバイトであり、値は0から255となります。対照的にマルチバイト文字列内の各文字は、0から4194303の値をもつかもしれません(文字型を参照)。いずれも127より上の文字は非ASCIIです。

文字をリテラルとして記述することにより、文字列に非ASCII文字を含めることができます。マルチバイトのバッファーや文字列、あるいはマルチバイトとしてvisitされたファイル等、マルチバイトのソースから文字列定数を読み込む場合、Emacsは非ASCII文字をマルチバイト文字として読み取り、その文字列を自動的にマルチバイト文字列にします。ユニバイトのソースから文字列定数を読み込む場合、Emacsは非ASCII文字をユニバイト文字として読み取り、その文字列をユニバイト文字列にします。

マルチバイト文字列内にリテラルとして文字を記述するかわりに、エスケープシーケンスを使用して文字コードとして記述できます。エスケープシーケンスについての詳細は、一般的なエスケープ構文を参照してください。

文字列定数内でUnicodeスタイルのエスケープシーケンス‘\uNNNN’または‘\U00NNNNNN’を使用する場合、(たとえASCII文字であっても)Emacsは自動的に文字列をマルチバイトとみなします。

文字列定数内で16進エスケープシーケンス(‘\xn’)と8進エスケープシーケンス(‘\n’)を使用することもできます。しかし注意してください: 文字列定数が8進のエスケープシーケンス、または1桁か2桁の16進エスケープシーケンスを含み、それらのエスケープシーケンスすべてがユニバイト文字(256より小)を指定していて、その文字列内に他にリテラルの非ASCII文字またはUnicodeスタイルのエスケープシーケンスが存在しない場合、Emacsは自動的に文字列をユニバイト文字列とみなします。つまり文字列内のすべての非ASCII文字は8ビットのrawバイトとみなされます。

16進および8進のエスケープシーケンスでは、エスケープされた文字コードに可変個の数字が含まれるかもしれないので、それに続く文字で16進および8進として有効ではない最初の文字は、そのエスケープシーケンスを終了させます。文字列内の次の文字が16進または8進として解釈できる文字の場合は、‘\ ’(バックスラッシュとスペース)を記述して、エスケープシーケンスを終了できます。たとえば‘\xe0\ ’はgrave accentつきの‘a’という1文字を表します。文字列内の‘\ ’はバックスラッシュ改行と同様です。これは文字列内の文字とはなりませんが、先行する16進エスケープを終了します。

2.4.8.3 文字列内の非プリント文字

リテラル文字と同様に、文字列定数内でバックスラッシュによるエスケープシーケンスを使用できます(ただし文字定数を開始するクエスチョンマークは使用しない)。たとえば非プリント文字のタブとC-aを含む文字列は、"\t, \C-a"のように、それらの間にカンマとスペースを記述します。文字にたいするさまざまな種類の入力構文については文字型とそのサブセクションを参照してください。

しかしバックスラッシュによるエスケープシーケンスとともに記述できるすべての文字が、文字列内で有効というわけではありません。文字列が保持できるコントロール文字はASCIIコントロール文字だけです。ASCIIコントロール文字では、文字列のcaseは区別されません。

正確に言うと、文字列はメタ文字を保持できません。しかし文字列がキーシーケンスとして使用される場合には、文字列内でメタ修飾されたASCII文字を表現するための方法を提供する特別な慣習があります。文字列定数内でメタ文字を示すために‘\M-’構文を使用した場合、これは文字列内の文字の 2**7 のビットをセットします。その文字列がdefine-keyまたはlookup-keyで使用される場合、この数字コードは等価なメタ文字に変換されます。文字型を参照してください。

文字列はハイパー(hyper)、スーパー(super)、アルト(alt)で修飾された文字を保持できません。

2.4.8.4 文字列内のテキストプロパティ

文字列にはその文字自身に加えて、文字のプロパティも保持することができます。これにより特別なことをしなくても、文字列とバッファーとの間でテキストをコピーするプログラムが、テキストプロパティをコピーすることが可能になります。テキストプロパティが何を意味するかについてはテキストのプロパティを参照してください。テキストプロパティをもつ文字列は、特別な入力構文とプリント構文を使用します。

#("characters" property-data...)

ここでproperty-dataは,3個でグループ化された0個以上の要素から構成されます:

beg end plist

要素begおよびendは整数で、文字列内のインデックスの範囲を指定します。plistはその範囲にたいするプロパティリストです。たとえば、

#("foo bar" 0 3 (face bold) 3 4 nil 4 7 (face italic))

これはテキスト内容が‘foo bar’で、最初の3文字はfaceプロパティに値boldをもち、最後の3文字はfaceプロパティに値italicをもつことを表します(4番目の文字にはテキストプロパティはないので、プロパティリストはnil。実際には範囲の中の指定されていない文字はデフォルトではプロパティをもたないので、範囲のプロパティリストをnilと指定する必要ない)。

2.4.9 ベクター型

ベクター(vector)は任意の型の要素からなる1次元の配列です。ベクター内の任意の要素へのアクセスに要す時間は一定です(リストの場合では要素へのアクセスに要す時間は、リストの先頭からその要素までの距離に比例する)。

ベクターのプリント表現は左角カッコ(left square bracket)、要素、右角カッコ(right square bracket)から構成されます。これは入力構文でもあります。数字や文字列と同様にベクターは評価において定数と判断されます。

[1 "two" (three)]      ; 3要素のベクター
     ⇒ [1 "two" (three)]

ベクターに作用する関数についてはベクターを参照してください。

2.4.10 文字テーブル型

文字テーブル(char-table)は任意の型の要素をもつ1次元の配列であり、文字コードによりインデックスづけされます。文字テーブルは、文字コードに情報を割り当てることを必要とする多くの処理を簡単にするための、特別な追加の機能をもちます — たとえば文字テーブルは継承する親、デフォルト値、特別な目的のために使用する余分なスロットをいくつかもつことができます。文字テーブルは文字セット全体にたいして1つの値を指定することもできます。

文字テーブルのプリント表現はベクターと似ていますが、最初に余分な‘#^’があります¹。

文字テーブルを操作する特別な関数については文字テーブルを参照してください。文字テーブルの使用には以下が含まれます:

caseテーブル(caseテーブルを参照)。
文字カテゴリーテーブル(カテゴリーを参照)。
ディスプレイテーブル(ディスプレイテーブルを参照)。
構文テーブル(構文テーブルを参照)。

2.4.11 ブールベクター型

ブールベクター(bool-vector)は、要素がtかnilのいずれかでなければならない1次元の配列です。

ブールベクターのプリント表現は文字列と似ていますが、後に長さを記述した‘#&’で始まります。これに続く文字列定数は、ビットマップとして実際に内容を指定するブールベクターです — 文字列定数内のそれぞれの“文字”は8ビットを含み、これはブールベクターの次の8要素を指定します(1はt、0はnilです)。文字の最下位ビットが、ブールベクターの最下位のインデックスに対応しています。

(make-bool-vector 3 t)
     ⇒ #&3"^G"
(make-bool-vector 3 nil)
     ⇒ #&3"^@"

‘C-g’の2進コードは111、‘C-@’はコード0の文字なのでこの結果は理にかなっています。

長さが8の倍数でなければプリント表現には余分な要素が表示されますが、これらの余分な要素に意味はありません。たとえば以下の例では、最初の3ビットだけが使用されるので2つのブールベクターは等価です:

(equal #&3"\377" #&3"\007")
     ⇒ t

2.4.12 ハッシュテーブル型

ハッシュテーブルは非常に高速な照合テーブルの一種で、キーを対応する値にマップするalistと似ていますがより高速です。ハッシュテーブルのプリント表現では、以下のようにハッシュテーブルのプロパティと内容を指定します:

(make-hash-table)
     ⇒ #s(hash-table size 65 test eql rehash-size 1.5
                             rehash-threshold 0.8125 data ())

ハッシュテーブルについての詳細はハッシュテーブルを参照してください。

2.4.13 関数型

他のプログラミング言語の関数と同様、Lisp関数は実行可能なコードです。他の言語と異なり、Lispの関数はLispオブジェクトでもあります。Lispのコンパイルされていない関数はラムダ式 — つまり1番目の要素がシンボルlambdaであるリストです(ラムダ式を参照)。

ほとんどのプログラミング言語では名前のない関数はありません。Lispでは関数に本質的な名前はありません。名前がなくてもラムダ式を関数として呼び出すことができます。これを強調するために、わたしたちはこれを無名関数(anonymous function)とも呼びます(無名関数を参照)。Lispの名前つき関数は関数セルに有効な関数がセットされた単なるシンボルです(関数の定義を参照)。

ほとんどの場合、関数はLispプログラム内のLisp式の名前が記述されたところで呼び出されます。しかし実行時に関数オブジェクトを構築または取得してから、プリミティブ関数funcallおよびapplyにより呼び出すことができます。関数の呼び出しを参照してください。

2.4.14 マクロ型

Lispマクロ(Lisp macro)はLisp言語を拡張するユーザー定義の構成です。これはオブジェクトとしてではなく関数のように表現されますが、引数の渡し方の意味が異なります。Lispマクロの形式はリストです。これは最初の要素がmacroで、CDRがLisp関数オブジェクト(lambdaシンボルを含む)であるようなリストです。

Lispマクロオブジェクトは通常、ビルトインのdefmacro関数で定義されますが、macroで始まる任意のリストもEmacsにとってはマクロです。マクロを記述する方法の説明はマクロを参照してください。

警告: Lispマクロとキーボードマクロ(キーボードマクロを参照)は完全に別の物である。修飾なしで“マクロ”という単語を使用したときは、キーボードマクロではなくLispマクロのことを指す。

2.4.15 プリミティブ関数型

プリミティブ関数(primitive function)とは、Cプログラミング言語で記述されたLispから呼び出せる関数です。プリミティブ関数はsubrsやビルトイン関数(built-in functions)とも呼ばれます(単語“subr”は“サブルーチン(subroutine)”が由来)。ほとんどのプリミティブ関数は、呼び出されたときにすべての引数を評価します。すべての引数を評価しないプリミティブ関数はスペシャルフォーム(special form)と呼ばれます(スペシャルフォームを参照)。

呼び出す側からすれば、その関数がプリミティブ関数かどうかは問題になりません。しかしプリミティブ関数をLispで記述された関数で再定義した場合に問題になります。理由はそのプリミティブ関数がCコードから直接呼び出されているかもしれないからです。Lispから再定義した関数を呼び出すと新しい定義を使用するでしょうが、Cコードから呼び出すとビルトインの定義が使用されるでしょう。したがって、プリミティブ関数の再定義はしないでください。

関数(function)という用語で、LispやCで記述されたすべてのEmacs関数を参照します。Lispで記述された関数についての情報は関数型を参照してください。

プリミティブ関数に入力構文はなく、サブルーチン名とともにハッシュ表記でプリントします。

(symbol-function 'car)          ; そのシンボルの関数セルに
                                ;     アクセスする
     ⇒ #<subr car>
(subrp (symbol-function 'car))  ; これはプリミティブ関数?
     ⇒ t                ;    そのとおり

2.4.16 バイトコード関数型

バイトコード関数オブジェクト(byte-code function objects)は、Lispコードをバイトコンパイルすることにより生成されます(バイトコンパイルを参照)。バイトコード関数オブジェクトは、内部的にはベクターによく似ています。しかしバイトコード関数オブジェクトが関数呼び出しのように見える場合、評価プロセスによりこのデータ型は特別に処理されます。バイトコード関数オブジェクトを参照してください。

バイトコード関数オブジェクトのプリント表現と入力構文はベクターのものと似ていますが、開き角カッコ‘[’の前に‘#’があります。

2.4.17 レコード型

レコード(record)はvectorと似ていますが、最初の要素はtype-ofでリターンされる型を保持するために使用されます。レコードの主要目的はプログラマーがEmacsのビルトインではない新たな型を作成することを可能にすることです。

レコードに作用する関数についてはレコードを参照してください。

2.4.18 型記述子

型記述子(type descriptor)は型に関する情報を保持するrecordです。レコードの1スロット目には型を命名するシンボルでなければならず、type-ofはrecordオブジェクトの型をリターンするためにこれに依存しています。他の型記述子スロットをEmacsは使用しません。これらをLisp拡張が使用するのは自由です。

cl-structure-classのインスタンスはすべて型記述子の例です。

2.4.19 autoload型

autoloadオブジェクト(autoload object)は、最初の要素がシンボルautoloadのリストです。これはシンボルの関数定義として保存され、実際の定義にたいする代替としての役割をもちます。autoloadオブジェクトは、必要な時にロードされるLispコードファイルの中で実際の定義を見つけることができることを宣言します。これにはファイル名と、それに加えて実際の定義についての他のいくつかの情報が含まれます。

ファイルのロード後、そのシンボルはautoloadオブジェクトではない新しい関数定義をもつはずです。新しい定義は、最初からそこにあったかのように呼び出されます。ユーザーの観点からは関数呼び出しは期待された動作、つまりロードされたファイル内の関数定義を使用します。

autoloadオブジェクトは通常、シンボルの関数セルにオブジェクトを保存する関数autoloadにより作成されます。詳細はautoloadを参照してください。

2.4.20 ファイナライザー型

ファイナライザーオブジェクト(finalizer object)は、オブジェクトがもはや必要なくなった後のLispコードのクリーンアップを助けます。ファイナライザーは、Lisp関数オブジェクトを保持します。ガーベージコレクションをパス(通過)した後にファイナライザーオブジェクトが到達不能になったとき、Emacsはそのファイナライザーに関連付けられた関数オブジェクトを呼び出します。ファイナライザーの到達可否の判定時、もしかしてファイナライザーオブジェクト自身が参照を離さないのではないかと心配することなくファイナライザーを使用できるように、Emacsはファイナラーオブジェト自身からの参照は勘定しません。

ファイナラーザー内でのエラーは*Messages*にプリントされます。その関数が失敗しても、Emacsは与えられたファイナライザーオブジェクトに関連付けられた関数を正確に1回実行します。

Function: make-finalizer function ¶: functionを実行するファイナライザーを作成する。functionはガーベージコレクション後、リターンされたファイナライザーオブジェクトが到達不能になったときに実行される。そのファイナライザーオブジェクトがファイナライザーオブジェクトからの参照を通じてのみ到達可能なら、functionの実行是非の判断時の目的にたいして、それは到達可能とみなされない。functionはファイナライザーオブジェクトごとに1回実行される。

2.5 編集用の型

前セクションの型は一般的なプログラミング目的のために使用され、これらの型のほとんどはLisp方言のほとんどで一般的です。Emacs Lispは編集に関する目的のために、いくつかの追加のデータ型を提供します。

2.5.1 バッファー型		編集のための基本オブジェクト。
2.5.2 マーカー型		バッファー内の位置。
2.5.3 ウィンドウ型		バッファーはウィンドウ内に表示される。
2.5.4 フレーム型		ウィンドウはフレームを細分化する。
2.5.5 端末型		フレームを表示する端末デバイス。
2.5.6 ウィンドウ構成型		フレームが細分化された方法を記録する。
2.5.7 フレーム構成型		すべてのフレームの状態を記録する。
2.5.8 プロセス型		背後のOS上で実行されるEmacsのサブプロセス。
2.5.9 スレッド型		Emacs Lispの実行スレッド。
2.5.10 ミューテックス型		スレッド同期のための排他ロック。
2.5.11 状態変数型		スレッド同期のための状態変数。
2.5.12 ストリーム型		文字の受信と送信。
2.5.13 キーマップ型		どのキーストロークがどの関数を呼び出すか。
2.5.14 オーバーレイ型		オーバーレイが表示される方法。
2.5.15 フォント型		テキストを表示するフォント。
2.5.16 Xwidget型		埋め込み可能なウィジェット。

2.5.1 バッファー型

バッファー(buffer)とは、編集されるテキストを保持するオブジェクトです(バッファーを参照)。ほとんどのバッファーはディスクファイル(ファイルを参照)の内容を保持するので編集できますが、他の目的のために使用されるものもいくつかあります。ほとんどのバッファーはユーザーにより閲覧されることも意図しているので、いつかはウィンドウ内(ウィンドウを参照)に表示されます。しかしバッファーはウィンドウに表示される必要はありません。バッファーはそれぞれ、ポイント(point)と呼ばれる位置指定をもちます(ポジションを参照)。ほとんどの編集コマンドは、カレントバッファー内のポイントに隣接する内容を処理します。常に1つのバッファーがカレントバッファー(current buffer)です。

バッファーの内容は文字列によく似ていますが、バッファーはEmacs Lispの文字列と同じようには使用されず、利用可能な操作は異なります。たとえば文字列にテキストを挿入するためには部分文字列の結合が必要であり、結果が完全に新しい文字列オブジェクトになるのにたいして。バッファーでは既存のバッファーに効率的にテキストを挿入してバッファーの内容を変更できます。

標準的なEmacs関数の多くは、カレントバッファー内の文字を操作したりテストするためのものです。このマニュアルはこれらの関数の説明のために、1つのチャプターを設けています(テキストを参照)。

他のデータ構造のいくつかは、各バッファーに関連付けられています:

ローカル構文テーブル(構文テーブルを参照)。
ローカルキーマップ(キーマップを参照)。
バッファーローカルな変数バインディングのリスト(バッファーローカル変数を参照)。
オーバーレイ(オーバーレイを参照)。
バッファー内のテキストにたいするテキストプロパティ(テキストのプロパティを参照)。

ローカルキーマップと変数リストは、グローバルなバインディングや値を個別にオーバーライドするためのエントリーを含みます。これらは実際にプログラムを変更することなく、異なるバッファーでプログラムの振る舞いをカスタマイズするために使用されます。

バッファーはインダイレクト(indirect: 間接) — つまり他のバッファーとテキストを共有するがそれぞれ別に表示する — かもしれません。インダイレクトバッファーを参照してください。

バッファーに入力構文はありません。バッファーはバッファー名を含むハッシュ表記でプリントされます。

(current-buffer)
     ⇒ #<buffer objects-ja.texi>

2.5.2 マーカー型

マーカー(marker)は特定のバッファー内の位置を表します。したがってマーカーには2つの内容 — 1つはバッファー、もう1つは位置 — をもちます。バッファーのテキストの変更では、マーカーが常にバッファー内の同じ2つの文字の間に位置することを確実にするために、必要に応じて自動的に位置の値が再配置されます。

マーカーは入力構文をもちません。マーカーはカレントの文字位置とそのバッファー名を与える、ハッシュ表記でプリントされます。

(point-marker)
     ⇒ #<marker at 10779 in objects-ja.texi>

マーカーのテスト、作成、コピー、移動の方法についての情報はマーカーを参照してください。

2.5.3 ウィンドウ型

ウィンドウ(window)はEmacsがバッファーを表示するために使用するスクリーンの範囲を記述します。すべての生きたウィンドウ(Emacsウィンドウの基本概念を参照)には関連付けられた1つのバッファーがあり、バッファーの内容はそのウィンドウに表示されます。それとは対照的に、あるバッファーは1つのウィンドウに表示されるか表示されないか、それとも複数のウィンドウに表示されるかもしれません。ウィンドウはスクリーン上でフレームにグループ化されます。それらのウィンドウはただ1つのフレームに属します。フレーム型を参照してください。

同時に複数のウィンドウが存在するかもしれませんが、常に1つのウィンドウが選択されたウィンドウ(selected window)になります(ウィンドウの選択を参照)。Emacsがコマンドにたいして準備できているときは、(通常は)カーソルが表示されるウィンドウが選択されたウィンドウです。選択されたウィンドウは、通常はカレントバッファー(カレントバッファーを参照)を表示しますがこれは必須ではありません。

ウィンドウは入力構文をもちません。ウィンドウはウィンドウ番号と表示されているバッファー名を与える、ハッシュ表記でプリントされます。与えられたウィンドウに表示されるバッファーは頻繁に変更されるかもしれないので、一意にウィンドウを識別するためにウィンドウ番号が存在します。

(selected-window)
     ⇒ #<window 1 on objects-ja.texi>

ウィンドウに作用する関数の説明はウィンドウを参照してください。

2.5.4 フレーム型

フレーム(frame)とは１つ以上のEmacsウィンドウを含むスクリーン領域です。スクリーン領域を参照するためにEmacsが使用するLispオブジェクトを指す場合にも“フレーム”という用語を使用します。

フレームは入力構文をもちません。フレームはフレームのタイトルとメモリー内のアドレス(フレームを一意に識別するのに有用)を与えるハッシュ表記でプリントされます。

(selected-frame)
     ⇒ #<frame emacs@psilocin.gnu.org 0xdac80>

フレームに作用する関数の説明はフレームを参照してください。

2.5.5 端末型

端末(terminal)は1つ以上のEmacsフレーム(フレーム型を参照)を表示する能力があるデバイスです。

端末は入力構文をもちません。端末はその端末の順序番号とTTYデバイスファイル名を与える、ハッシュ表記でプリントされます。

(get-device-terminal nil)
     ⇒ #<terminal 1 on /dev/tty>

2.5.6 ウィンドウ構成型

ウィンドウ構成(window configuration)はフレーム内のウィンドウの位置とサイズ、内容についての情報を保持します。これにより後で同じウィンドウ配置を再作成できます。

ウィンドウ構成は入力構文をもちません。ウィンドウ構成のプリント表現は‘#<window-configuration>’のようになります。ウィンドウ構成に関連するいくつかの関数の説明はウィンドウの構成を参照してください。

2.5.7 フレーム構成型

フレーム構成(frame configuration)はすべてのフレーム内のウィンドウの位置とサイズ、内容についての情報を保持します。これは基本型ではありません — 実際のところ、これはCARがframe-configurationでCDRがalistであるようなリストです。それぞれのalist要素は、その要素のCARに示される1つのフレームを記述します。

フレーム構成に関連するいくつかの関数の説明はフレーム構成を参照してください。

2.5.8 プロセス型

プロセス(process)という単語は、通常は実行中のプログラムを意味します。Emacs自身はこの種のプロセス内で実行されます。しかしEmacs Lispでは、プロセスとはEmacsプロセスにより作成されたサブプロセスを表すLispオブジェクトです。シェル、GDB、ftp、コンパイラーなどのプログラムは、Emacsのサブプロセスとして実行されEmacsの能力を拡張します。さらに操作を行なうために、EmacsサブプロセスはEmacsからテキスト入力を受け取り、テキスト出力をEmacsにリターンします。Emacsがサブプロセスにシグナルを送ることもできます。

プロセスオブジェクトは入力構文をもちません。プロセスオブジェクトはプロセス名を与えるハッシュ表記でプリントされます。

(process-list)
     ⇒ (#<process shell>)

プロセスの作成、削除、プロセスに関する情報のリターン、入力やシグナルの送信、出力の受信を行なう関数についての情報はプロセスを参照してください。

2.5.9 スレッド型

Emacsでのスレッド(thread)とはEmacs Lispの実行スレッドとは別のスレッドを表します。これは自身のLispプログラムを実行して、自身のカレントバッファーを所有して、そのスレッドにロックされたサブプロセスをもつことができます(サブプロセスの出力を受け取ることができるのはそのスレッドのみ)。スレッドを参照してください。

スレッドオブジェクトは入力構文をもちません。スレッドオブジェクトは(名前を与えられていれば)スレッド名を与えるハッシュ表記かメモリー内のアドレスでプリントされます。

(all-threads)
    ⇒ (#<thread 0176fc40>)

2.5.10 ミューテックス型

ミューテックス(mutex)とはスレッド間で同期をとるためにスレッドが所有と非所有することができる排他ロックです。ミューテックスを参照してください。

ミューテックスオブジェクトは入力構文をもちません。プロセスオブジェクトは(名前を与えられていれば)ミューテックス名を与えるハッシュ表記かメモリー内のアドレスでプリントされます。

(make-mutex "my-mutex")
    ⇒ #<mutex my-mutex>
(make-mutex)
    ⇒ #<mutex 01c7e4e0>

2.5.11 状態変数型

状態変数(condition variable)はミューテックスがサポートするよりも複雑な非同期スレッドのためのデバイスです。スレッドは別のスレッドが状態を通知したときに再開するように状態変数を待機することができます。

状態変数オブジェクトは入力構文をもちません。プロセスオブジェクトは(名前が与えられていれば)状態変数の名前を与えるハッシュ表記かメモリー内のアドレスでプリントされます。

(make-condition-variable (make-mutex))
    ⇒ #<condvar 01c45ae8>

2.5.12 ストリーム型

ストリーム(stream)とは、文字のソースまたはシンクとして — つまり入力として文字を供給したり、出力として文字を受け入れるために使用できるオブジェクトです。多くの異なるタイプ — マーカー、バッファー、文字列、関数をこの方法で使用できます。ほとんどの場合、入力ストリーム(文字列ソース)はキーボード、バッファー、ファイルから文字を受け取り、出力ストリーム(文字シンク)は文字を*Help*バッファーのようなバッファーやエコーエリアに文字を送ります。

オブジェクトnilは、他の意味に加えてストリームとして使用されることがあります。nilは変数standard-inputやstandard-outputの値を表します。オブジェクトtも入力としてミニバッファー(ミニバッファーを参照)、出力としてエコーエリア(エコーエリアを参照)の使用を指定するストリームになります。

ストリームは特別なプリント表現や入力構文をもたず、それが何であれそれらの基本型としてプリントされます。

パース関数およびプリント関数を含む、ストリームに関連した関数の説明はLispオブジェクトの読み取りとプリントを参照してください。

2.5.13 キーマップ型

キーマップ(keymap)はユーザーがタイプした文字をコマンドにマップします。このマップはユーザーのコマンド入力が実行される方法を制御します。キーマップは、実際にはCARがシンボルkeymapであるようなリストです。

キーマップの作成、プレフィクスキーの処理、ローカルキーマップやグローバルキーマップ、キーバインドの変更についての情報はキーマップを参照してください。

2.5.14 オーバーレイ型

オーバーレイ(overlay)はバッファーの一部に適用するプロパティを指定します。それぞれのオーバーレイはバッファーの指定された範囲に適用され、プロパティリスト(プロパティ名と値が交互に記述された要素のリスト)を含みます。オーバーレイプロパティは、バッファーの指定された一部を、一時的に異なるスタイルで表示するために使用されます。オーバーレイは入力構文をもたず、バッファー名と範囲の位置を与えるハッシュ表記でプリントされます。

オーバーレイを作成したり使用する方法についての情報はオーバーレイを参照してください。

2.5.15 フォント型

fontはグラフィカルな端末上のテキストを表示する方法を指定します。実際には異なる3つのフォント型 — フォントオブジェクト(font objects)、フォントスペック(font specs)、フォントエンティティー(font entities) — が存在します。これらは入力構文をもちません。これらのプリント構文は‘#<font-object>’、‘#<font-spec>’、‘#<font-entity>’のようになります。これらのLispオブジェクトの説明は低レベルのフォント表現を参照してください。

2.5.16 Xwidget型

xwidgetとはバッファー内に埋め込みができる、ウェブブラウザのような特別な表示要素のことです。xwidgetを表示しているウィンドウはそれぞれ、xwidgetビュー(xwidget view)ももつことができます。Xウィンドウにおいては、ウィジェットの表示に使用される単一のウィンドウに相当するのがxwidgetビューです。

これらのオブジェクトはいずれも読み取りができません。プリント構文はそれぞれ‘#<xwidget>’、‘#<xwidget-view>’のようになります。xwidgetに関する詳細については埋め込みネイティブウィジェットを参照してください。

2.6 循環オブジェクトの読み取り構文

複雑なLispオブジェクトでの共有された構造や循環する構造を表すために、リーダー構成‘#n=’と‘#n#’を使用することができます。

後でオブジェクトを参照するには、オブジェクトの前で#n=を使用します。その後で、他の場所にある同じオブジェクトを参照するために、#n#を使用することができます。ここでnは任意の整数です。たとえば以下は、1番目の要素が3番目の要素にも繰り替えされるリストを作成する方法です:

(#1=(a) b #1#)

これは、以下のような通常の構文とは異なります

((a) b (a))

これは1番目の要素と3番目の要素がそっくりなリストですが、これらは同じLispオブジェクトではありません。以下で違いを見ることができます:

(prog1 nil
  (setq x '(#1=(a) b #1#)))
(eq (nth 0 x) (nth 2 x))
     ⇒ t
(setq x '((a) b (a)))
(eq (nth 0 x) (nth 2 x))
     ⇒ nil

“要素”として自身を含むような循環する構造を作成するために、同じ構文を使用できます。以下は例です:

#1=(a #1#)

これは2番目の要素がそのリスト自身であるリストを作成します。これが実際にうまくいくのか、以下で確認できます:

(prog1 nil
  (setq x '#1=(a #1#)))
(eq x (cadr x))
     ⇒ t

変数print-circleを非nil値にバインドした場合、Lispプリンターは、循環および共有されるLispオブジェクトを記録するこの構文を生成することができます。出力に影響する変数を参照してください。

2.7 型のための述語

関数が呼び出されたとき、Emacs Lispインタープリター自身はその関数に渡された実際の引数の型チェックは行ないません。それが行なえないのは、Lispにおける関数の引数は他のプログラミング言語のようなデータ型宣言をもたないからです。したがって実際の引数が、その関数が使用できる型に属するかどうかをテストするのは、それぞれの関数に任されています。

すべてのビルトイン関数は適切なときに実際の引数の型チェックを行い、引数の型が違う場合はwrong-type-argumentエラーをシグナルします。たとえば以下は、+の引数に+が扱うことができない引数を渡したとき何が起こるかの例です:

(+ 2 'a)
     error→ Wrong type argument: number-or-marker-p, a

異なる型にたいして異なる処理をプログラムに行なわせる場合は、明示的に型チェックを行なわなければなりません。オブジェクトの型をチェックするもっとも一般的な方法は型述語(type predicate)関数の呼び出しです。Emacsはそれぞれの型にたいする型述語をもち、組み合わされた型にたいする述語もあります。

型述語関数は1つの引数をとり、その引数が適切な型であればt、そうでなければnilをリターンします。述語関数にたいする一般的なLisp慣習にしたがい、ほとんどの型述語の名前は‘p’で終わります。

以下はリストにたいしてチェックを行なう述語listpと、シンボルにたいしてチェックを行なう述語symbolpの例です。

(defun add-on (x)
  (cond ((symbolp x)
         ;; XがシンボルならLISTにputする
         (setq list (cons x list)))
        ((listp x)
         ;; Xがリストならその要素をLISTに追加
         (setq list (append x list)))
        (t
         ;; シンボルとリストだけを処理する
         (error "Invalid argument %s in add-on" x))))

以下のテーブルは事前定義された型述語(アルファベット順)と、さらに情報を得るためのリファレンスです。

atom: atomを参照のこと。
arrayp: arraypを参照のこと。
bignump: floatpを参照のこと。
bool-vector-p: bool-vector-pを参照のこと。
booleanp: booleanpを参照のこと。
bufferp: bufferpを参照のこと。
byte-code-function-p: byte-code-function-pを参照のこと。
compiled-function-p: compiled-function-pを参照のこと。
case-table-p: case-table-pを参照のこと。
char-or-string-p: char-or-string-pを参照のこと。
char-table-p: char-table-pを参照のこと。
commandp: commandpを参照のこと。
condition-variable-p: condition-variable-pを参照のこと。
consp: conspを参照のこと。
custom-variable-p: custom-variable-pを参照のこと。
fixnump: floatpを参照のこと。
floatp: floatpを参照のこと。
fontp: 低レベルのフォント表現を参照のこと。
frame-configuration-p: frame-configuration-pを参照のこと。
frame-live-p: frame-live-pを参照のこと。
framep: framepを参照のこと。
functionp: functionpを参照のこと。
hash-table-p: hash-table-pを参照のこと。
integer-or-marker-p: integer-or-marker-pを参照のこと。
integerp: integerpを参照のこと。
keymapp: keymappを参照のこと。
keywordp: 変更不可な変数を参照のこと。
listp: listpを参照のこと。
markerp: markerpを参照のこと。
mutexp: mutexpを参照のこと。
nlistp: nlistpを参照のこと。
number-or-marker-p: number-or-marker-pを参照のこと。
numberp: numberpを参照のこと。
overlayp: overlaypを参照のこと。
processp: processpを参照のこと。
recordp: recordpを参照のこと。
sequencep: sequencepを参照のこと。
string-or-null-p: string-or-null-pを参照のこと。
stringp: stringpを参照のこと。
subrp: subrpを参照のこと。
symbolp: symbolpを参照のこと。
syntax-table-p: syntax-table-pを参照のこと。
threadp: threadpを参照のこと。
vectorp: vectorpを参照のこと。
wholenump: wholenumpを参照のこと。
window-configuration-p: window-configuration-pを参照のこと。
window-live-p: window-live-pを参照のこと。
windowp: windowpを参照のこと。

あるオブジェクトがどの型かチェックするもっとも一般的な方法は、関数type-ofの呼び出しです。オブジェクトは、ただ1つだけの基本型に属することを思い出してください。type-ofは、それがどの型かを告げます(Lispのデータ型を参照)。しかしtype-ofは基本型以外の型については何も知りません。ほとんどの場合では、type-ofより型述語を使用するほうが便利でしょう。

Function: type-of object ¶

この関数はobjectの基本型を名前とするシンボルをリターンする。リターン値はシンボルbool-vector、buffer、char-table、compiled-function、condition-variable、cons、finalizer、float、font-entity、font-object、font-spec、frame、hash-table、integer、marker、mutex、overlay、process、string、subr、symbol、thread、vector、window、window-configurationのいずれか。ただしobjectがレコードなら最初のスロットで指定された型をリターンする。レコードを参照のこと。

(type-of 1)
     ⇒ integer

(type-of 'nil)
     ⇒ symbol
(type-of '())    ; ()はnil
     ⇒ symbol
(type-of '(x))
     ⇒ cons
(type-of (record 'foo))
     ⇒ foo

2.8 同等性のための述語

ここでは2つのオブジェクトの同一性をテストする関数を説明します。(たとえば文字列などの)特定の型のオブジェクト同士で内容の同一性をテストするには、別の関数を使用します。これらの述語にたいしては、そのデータ型を説明する適切なチャプターを参照してください。

Function: eq object1 object2 ¶

この関数はobject1とobject2が同じオブジェクトならt、それ以外はnilをリターンする。

object1とobject2が同じ名前をもつシンボルなら、通常は同じオブジェクトだが例外もある。シンボルの作成とinternを参照のこと。他の非数値型(リストやベクター、文字列などの)にたいしては、同じ内容(または要素)の2つの引数が両者eqである必要はない。これらが同じオブジェクトの場合だけeqであり、その場合には一方の内容を変更するともう一方の内容にも同じ変更が反映される。

object1とobject2が異なるタイプや値をもつ数値なら同じオブジェクトではなく、eqはnilをリターンする。同じ値をもつfixnumなら同じオブジェクトであり、eqはtをリターンする。別個に計算されてたまたま同じ値をもち、かつ非fixnumタイプの同じ数値型なら、それらは同じかもしれないし違うかもしれず、Lispインタープリターが作成したオブジェクトが1つか2つかに依存してeqはtかnilをリターンする。

(eq 'foo 'foo)
     ⇒ t

(eq ?A ?A)
     ⇒ t

(eq 3.0 3.0)
     ⇒ t または nil
;; 浮動小数にたいするeqではオブジェクト同じかもしれず違うかもしれない

(eq (make-string 3 ?A) (make-string 3 ?A))
     ⇒ nil

(eq "asdf" "asdf")
     ⇒ t または nil
;; 文字列コンテンツにたいするeqではオブジェクト同じかもしれず違うかもしれない

(eq '(1 (2 (3))) '(1 (2 (3))))
     ⇒ nil

(setq foo '(1 (2 (3))))
     ⇒ (1 (2 (3)))
(eq foo foo)
     ⇒ t
(eq foo '(1 (2 (3))))
     ⇒ nil

(eq [(1 2) 3] [(1 2) 3])
     ⇒ nil

(eq (point-marker) (point-marker))
     ⇒ nil

make-symbol関数はinternされていないシンボルをリターンする。これはLisp式内でその名前を記述したシンボルとは区別される。同じ名前の異なるシンボルはeqではない。シンボルの作成とinternを参照のこと。

(eq (make-symbol "foo") 'foo)
     ⇒ nil

Emacs Lispバイトコンパイラーはリテラル文字列のような等価なリテラルオブジェクトを同一オブジェクトにたいする参照に落し込む(collapse into)かもしれない。バイトコンパイルされたコードはそのようなオブジェクトをeqで比較するだろうが、そうでないコードは異なるという効果がある。したがってコードではオブジェクトのリテラルコンテンツがeqか否かではなく、以下に説明するequalのような関数でオブジェクトの関数を使用すること。同様にコードではリテラルオブジェクトを変更(たとえばリテラル文字列へのテキストプロパティのput)しないこと。バイトコンパイラーがそれらの落し込みを行っていたら、同一コンテンツをもつ別のリテラルオブジェクトに影響があるかもしれない。

Function: equal object1 object2 ¶

この関数はobject1とobject2が同じ構成要素をもつならt、それ以外はnilをリターンする。eqが引数が同じオブジェクトなのかテストするのにたいして、equalは同一でない引数の内部を調べて、それらの要素または内容が同一化をテストする。したがって2つのオブジェクトがeqならばそれらはequalだが、その逆は常に真ではない。

(equal 'foo 'foo)
     ⇒ t

(equal 456 456)
     ⇒ t

(equal "asdf" "asdf")
     ⇒ t

(eq "asdf" "asdf")
     ⇒ nil

(equal '(1 (2 (3))) '(1 (2 (3))))
     ⇒ t

(eq '(1 (2 (3))) '(1 (2 (3))))
     ⇒ nil

(equal [(1 2) 3] [(1 2) 3])
     ⇒ t

(eq [(1 2) 3] [(1 2) 3])
     ⇒ nil

(equal (point-marker) (point-marker))
     ⇒ t

(eq (point-marker) (point-marker))
     ⇒ nil

文字列の比較はcaseを区別するがテキストプロパティは考慮しない — これは文字列内の文字だけを比較する。テキストのプロパティを参照のこと。テキストプロパティも比較する場合には、equal-including-propertiesを使用すること。技術的な理由によりユニバイト文字列とマルチバイト文字列は、それらが同じ文字コードのシーケンスを含み、それらのコードがすべて0から127(ASCII)の場合に限りequalとなる(テキストの表現方法を参照)。

(equal "asdf" "ASDF")
     ⇒ nil

equal関数はオブジェクトが整数、文字列、マーカー、ベクター、ブールベクター、バイトコード関数オブジェクト、文字テーブル、レコード、フォントオブジェクトなら、それらのコンテンツを再帰的に比較する。その他のオブジェクトは、それらがeqの場合のみequalとみなされる。たとえば個別の2つのバッファーは、たとえバッファーのテキスト的なコンテンツが同一であってもequalとみなされることはない。

equalでは等価性は再帰的に定義されています。たとえば2つのコンスセルxとyを与えると、(equal x y)は、以下の式の両方がtをリターンする場合だけtをリターンします:

(equal (car x) (car y))
(equal (cdr x) (cdr y))

したがって循環リストの比較はエラーとなるような深い再帰を引き起こすかもしれず、(equal a b)はtをリターンするにも関わらず(equal b a)はエラーをシグナルするといった直感に反する結果となることがあります。

Function: equal-including-properties object1 object2 ¶

この関数はすべてのケースにおいてequalと同様に振る舞うが、2つの文字列がequalになるためには、それらが同じテキストプロパティをもつ必要がある。

(equal "asdf" (propertize "asdf" 'asdf t))
     ⇒ t

(equal-including-properties "asdf"
                            (propertize "asdf" 'asdf t))
     ⇒ nil

2.9 可変性

変更されるべきではないLispオブジェクトがいくつかあります。たとえばLisp式"aaa"では文字列を生成しますが、そのコンテンツを変更するべきではありません。いくつかのオブジェクトは変更できません。たとえばある数値を計算して新たな数値を作成できたとしても、Lispは既存の数値を変更する操作を提供しません。

その他のLispオブジェクトはmutable(可変)オブジェクトで、副作用をともなう破壊的な操作を通じて値を変更しても安全です。たとえばマーカーを別のポイントを指すマーカーに移動することにより、既存のマーカーを変更することができます。

数値は変更不可でマーカーはすべてmutableだとしても、mutableと非mutableのメンバーをもつタイプがいくつかあります。これらのタイプにはコンス、ベクター、文字列が含まれます。たとえば"cons"と(symbol-name 'cons)は変更するべきではない文字列を生成しますが、(copy-sequence "cons")と(make-string 3 ?a)は後からasetを呼び出すことを通じて変更可能なmutable文字列を生成します。

mutableオブジェクトは評価される式の一部となったときにmutableであることを止めます。たとえば:

(let* ((x (list 0.5))
       (y (eval (list 'quote x))))
  (setcar x 1.5) ;; プログラムはこれを行うべきではない
  y)

作成時にリスト(0.5)がmutableでも、それはevalに与えられたのでsetcarを通じて変更するべきではありません。変更するべきではないオブジェクトが後からmutableになることは決してないので逆はあり得ません。

変更するべきではないオブジェクトの変更をプログラムが試みた際の動作は未定義です。Lispインタープリターがエラーをシグナルするかもしれず、クラッシュしたり他の方法で予測不能な振る舞いを引き起こすかもしれません²。

プログラムの一部として類似した定数が出現する際には、既存の定数やそのコンポーネントの再利用によってLispが時間やスペースを節約できるかもしれません。たとえば(eq "abc" "abc")はインタープリターが文字列リテラル"abc"の1つのインスタンスを作成したらt、2つのインスタンスを作成したらnilをリターンします。したがってこの最適化使用の有無に関わらず機能するようにLispプログラムを記述する必要があります。

3 数値

GNU Emacsは2つの数値データ型 — 整数(integers)と浮動小数点数(floating-point numbers)をサポートします。整数は-3、0、7、13、511などの整数です。浮動小数点数は-4.5、0.0、2.71828などの小数部をもちます。これらは指数記数法でも表現できます — ‘1.5e2’は‘150.0’と同じです。ここで‘e2’は10の2乗を表し、それに1.5を乗じるという意味です。整数計算は正確です。浮動小数点数の計算では数値は固定された精度をもつので、しばしば丸め誤差(rounding errors)が発生します。

3.1 整数の基礎		整数の表現と範囲。
3.2 浮動小数点数の基礎		浮動小数の表現と範囲。
3.3 数値のための述語		数にたいするテスト。
3.4 数値の比較		同一性と非同一性の述語。
3.5 数値の変換		浮動小数点数から整数の変換と逆変換。
3.6 算術演算		加減乗除の方法。
3.7 丸め処理		浮動小数点数の明示的な丸め。
3.8 整数にたいするビット演算		論理的なand、or、not、shift。
3.9 標準的な数学関数		三角関数、指数、対数関数。
3.10 乱数		予測可能または不可能な乱数の取得。

3.1 整数の基礎

Lispリーダーは、10進数字のシーケンス(オプションで最初の符号記号と最後のピリオドをともなう)として整数を読み取ります。

 1               ; 整数1
 1.              ; 整数1
+1               ; これも整数1
-1               ; 整数-1
 0               ; 整数0
-0               ; 整数0

10以外の基数をもつ整数の構文は‘#’、基数表示(radix indication)、その後の1つ以上の数字から構成されます。基数表示は2進数(binary)は‘b’、8進数(octal)は‘o’、16進数(hex)は‘x’、基数radixにたいしては‘radixr’になります。したがって‘#binteger’は2進数、‘#radixrinteger’は基数radixでintegerを読み取ります。radixの値として可能な値は2から36であり、最初のradix文字は‘0’–‘9’および‘A’–‘Z’から採択されます。英文字のcase(大文字小文字)は無視されて、最初の符号と最後のピリオドはありません。たとえば:

#b101100 ⇒ 44
#o54 ⇒ 44
#x2c ⇒ 44
#24r1k ⇒ 44

整数にたいして処理を行なうさまざまな関数、特にビット演算(整数にたいするビット演算を参照)を理解するためには、数を2進形式で見ることが助けになることがよくあります。

10進整数の5は2進数では以下のようになります:

…000101

(省略記号‘…’は概念的に先頭ビットにマッチする無限個数のビットを意味する。ここでは無限個の0ビット。後の例でも‘…’表記を使用する。)

整数の-1は以下のようになります:

…111111

-1はすべて1で表現されます(2の補数表記と呼ばれる)。

-1から4を減じることで負の整数-5が得られます。10進の整数4は2進では100です。したがって-5は以下のようになります:

…111011

このチャプターで説明する多くの関数は、数字の位置として引数にマーカー(マーカーを参照)を受け取ります。そのような関数にたいする実際の引数は数字かマーカーなので、わたしたちはこれらの引数にnumber-or-markerという名前を与えることがあります。引数の値がマーカーならマーカーの位置が使用され、マーカーのバッファーは無視されます。

Emacs Lispでは、テキスト文字は整数により表現されます。0から(max-char)までの整数は、有効な文字として判断されます。文字コードを参照してください。

Emacs Lispの整数はマシンのワードサイズに制限されません。しかしその背後にはfixnumsと呼ばれる小さい整数と、bignumsと呼ばれる大きい整数という2種類の整数が存在します。Emacs Lispコードは通常は整数がfixnumかbignumのいずれであるかに依存するべきではありませんが、Emacsの古いバージョンではfixnumだけがサポートされており、未だにfixnumだけを受け取るEmacs関数がいくつかあり、古いEmacs Lispコードがbignumを受け取ると問題が起こるかもしれません。たとえば古いEmacs Lispコードはeqで整数にたいする数値の等価性を安全に比較できましたが、bignumの登場により整数の比較にはeqlや=のような等価性にたいする述語を使うことが必要になりました。

bignumの値の範囲は主メモリー量、bignumの指数の表現に使用されるワードサイズのようなマシン特性、およびinteger-width変数により制限されます。これらの制限は通常はfixnumにたいする制限よりは寛大です。bignumが数値的にfixnumと等しくなることはありません。Emacsはfixnum範囲内の整数を、bignumではなく常にfixnumとして表現します。

fixnumの値の範囲はマシンに依存します。最小の範囲は-536,870,912から536,870,911(30ビット長の -2**29 から 2**29 - 1) ですが、多くのマシンはより広い範囲を提供します。

Variable: most-positive-fixnum ¶: この変数の値はEmacs Lispが扱える“小さい”整数の最大値。典型的な値は32ビットでは 2**29 - 1 、64ビットでは 2**61 - 1 。

Variable: most-negative-fixnum ¶: この変数の値はEmacs Lispが扱える数値的に最小の“小さい”整数。これは負の整数。典型的な値は32ビットでは -2**29 、64ビットでは -2**61、。

Variable: integer-width ¶: この変数の値は大きな整数の計算時にEmacsが範囲エラー(range error)をシグナルするかどうかを制御する負ではない整数。絶対値が 2**n (nはこの変数の値)より小さい整数の時は範囲エラーをシグナルしない。大きい整数を簡単に作成できればエラーがシグナルされない場合もあるが、通常は大きな整数の作成を試みると範囲エラーをシグナルする。この変数に大きな数値を設定すると、巨大な整数の計算にコストを要する可能性がある。

3.2 浮動小数点数の基礎

浮動小数点数は整数以外の数値の表現に有用です。浮動小数点数の範囲は使用中マシンでのCのデータ型doubleと同じ範囲です。EmacsがサポートするほとんどすべてのコンピューターではIEEEの64ビット浮動小数フォーマットであり、これはIEEE Std 754-2019で標準化されたもので、David Goldbergの論文“What Every Computer Scientist Should Know About Floating-Point Arithmetic”で更に議論されています。モダンなプラットフォームでは浮動小数処理はIEEE-754標準に厳密にしたがいますが、特に32ビットX86のような一部のシステムでは丸めは常に正しい訳ではありません。

一部の古いコンピューターシステムでは、EmacsがIEEEの浮動小数点数を使わないかもしれません。わたしたちが把握している、Emacsが正しく実行されているにも関わらずIEEE-754にしたがわないようなシステムとして、GCC 10.4.0を使用してNetBSDを実行するVAXシステムが挙げられます。このシステムではVAXの‘D_Floating’フォーマットが使用されています。IBMのSystem/370系メインフレームとそのXL/Cコンパイラーも16進浮動小数点数を扱う能力がありますが、今のところEmacsはそのような構成でビルドされていません。

浮動小数点数にたいする入力構文は、小数点と指数のどちらか1つ、または両方を必要とします。オプションの符号(‘+’か‘-’)は、その数字と指数の前に記述します。たとえば‘1500.0’、‘+15e2’、‘15.0e+2’、‘+1500000e-3’、‘.15e4’は値が1500の浮動小数点数を記述する5つの方法です。これらはすべて等価です。Common Lispと同様に、Emacs Lispは指数のない浮動小数点数の小数点の後に少なくとも1つの数字を必要とします。‘1500.’は整数であって浮動小数点数ではありません。

Emacs Lispは=のような数学的な比較に関して、-0.0を通常の0と数学的に同じものとして扱います。これは、(他の処理がこれらを区別するとしても-0.0と0.0は数学的に等しいとする)IEEE浮動小数点数規格にしたがっています。

IEEE浮動小数点数規格は浮動小数点数として、正の無限大と負の無限大をサポートします。この規格はNaNまたは“not a number(数字ではない)”と呼ばれる値クラスも提供します。正しい答えが存在しないような場合に、数学関数はこのような値をリターンします。たとえば(/ 0.0 0.0)はNaNをリターンします。数値的にNaNはたとえ自身と比較してもすべての値にたいして数値的にイコールになることはありません。NaNは符号と仮数をもち、非数学関数は符号と仮数が一致すれば2つのNaNを等しいものと扱います。NaNの仮数は文字列表現の数字のようにマシン依存です。

NaNはIEEE浮動小数点演算を使用しないシステムでは利用できません。たとえばNaNにたいする読み取り構文をVAXで使用すると、リーダーがエラーをシグナルするでしょう。

NaNと符号つき0が関係する際にはeql、equal、sxhash-eql、sxhash-equal、gethashのような非数学関数はそれらが数学的にイコールかではなく、値が区別できるかどうかを判断します。たとえばxとyが同じNaNなら数値比較を使用する(= x y)はnilをリターンするのにたいして(equal x y)はtをリターンして、反対に(= 0.0 -0.0)がtをリターンするのにたいして(equal 0.0 -0.0)はnilをリターンします。

以下は、これらの特別な浮動小数点数にたいする入力構文です:

infinity: ‘1.0e+INF’と‘-1.0e+INF’
not-a-number: ‘0.0e+NaN’と‘-0.0e+NaN’

以下の関数は浮動小数点数を扱うために特化したものです:

Function: isnan x ¶: この述語は浮動小数引数がNaNならt、それ以外はnilをリターンする。

Function: frexp x ¶

この関数はコンスセル(s . e)をリターンする。ここでsとeは、浮動小数点数の仮数(浮動小数点数を2の指数表現したときの仮数)と指数である。

xが有限ならsは0.5以上1.0未満の浮動小数点数、eは整数で、 x = s * 2**eとなる。 xが0または無限ならsはxと等しくなる。xがNaNならsもNaN。xが0ならeは0。

Function: ldexp s e ¶: 数値の仮数sと整数の指数eを与えられると、この関数は浮動小数点数 s * 2**eをリターンする。

Function: copysign x1 x2 ¶: この関数はx2の符号をx1の値にコピーして結果をリターンする。x1とx2は浮動小数でなければならない。

Function: logb x ¶

この関数はxの2進指数をリターンする。より正確にはxが有限かつ非0なら|x|の2を底とする対数を整数に切り下げた値。xが0または無限なら値は無限大。xがNaNなら値はNaN。

(logb 10)
     ⇒ 3
(logb 10.0e20)
     ⇒ 69
(logb 0)
     ⇒ -1.0e+INF

3.3 数値のための述語

このセクションの関数は数値や、特定の数値型にたいしてテストを行ないます。関数integerpとfloatpは、引数として任意のLispオブジェクト型をとることができます(でなければ、あまり使用する機会ない)。しかし述語zeropは引数として数値を要求します。マーカーのための述語のinteger-or-marker-p、number-or-marker-pも参照してください。

Function: bignump object ¶: この述語は引数が大きい整数かどうかをテストしてもしそうならt、それ以外はnilをリターンする。小さい整数とは異なり大きい整数はeqでなくても=やeqlになり得る。

Function: fixnump object ¶: この述語は引数が小さい整数かどうかをテストしてもしそうならt、それ以外はnilをリターンする。小さい整数はeqで比較できる。

Function: floatp object ¶: この述語は引数が浮動小数かどうかをテストしてもしそうならt、それ以外はnilをリターンする。

Function: integerp object ¶: この述語は引数が整数かどうかをテストしてもしそうならt、それ以外はnilをリターンする。

Function: numberp object ¶: この述語は引数が数(整数か浮動小数)かどうかをテストしてもしそうならt、それ以外はnilをリターンする。

Function: natnump object ¶

この述語は引数が正の整数かどうかをテストしてもしそうならt、それ以外はnilをリターンする(名前は“natural number: 自然数”が由来)。0は負でないと判断される。

wholenumpはnatnumpのシノニム。

Function: zerop number ¶

この述語は引数が0かどうかをテストしてもしそうならt、それ以外はnilをリターンする。引数は数でなければならない。

(zerop x)は(= x 0)と等価。

3.4 数値の比較

数値にたいして数学的な等価性をテストするには通常はeq、eql、equalのような非数値的な比較述語のかわりに=を使用するべきです。異なる浮動小数点オブジェクトと大きい整数オブジェクトを数値的に等しくすることができます。これらの比較にeqを使用した場合にはそれらが同一のオブジェクトかどうかを、eqlやequalを使用した場合にはそれらの値が区別不能かどうかをテストすることになります。対照的に=は数値比較を使用して、非数値的な比較がnilをリターンするような場合にtをリターンしたり、その逆もあり得ます。浮動小数点数の基礎を参照してください。

Emacs Lispでは2つのfixnumが数値的に等しければ同一のLispオブジェクトです。つまりfixnumではeqは=と同じです。値が未知のfixnumの比較にeqを使用する方が便利な場合があります。なぜなら未知の値が数でない場合でもeqはエラーを報告しないからです。これは任意のタイプの引数を受け付けます。対照的に引数が数でもマーカーでもなければ=はエラーをシグナルします。しかし整数の比較においてさえ、使用できる場合には=を使用するのがよいプログラミング習慣です。

数の比較において、2つの数が同じデータ型(どちらも整数であるかどちらも浮動小数であるか)で同じ値の場合は等しい数として扱うeqlやequalのほうが便利なときもあります。対照的に=は整数と浮動小数点数を(訳注:同じ値の場合には)等しい数と扱うことができます。同等性のための述語を参照してください。

他の欠点もあります。浮動小数演算は正確ではないので、浮動小数値を比較するのが悪いアイデアとなるときがよくあります。通常は近似的に等しいことをテストするほうがよいでしょう。以下はこれを行なう関数です:

(defvar fuzz-factor 1.0e-6)
(defun approx-equal (x y)
  (or (= x y)
      (< (/ (abs (- x y))
            (max (abs x) (abs y)))
         fuzz-factor)))

Function: = number-or-marker &rest number-or-markers ¶: この関数はすべての引数が数値的に等しいかどうかをテストしてもしそうならt、それ以外はnilをリターンする。

Function: eql value1 value2 ¶: この関数はeqと同様に振る舞うが引数が両方とも数のときを除く。これは数を型と数値的な値により比較するので(eql 1.0 1)はnilをリターンするが、(eql 1.0 1.0)と(eql 1 1)はtをリターンする。これは小さい整数と同様に大きい整数の比較に使用できる。符号、指数部、小数部が同じ浮動小数点数はeqlであり、これは数値の比較とは異なる。(eql 0.0 -0.0)はnil、(eql 0.0e+NaN 0.0e+NaN)はtをリターンするが、これは=の動作とは逆である。

Function: /= number-or-marker1 number-or-marker2 ¶: この関数は引数が数値的に等しいかどうかをテストして、もし異なる場合はt、等しい場合はnilをリターンする。

Function: < number-or-marker &rest number-or-markers ¶: この関数は、各引数それぞれを後の引数より小さいかどうかをテストしてもしそうならt、それ以外はnilをリターンする。

Function: <= number-or-marker &rest number-or-markers ¶: この関数は、各引数それぞれが後の引数以下かどうかをテストしてもしそうならt、それ以外はnilをリターンする。

Function: > number-or-marker &rest number-or-markers ¶: この関数は、各引数それぞれが後の引数より大きいかどうかをテストしてもしそうならt、それ以外はnilをリターンする。

Function: >= number-or-marker &rest number-or-markers ¶: この関数は、各引数それぞれが後の引数以上かどうかをテストしてもしそうならt、それ以外はnilをリターンする。

Function: max number-or-marker &rest numbers-or-markers ¶

この関数は最大の引数をリターンする。

(max 20)
     ⇒ 20
(max 1 2.5)
     ⇒ 2.5
(max 1 3 2.5)
     ⇒ 3

Function: min number-or-marker &rest numbers-or-markers ¶

この関数は最小の引数をリターンする。

(min -4 1)
     ⇒ -4

Function: abs number ¶: この関数はnumberの絶対値をリターンする。

3.5 数値の変換

整数を浮動小数の変換には関数floatを使用します。

Function: float number ¶: これは浮動小数点数に変換されたnumberをリターンする。すでにnumberが浮動小数点数ならfloatはそれを変更せずにリターンする。

浮動小数点数を整数に変換する関数が4つあります。これらは浮動小数点数を丸める方法が異なります。これらはすべて引数number、およびオプション引数としてdivisorを受け取ります。引数は両方とも整数か浮動小数点数です。divisorがnilのこともあります。divisorがnilまたは省略された場合、これらの関数はnumberを整数に変換するか、それが既に整数の場合は変更せずにリターンします。divisorが非nilなら、これらの関数はnumberをdivisorで除して結果を整数に変換します。divisorが(整数か浮動小数かに関わらず)0の場合、Emacsはarith-errorエラーをシグナルします。

Function: truncate number &optional divisor ¶

これは0に向かって丸めることにより整数に変換したnumberをリターンする。

(truncate 1.2)
     ⇒ 1
(truncate 1.7)
     ⇒ 1
(truncate -1.2)
     ⇒ -1
(truncate -1.7)
     ⇒ -1

Function: floor number &optional divisor ¶

これは下方(負の無限大に向かって)に丸めることにより整数に変換したnumberをリターンする。

divisorが指定された場合には、modに相当する種類の除算演算を使用して下方に丸めを行う。

(floor 1.2)
     ⇒ 1
(floor 1.7)
     ⇒ 1
(floor -1.2)
     ⇒ -2
(floor -1.7)
     ⇒ -2
(floor 5.99 3)
     ⇒ 1

Function: ceiling number &optional divisor ¶

これは上方(正の無限大に向かって)に丸めることにより整数に変換したnumberをリターンする。

(ceiling 1.2)
     ⇒ 2
(ceiling 1.7)
     ⇒ 2
(ceiling -1.2)
     ⇒ -1
(ceiling -1.7)
     ⇒ -1

Function: round number &optional divisor ¶

これはもっとも近い整数に向かって丸めることにより、整数に変換したnumberをリターンする。2つの整数から等距離にある値の丸めでは、偶数の整数をリターンする。

(round 1.2)
     ⇒ 1
(round 1.7)
     ⇒ 2
(round -1.2)
     ⇒ -1
(round -1.7)
     ⇒ -2

3.6 算術演算

Emacs Lispは伝統的な4つの算術演算(加減乗除)、同様に剰余とmodulusの関数、および1の加算と減算を行う関数を提供します。%を除き、これらの各関数は引き数として整数か浮動小数を受け取り、浮動小数の引数がある場合は浮動小数点数をリターンします。

Function: 1+ number-or-marker ¶

この関数はnumber-or-marker + 1をリターンする。例えば、

(setq foo 4)
     ⇒ 4
(1+ foo)
     ⇒ 5

この関数はCの演算子++とは異なり、変数をインクリメントしない。この関数は和を計算するだけである。したがって以下を続けて評価すると、

foo
     ⇒ 4

変数をインクリメントしたい場合は、以下のようにsetqを使用しなければならない:

(setq foo (1+ foo))
     ⇒ 5

Function: 1- number-or-marker ¶: この関数はnumber-or-marker - 1をリターンする。

Function: + &rest numbers-or-markers ¶

この関数は引数すべてを加算する。引数を与えないと+は0をリターンする。

(+)
     ⇒ 0
(+ 1)
     ⇒ 1
(+ 1 2 3 4)
     ⇒ 10

Function: - &optional number-or-marker &rest more-numbers-or-markers ¶

-関数は2つの目的 — 符号反転と減算 — をもつ。-に1つの引数を与えると、値は引数の符号を反転したものになる。複数の引数の場合は、number-or-markerからmore-numbers-or-markersまでの各値を蓄積的に減算する。引数がなければ結果は0。

(- 10 1 2 3 4)
     ⇒ 0
(- 10)
     ⇒ -10
(-)
     ⇒ 0

Function: * &rest numbers-or-markers ¶

この関数はすべての引数を乗じて積をリターンする。引数がなかれば*は1をリターンする。

(*)
     ⇒ 1
(* 1)
     ⇒ 1
(* 1 2 3 4)
     ⇒ 24

Function: / number &rest divisors ¶

divisorsが1つ以上ならこの関数はdivisors内の除数で順にnumberを除して、その商をリターンする。divisorsがなければ、この関数は1/number、つまりnumberの逆数をリターンする。各引数には数かマーカーを指定できる。

すべての引数が整数なら、結果は各除算の後に商を0へ向かって丸めることにより得られる整数となる。

(/ 6 2)
     ⇒ 3

(/ 5 2)
     ⇒ 2

(/ 5.0 2)
     ⇒ 2.5

(/ 5 2.0)
     ⇒ 2.5

(/ 5.0 2.0)
     ⇒ 2.5

(/ 4.0)
     ⇒ 0.25

(/ 4)
     ⇒ 0

(/ 25 3 2)
     ⇒ 4

(/ -17 6)
     ⇒ -2

整数を整数0で除するとEmacsはarith-errorエラー(エラーを参照)をシグナルする。IEEE-754の浮動小数点数を使用するシステムにおける浮動小数点数の除算では、非0の数を0で除することで正の無限大または負の無限大を得る(浮動小数点数の基礎を参照)。それ以外のシステムでは通常通りarith-errorエラーがシグナルされる。

Function: % dividend divisor ¶

この関数はdividendをdivisorで除した後、その剰余を整数でリターンする。引数は整数かマーカーでなければならない。

任意の2つの整数dividendとdivisorにたいして、

(+ (% dividend divisor)
   (* (/ dividend divisor) divisor))

は、divisorが非0なら常にdividendと等しくなる。

(% 9 4)
     ⇒ 1
(% -9 4)
     ⇒ -1
(% 9 -4)
     ⇒ 1
(% -9 -4)
     ⇒ -1

Function: mod dividend divisor ¶

この関数はdividendのdivisorにたいするmodulo、言い換えるとdividendをdivisorで除した後の剰余(ただし符号はdivisorと同じ)をリターンする。引数は数かマーカーでなければならない。

%とは異なりmodは浮動小数の引数を許す。これは商を整数に下方(負の無限大に向かって)へ丸めて剰余を計算するのにこの商を使用する。

modはdivisorが0のとき、両方の引数が整数ならarith-errorエラーをシグナルし、それ以外はNaNをリターンする。

(mod 9 4)
     ⇒ 1

(mod -9 4)
     ⇒ 3

(mod 9 -4)
     ⇒ -3

(mod -9 -4)
     ⇒ -1

(mod 5.5 2.5)
     ⇒ .5

任意の2つの数dividendとdivisorにたいして、

(+ (mod dividend divisor)
   (* (floor dividend divisor) divisor))

は常にdividendになる(ただし引数のどちらかが浮動小数なら、丸め誤差の範囲内で等しく、かつdividendが整数でdivisorが0ならarith-errorとなる)。floorについては、数値の変換を参照のこと。

3.7 丸め処理

関数ffloor、fceiling、fround、ftruncateは浮動小数の引数をとり、値が近くの整数であるような浮動小数をリターンします。ffloorは一番近い下方の整数、fceilingは一番近い上方の整数、ftruncateは0に向かう方向で一番近い整数、froundは一番近い整数をリターンします。

Function: ffloor float ¶: この関数はfloatを次に小さい整数値に丸めて、その値を浮動小数点数としてリターンする。

Function: fceiling float ¶: この関数はfloatを次に大きい整数値に丸めて、その値を浮動小数点数としてリターンする。

Function: ftruncate float ¶: この関数はfloatを0方向の整数値に丸めて、その値を浮動小数点数としてリターンする。

Function: fround float ¶: この関数はfloatを一番近い整数値に丸めて、その値を浮動小数点数としてリターンする。2つの整数値との距離が等しい値にたいする丸めでは、偶数の整数をリターンする。

3.8 整数にたいするビット演算

コンピューターの中では、整数はビット(bit: 0か1の数字)のシーケンスである2進数で表されます。ビットシーケンスは概念的には最上位ビットがすべて0か1であるような左側に無限なシーケンスです。ビット演算はそのようなシーケンスの中の個々のビットに作用します。たとえばシフト(shifting)はシーケンス全体を1つ以上左または右に移動して、移動されたのと同じパターンを再現します。

Emacs Lispのビット演算は整数だけに適用されます。

Function: ash integer1 count ¶

ash (算術シフト(arithmetic shift))は、integer1の中のビット位置を左にcountシフトする。countが負なら右にシフトする。左シフトでは右側に0が挿入されて、右シフトでは最右ビットが破棄される。整数処理として考えると、ashはinteger1に 2**count を乗じてから、負の無限大に向かって丸めることによりその結果を変換する。

以下はビットパターンを1ビット左にシフトしてから右にシフトする例。この例で2進数パターンの下位ビットだけを示している。先頭ビットはすべて表示されている最上位ビットと一致する。ご覧のとおり1ビットの左シフトは2を乗ずること、1ビットの右シフトは2で除してから負の無限大方向に丸められることと等価である。

(ash 7 1) ⇒ 14
;; 10進の7は10進の14になる
…000111
     ⇒
…001110

(ash 7 -1) ⇒ 3
…000111
     ⇒
…000011

(ash -7 1) ⇒ -14
…111001
     ⇒
…110010

(ash -7 -1) ⇒ -4
…111001
     ⇒
…111100

以下は2ビット左にシフトしてから右に2ビットシフトする例:

                  ;         2進数値
(ash 5 2)         ;   5  =  …000101
     ⇒ 20         ;      =  …010100
(ash -5 2)        ;  -5  =  …111011
     ⇒ -20        ;      =  …101100

(ash 5 -2)
     ⇒ 1          ;      =  …000001

(ash -5 -2)
     ⇒ -2         ;      =  …111110

Function: lsh integer1 count ¶

lshはlogical shiftの略で、integer1のビットを左にcount回シフト(countが負なら右にシフト、空いたビットには0を補填)する。countが負ならinteger1はfixnumか正のbignumのいずれかでなければならず、lshはシフト前に負のfixnumをmost-negative-fixnumで2回減算してあたかも符号なしであるかのように非負の結果を生成する。この奇妙な振る舞いはEmacsがfixnumsだけをサポートしていた頃の振る舞いであり、現在ではashがより良い選択である。

integer1とcount1がいずれも負の場合を除いてlshはashのように振る舞うので、以下の例ではこれらの例外ケースに焦点をあてている。これらの例は30ビットのfixnumsを想定している。

                 ;      2進数値
(ash -7 -1)      ; -7 = …111111111111111111111111111001
     ⇒ -4        ;    = …111111111111111111111111111100
(lsh -7 -1)
     ⇒ 536870908 ;    = …011111111111111111111111111100

(ash -5 -2)      ; -5 = …111111111111111111111111111011
     ⇒ -2        ;    = …111111111111111111111111111110
(lsh -5 -2)
     ⇒ 268435454 ;    = …001111111111111111111111111110

Function: logand &rest ints-or-markers ¶

この関数は引数のビットのANDをリターンする。すべての引数のn番目のビットが1の場合に限り、結果のn番目のビットが1となる。

たとえば13と12では、4ビット2進数を使用すると1101と1100のビットANDは1100を生成する。この2進数ではいずれも左の2ビットがセット(つまり1)されているので、リターンされる値の左2ビットがセットされる。しかし右の2ビットにたいしては少なくとも1つの引数でそのビットが0なので、リターンされる値の右2ビットは0になる。

したがって、

(logand 13 12)
     ⇒ 12

logandに何も引数も渡さなければ、値-1がリターンされる。-1を2進数で表すとすべてのビットが1なので、-1はlogandにたいする単位元(identity element)である。logandに渡す引数が1つだけならその引数がリターンされる。

                   ;        2進数値

(logand 14 13)     ; 14  =  …001110
                   ; 13  =  …001101
     ⇒ 12         ; 12  =  …001100

(logand 14 13 4)   ; 14  =  …001110
                   ; 13  =  …001101
                   ;  4  =  …000100
     ⇒ 4          ;  4  =  …000100

(logand)
     ⇒ -1         ; -1  =  …111111

Function: logior &rest ints-or-markers ¶

この関数は、引数のビット単位の包含的ORをリターンする。少なくとも1つの引数でn番目のビットが1なら、結果のn番目のビットが1になる。引数を与えなければ、結果はこの処理にたいする単位元である0となる。logiorに渡す引数が1つだけならその引数がリターンされる。

                   ;        2進数値

(logior 12 5)      ; 12  =  …001100
                   ;  5  =  …000101
     ⇒ 13         ; 13  =  …001101

(logior 12 5 7)    ; 12  =  …001100
                   ;  5  =  …000101
                   ;  7  =  …000111
     ⇒ 15         ; 15  =  …001111

Function: logxor &rest ints-or-markers ¶

この関数は、引数のビット単位の排他的ORをリターンする。n番目のビットが1であるような引数の数が奇数個の場合のみ、結果のn番目のビットが1となる。引数を与えなければ、結果はこの処理の単位元である0となる。logxorに渡す引数が1つだけならその引数がリターンされる。

                   ;        2進数値

(logxor 12 5)      ; 12  =  …001100
                   ;  5  =  …000101
     ⇒ 9          ;  9  =  …001001

(logxor 12 5 7)    ; 12  =  …001100
                   ;  5  =  …000101
                   ;  7  =  …000111
     ⇒ 14         ; 14  =  …001110

Function: lognot integer ¶

この関数は引数のビット単位の補数(bitwise complement)をリターンする。integerのn番目のビットが0の場合に限り、結果のn番目のビットが1になり、その逆も成り立つ。結果は-1 - integerと等価。

(lognot 5)
     ⇒ -6
;;  5  =  …000101
;; becomes
;; -6  =  …111010

Function: logcount integer ¶

この関数はintegerのハミング重み (Hamming weight: integerの2進数表現での1の個数)をリターンする。integerが負なら、その2の補数の2進数表現での0ビットの個数をリターンする。結果は常に非負となる。

(logcount 43)     ;  43 = …000101011
     ⇒ 4
(logcount -43)    ; -43 = …111010101
     ⇒ 3

3.9 標準的な数学関数

以下の数学的関数は、引数として整数と同様に浮動小数点数も受け入れます。

Function: sin arg ¶
Function: cos arg ¶
Function: tan arg ¶: これらは三角関数であり、引数argはラジアン単位。

Function: asin arg ¶: (asin arg)の値は、sinの値がargとなるような -pi/2 から pi/2 (両端を含む)の数である。argが範囲外([-1, 1]の外)なら、asinはNaNをリターンする。

Function: acos arg ¶: (acos arg)の値は、cosの値がargとなるような、0から pi (両端を含む)の数である。argが範囲外([-1, 1]の外)ならacosはNaNをリターンする。

Function: atan y &optional x ¶: (atan y)の値は、tanの値がyとなるような、 -pi/2 から pi/2 (両端を含まず)の数である。オプションの第2引数xが与えられると、(atan y x)の値はベクトル[x, y]とX軸が成す角度のラジアン値となる。

Function: exp arg ¶: これは指数関数である。この関数はeの指数argをリターンする。

Function: log arg &optional base ¶: この関数は底をbaseとするargの対数をリターンする。baseを指定しなければ、自然底(natural base)eが使用される。argかbaseが負なら、logはNaNをリターンする。

Function: expt x y ¶: この関数はxのy乗をリターンする。引数が両方とも整数でyが非負なら結果は整数になる。この場合オーバーフローはエラーをシグナルするので注意。xが有限の負数でyが有限の非整数なら、exptはNaNをリターンする。

Function: sqrt arg ¶: これはargの平方根をリターンする。argが有限で0より小さければ、sqrtはNaNをリターンする。

加えて、Emacsは以下の数学的な定数を定義します:

Variable: float-e ¶: 自然対数e(2.71828…)

Variable: float-pi ¶: 円周率pi(3.14159…)

3.10 乱数

決定論的なコンピュータープログラムでは真の乱数を生成することはできません。しかしほとんどの目的には、疑似乱数(pseudo-random numbers)で充分です。一連の疑似乱数は決定論的な手法により生成されます。真の乱数ではありませんが、それらにはランダム列を模する特別な性質があります。たとえば疑似ランダム系では、すべての可能な値は均等に発生します。

疑似乱数はシード値(seed value)から生成されます。与えられた任意のシードから開始することにより、random関数は常に同じ数列を生成します。デフォルトでは、Emacsは開始時に乱数シードを初期化することにより、それぞれのEmacsの実行において、randomの値シーケンスは(ほとんど確実に)異なります。乱数シードは通常はシステムエントロピーから初期化されます。ただしエントロピープールをもたない時代遅れのプラットフォームでは、カレント時刻のようなランダム度に劣る揮発性データからシードを取得します。

再現可能な乱数シーケンスが欲しい場合もあります。たとえば乱数シーケンスに依存するプログラムをデバッグする場合、プログラムの各実行において同じ挙動を得ることが助けになります。再現可能なシーケンスを作成するには、(random "")を実行します。これは特定のEmacsの実行可能ファイルにたいして、シードに定数値をセットします(しかしこの実行可能ファイルは、その他のEmacsビルドと異なるものになるであろう)。シード値として、他のさまざまな文字列を使用することができます。

Function: random &optional limit ¶

この関数は疑似乱数の整数をリターンする。繰り返し呼び出すと一連の疑似乱数の整数をリターンする。

limitが正の整数なら、値は負ではないlimit未満の値から選択される。それ以外なら値はLispで表現可能な任意のfixnum(most-negative-fixnumからmost-positive-fixnumの間の任意の整数)となるだろう(整数の基礎を参照)。

limitが文字列なら、その文字列定数にもとづいた新しいシードを選択することを意味する。これにより後でrandomを呼び出して再現可能な結果シーケンスをリターンさせることができる。

limitがtなら、あたかもEmacsが再起動されたかのように新たなシードが選択されることを意味する。これにより後でrandomを呼び出して予測不能な結果シーケンスをリターンさせることができる。

暗号化用に乱数ノンス(random nonce: 使い捨てのランダム値)が必要な場合にrandomを使用するのは、いくつかの理由により適切ではありません:

システムエントロピーの参照に(random t)を用いるのは可能とはいえ、あなたのプログラムのうち再現可能な結果から恩恵を受ける他の部分に悪影響を与えるかもしれない。
randomが使用するシステム依存の疑似乱数ジェネレーター(PRNG: pseudo-random number generator)は、必ずしも暗号化に適している訳ではない。
(random t)は、システムエントロピーへの直接的アクセスを提供しない。このエントロピーはシステム依存のPRNGを通過するので、結果にバイアスがかかる可能性がある。
典型的なプラットフォームの乱数シードに含まれるのは32ビットだけであり、これはEmacsのfixnumより小さいので、暗号化という目的にたいしては不十分である。
(random t)の呼び出しによって、Emacsの内部状態が散在するノンス情報が残るので、内部的な攻撃面のサイズが増加する。
エントロピープールのない旧式のシステムでは、(random t)が暗号化にたいして脆弱なソースからシードされる。

4 文字列と文字

Emacs Lispの文字列は、文字列の順序列(ordered sequence)を含む配列です。文字列はシンボル、バッファー、ファイルの名前に使用されます。その他にもユーザーにたいしてメッセージを送ったりバッファー間でコピーする文字列を保持したり等、多くの目的に使用されます。文字列は特に重要なので、Emacs Lispは特別には文字列を操作するために多くの関数があります。Emacs Lispプログラムでは個々の文字より文字列を多用します。

キーボードの文字イベントの文字列にたいする特別な考慮は、文字列内へのキーボードイベントの配置を参照してください。

4.1 文字列と文字の基礎		文字列と文字の基本的なプロパティ。
4.2 文字列のための述語		オブジェクトが文字列か文字かをテストする。
4.3 文字列の作成		新しい文字列を割り当てる関数。
4.4 文字列の変更		既存の文字列の内容を変更する。
4.5 文字および文字列の比較		文字または文字列を比較する。
4.6 文字および文字列の変換		文字から文字列への変換と逆変換。
4.7 文字列のフォーマット		`format`: `printf`のEmacs版。
4.8 カスタムフォーマット文字列		カスタマイズした`format`仕様によるフォーマット。
4.9 Lispでの大文字小文字変換		大文字小文字の変換関数。
4.10 caseテーブル		case変換のカスタマイズ。

4.1 文字列と文字の基礎

文字(character)とは、テキスト内の1つの文字を表すLispオブジェクトです。Emacs Lispでは文字は単なる整数です。ある整数が文字か文字でないかを区別するのは、それが使用される方法だけです。Emacsでの文字表現についての詳細は文字コードを参照してください。

文字列(string)とは固定された文字シーケンスです。これは配列(array)と呼ばれるシーケンス型であり、配列長が固定で一度作成したら変更できないことを意味します(シーケンス、配列、ベクターを参照)。Cとは異なり、Emacs Lispの文字列は文字コードを判断することにより終端されません。(訳注: 文字列の終端用の文字コードはない、ということ。)

文字列は配列であるということは同様にシーケンスでもあるので、シーケンス、配列、ベクターにドキュメントされている一般的な配列関数やシーケンス関数で文字列を処理できます。たとえば関数arefを使用して文字列内の特定の文字にアクセスしたり変更することができます(配列を操作する関数を参照)。

Emacs文字列での非ASCIIにたいすテキスト表現は2つ — ユニバイト(unibyte)とマルチバイト(multibyte)があります。ほとんどのLispプログラミングでは、これら2つの表現を気にする必要はありません。詳細はテキストの表現方法を参照してください。

キーシーケンスがユニバイト文字列で表されることがあります。ユニバイト文字列がキーシーケンスの場合、範囲128から255までの文字列要素は範囲128から255の文字コードではなく、メタ文字(これは非常に大きな整数である)を表します。文字列はハイパー(hyper)、スーパー(super)、アルト(alt)で修飾された文字を保持できません。文字列はASCIIコントロール文字を保持できますが、それは他のコントロール文字です。文字列はASCIIコントロール文字のcaseを区別できません。そのような文字をシーケンスに保存したい場合は、文字列ではなくベクターを使用しなければなりません。キーボード入力文字についての情報は文字型を参照してください。

文字列は正規表現を保持するために便利です。string-match (正規表現の検索を参照)を使用して、文字列にたいして正規表現をマッチすることもできます。関数match-string (単純なマッチデータへのアクセスを参照)とreplace-match (マッチしたテキストの置換を参照)は、文字列にたいして正規表現をマッチした後に、文字列を分解・変更するのに便利です。

バッファーのように、文字列は文字列内の文字自身とその文字にたいするテキストプロパティを含みます。テキストのプロパティを参照してください。文字列からバッファーや他の文字列にテキストをコピーする、すべてのLispプリミティブ(Lisp primitives)はコピーされる文字のプロパティもコピーします。

文字列の表示やバッファーにコピーする関数についての情報はテキストを参照してください。文字または文字列の構文についての情報は、文字型と文字列型を参照してください。異なるテキスト表現間で変換したり、文字コードのエンコードやデコードを行う関数については非ASCII文字を参照してください。ディスプレイ上の文字列幅の計算にlengthを使用するべきではないことにも注意してください。かわりにstring-widthを使用してください(表示されるテキストのサイズを参照)。

4.2 文字列のための述語

一般的なシーケンスや配列にたいする述語についての情報は、シーケンス、配列、ベクターと配列を参照してください。

Function: stringp object ¶: この関数はobjectが文字列ならt、それ以外はnilをリターンする。

Function: string-or-null-p object ¶: この関数はobjectが文字列かnilならt、それ以外はnilをリターンする。

Function: char-or-string-p object ¶: この関数はobjectが文字列か文字(たとえば整数)ならt、それ以外はnilをリターンする。

4.3 文字列の作成

以下の関数はスクラッチ、文字列同士、またはその一部から文字列を作成します(string-replaceやreplace-regexp-in-stringのように他の文字列内容を変更して文字列を作成する関数については検索と置換を参照)。

Function: make-string count character &optional multibyte ¶

この関数はcharacterをcount回繰り返すことにより作成された文字列をリターンする。countが負ならエラーをシグナルする。

(make-string 5 ?x)
     ⇒ "xxxxx"
(make-string 0 ?x)
     ⇒ ""

characterがASCII文字なら、結果は通常はユニバイト文字列になる。しかしオプション引数multibyteが非nilなら、この関数はかわりにマルチバイト文字列を生成する。これは結果を後で非ASCII文字列と結合したり、結果の中のいくつかの文字を非ASCII文字で置換する必要がある際に有用。

この関数に対応する他の関数にはmake-vector (ベクターを参照)やmake-list (コンスセルおよびリストの構築を参照)が含まれる。

Function: string &rest characters ¶

この関数は文字charactersを含む文字列をリターンする。

(string ?a ?b ?c)
     ⇒ "abc"

Function: substring string &optional start end ¶

この関数はstringから、インデックスstartの文字(その文字を含む)とendの文字(その文字は含まない)の間の範囲の文字で構成される、新しい文字列をリターンする。文字列の最初の文字はインデックス0。引数が1つなら、この関数は単にstringをコピーする。

(substring "abcdefg" 0 3)
     ⇒ "abc"

上記の例では‘a’のインデックスは0、‘b’のインデックスは1、‘c’のインデックスは2となる。インデックス3 — この文字列の4番目の文字 — は、コピーされる部分文字列の文字位置までをマークする。したがって文字列"abcdefg"から‘abc’がコピーされる。

負の数は文字列の最後から数えることを意味するので、-1は文字列の最後の文字のインデックスである。たとえば:

(substring "abcdefg" -3 -1)
     ⇒ "ef"

この例では‘e’のインデックスは-3、‘f’のインデックスは-2、‘g’のインデックスは-1。つまり‘e’と‘f’が含まれ、‘g’は含まれない。

endにnilを使用した場合、それは文字列の長さを意味する。したがって、

(substring "abcdefg" -3 nil)
     ⇒ "efg"

引数endを省略した場合、それはnilを指定したのと同じである。(substring string 0)はstringのすべてをコピーしてリターンする。

(substring "abcdefg" 0)
     ⇒ "abcdefg"

しかしこの目的のためにはcopy-sequenceを推奨する(シーケンスを参照)。

stringからコピーされた文字がテキストプロパティをもつなら、そのプロパティは新しい文字列へもコピーされる。テキストのプロパティを参照のこと。

substringの最初の引数にはベクターも指定できる。たとえば:

(substring [a b (c) "d"] 1 3)
     ⇒ [b (c)]

startが整数でない、またはendが整数でもnilでもななければ、wrong-type-argumentエラーがシグナルされる。startがendの後の文字を指す、またはstringにたいして範囲外の整数をいずれかに指定すると、args-out-of-rangeエラーがシグナルされる。

この関数に対応するのはbuffer-substring (バッファーのコンテンツを調べるを参照)で、これはカレントバッファー内のテキストの一部を含む文字列をリターンする。文字列の先頭はインデックス0だが、バッファーの先頭はインデックス1である。

Function: substring-no-properties string &optional start end ¶: これはsubstringと同じように機能するが、値のすべてのテキストプロパティを破棄する。startを省略したりnilを指定することができ、その場合は0と等価である。したがって(substring-no-properties string)は、すべてのテキストプロパティが削除されたstringのコピーをリターンする。

Function: concat &rest sequences ¶

この関数は渡された引数内の文字からなる文字列をリターンする(もしあればテキストプロパティも)。引数には文字列、数のリスト、数のベクターを指定できる。引数は変更されない。concatに引数を指定しなければ空文字列をリターンする。

(concat "abc" "-def")
     ⇒ "abc-def"
(concat "abc" (list 120 121) [122])
     ⇒ "abcxyz"
;; nilは空のシーケンス。
(concat "abc" nil "-def")
     ⇒ "abc-def"
(concat "The " "quick brown " "fox.")
     ⇒ "The quick brown fox."
(concat)
     ⇒ ""

この関数は常に新たな文字列の割り当てを行う訳ではない。呼び出し側は結果が新たな文字列であること、もしくは既存の文字列にたいしてeqであることに依存しないよう推奨する。

特にリターン値を変更すると誤って別の文字列を変更したり、プログラム内の定数文字列の変更や、エラーをraiseすることさえあり得る。安全に変更できる文字列を取得するには、結果にcopy-sequenceを使用すること。

他の結合関数(concatenation functions)についての情報は関数のマッピングのmapconcat、ベクターのための関数のvconcat、コンスセルおよびリストの構築のappendを参照のこと。シェルコマンドで使用される文字列の中に、個々のコマンドライン引数を結合するには、combine-and-quote-stringsを参照されたい。

Function: split-string string &optional separators omit-nulls trim ¶

この関数は正規表現separators(正規表現を参照)にもとづいて、stringを部分文字列に分解する。separatorsにたいする各マッチは分割位置を定義する。分割位置の間にある部分文字列をリストにまとめてリターンする。

separatorsがnil (か省略)ならデフォルトはsplit-string-default-separatorsの値となり、関数はomit-nullsがtであるかのように振る舞う。

omit-nullsがnil(または省略)なら、連続する2つのseparatorsへのマッチか、stringの最初か最後にマッチしたときの空文字列が結果に含まれる。omit-nullsがtなら、これらの空文字列は結果から除外される。

オプションの引数trimが非nilなら、その値は各部分文字列の最初と最後からトリム(trim: 除去)するテキストにマッチする正規表現を指定する。トリムによりその部分文字列が空になるようなら、それは空文字列として扱われる。

文字列を分割してcall-processやstart-processに適するような、個々のコマンドライン引数のリストにする必要がある場合はsplit-string-and-unquoteを参照のこと。

以下は例:

(split-string "  two words ")
     ⇒ ("two" "words")

有用性はほとんどないであろう("" "two" "words" "")という結果とはならない。このような結果が必要ならseparatorsに明示的な値を使用すること

(split-string "  two words "
              split-string-default-separators)
     ⇒ ("" "two" "words" "")

(split-string "Soup is good food" "o")
     ⇒ ("S" "up is g" "" "d f" "" "d")
(split-string "Soup is good food" "o" t)
     ⇒ ("S" "up is g" "d f" "d")
(split-string "Soup is good food" "o+")
     ⇒ ("S" "up is g" "d f" "d")

空のマッチはカウントされます。例外は、空でないマッチを使用することにより、すでに文字列の最後に到達しているとき、またはstringが空の時で、この場合split-stringは最後の空マッチを探しません。

(split-string "aooob" "o*")
     ⇒ ("" "a" "" "b" "")
(split-string "ooaboo" "o*")
     ⇒ ("" "" "a" "b" "")
(split-string "" "")
     ⇒ ("")

しかしseparatorsが空文字列にマッチできるとき、通常はomit-nullsをtにすれば、前の3つの例の不明瞭さはほとんど発生しない:

(split-string "Soup is good food" "o*" t)
     ⇒ ("S" "u" "p" " " "i" "s" " " "g" "d" " " "f" "d")
(split-string "Nice doggy!" "" t)
     ⇒ ("N" "i" "c" "e" " " "d" "o" "g" "g" "y" "!")
(split-string "" "" t)
     ⇒ nil

空でないマッチより空のマッチを優先するような、一部の“非貪欲(non-greedy)”な値をseparatorsに指定することにより、幾分奇妙(ではあるが予見可能)な振る舞いが発生することがある。繰り返しになるが、そのような値は実際には稀である:

(split-string "ooo" "o*" t)
     ⇒ nil
(split-string "ooo" "\\|o+" t)
     ⇒ ("o" "o" "o")

Variable: split-string-default-separators ¶: split-stringのseparatorsにたいするデフォルト値。通常の値は"[ \f\t\n\r\v]+"。

Function: string-clean-whitespace string ¶: string内の連続する空白文字を単一のスペースに、同様にstringの先頭と終端にあるすべての空白文字を取り除くことにより空白文字を整理する。

Function: string-trim-left string &optional regexp ¶: stringの先頭からregexpにマッチするテキストを削除する。regexpのデフォルトは‘[ \t\n\r]+’。

Function: string-trim-right string &optional regexp ¶: stringの末尾からregexpにマッチするテキストを削除する。regexpのデフォルトは‘[ \t\n\r]+’。

Function: string-trim string &optional trim-left trim-right ¶: stringからtrim-leftにマッチする先頭のテキストと、trim-rightにマッチする末尾のテキストを削除する。いずれのregexpもデフォルトは‘[ \t\n\r]+’。

Function: string-fill string length ¶: lengthより長い行が無くなるようにstringのワードラップを試みる。フィルは空白文字境界でのみ行われる。lengthより長い個別の単語は短くならない。

Function: string-limit string length &optional end coding-system ¶

stringの文字数がlengthより短ければstringをそのままリターンする。それ以外なら最初のlength文字からなるstringの部分文字列をリターンする。オプションのパラメーターendが与えられた場合には、かわりに最後のlength文字からなる文字列をリターンする。

coding-systemが非nilならstringを切り詰める前にエンコードして、結果はlengthバイトより短いユニバイト文字列になる。stringにエンコードされると複数バイトになる文字(たとえばutf-8使用時)が含まれる場合には、結果となるユニバイト文字列が文字表現の途中で切り詰められることはない。

この関数は文字列長を文字数かバイトで数えるので、文字列を表示用に短くする必要がある場合には一般的に適していない。かわりにtruncate-string-to-width、window-text-pixel-size、string-glyph-splitを使用すること(表示されるテキストのサイズを参照)。

Function: string-lines string &optional omit-nulls keep-newlines ¶: 改行を境界としてstringを文字列のリストに分割する。オプション引数omit-nullsが非nilなら、結果から空行を除外する。オプション引数keep-newlinesが非nilなら、結果文字列から末尾の改行を取り除かない。

Function: string-pad string length &optional padding start ¶: paddingをパディング文字に使用して、与えられたlengthになるようにstringをパディングする。paddingのデフォルトはスペース文字。lengthよりstringが長ければパディングしない。startがnil (または省略)ならパディングは文字列終端、非nilなら文字列先頭に追加される。

Function: string-chop-newline string ¶: stringからもしあれば最後の改行を削除する。

4.4 文字列の変更

このセクションで説明する処理を介して変更可能な文字列のコンテンツを変更できます。可変性を参照してください。

既存の文字列の内容を変更するもっとも基本的な方法は、aset (配列を操作する関数を参照)を使用する方法です。(aset string idx char)は、stringの文字インデックスidxに、charを格納します。これはstringが純正なASCIIなら必要に応じてマルチバイト文字列(テキストの表現方法を参照)に変換しますが、charがrawバイトではなく非ASCII文字の場合には、たとえばstring-to-multibyte (テキスト表現の変換を参照)を使う等により、stringがマルチバイトになるよう常に保証することをお勧めします。

より強力な関数はstore-substringです:

Function: store-substring string idx obj ¶

この関数は文字インデックスidxで開始される位置にobjを格納することにより、指定されたstringの内容の一部を変更する。objは文字(この場合にはasetとまったく同じように振る舞う)、または(stringより小さい)文字列。objがマルチバイト文字列の場合には、たとえstringが純正のASCII文字列であってもマルチバイト文字列に変更することを推奨する。

既存の文字列の文字数を変更するのは不可能なので、文字インデックスidxを開始位置としたときにobjがstringに収まらないような文字数で構成される場合にはエラーとなる。

パスワードを含む文字列をクリアーするときにはclear-stringを使用します:

Function: clear-string string ¶: これはstringをユニバイト文字列にして、内容を0にクリアーする。これによりstringの長さも変更されるだろう。

4.5 文字および文字列の比較

Function: char-equal character1 character2 ¶

この関数は引数が同じ文字を表すならt、それ以外はnilをリターンする。case-fold-searchが非nilなら、この関数はcaseの違いを無視する。

(char-equal ?x ?x)
     ⇒ t
(let ((case-fold-search nil))
  (char-equal ?x ?X))
     ⇒ nil

Function: string= string1 string2 ¶

この関数は、2つの文字列の文字が正確にマッチすればtをリターンする。引数にはシンボルも指定でき、この場合はそのシンボル名が使用される。case-fold-searchとは無関係にcaseは常に意味をもつ。

この関数は、equalで2つの文字列を比較するのと等価である(同等性のための述語を参照)。特に、2つの文字列のテキストプロパティは無視される。テキストプロパティだけが異なる文字列を区別する必要があるならequal-including-propertiesを使用すること。しかしequalとは異なり、いずれかの引数が文字列でもシンボルでもなければ、string=はエラーをシグナルする。

(string= "abc" "abc")
     ⇒ t
(string= "abc" "ABC")
     ⇒ nil
(string= "ab" "ABC")
     ⇒ nil

ユニバイト文字列とマルチバイト文字列がstring=において等しくなるのは、すべての文字が0から127の範囲(ASCII)にある同じ文字シーケンスを含む場合だけである。テキストの表現方法を参照のこと。

Function: string-equal string1 string2 ¶: string-equalはstring=の別名である。

Function: string-equal-ignore-case string1 string2 ¶: string-equal-ignore-caseはcase-fold-searchがtの際のchar-equalのように、case(大文字小文字)の違いを無視して文字列を比較する。

Function: string-collate-equalp string1 string2 &optional locale ignore-case ¶

この関数はlocale (デフォルトはカレントのシステムlocale)で指定された照合ルール(collation rule)にもとづいて、string1とstring2が等しければtをリターンする。照合ルールはstring1とstring2に含まれる文字の辞書順だけではなく、それらの文字間の関係に関する他のルールにより判断される。これは通常はEmacs実行中のlocale環境、およびEmacsがリンクされた標準Cライブラリー³により決定される。

たとえばUnicode文字の異なるグレイブアクセントのように、コーディングポイントが異なっても意味が同じなら、一部のlocaleでは等しいとみなされるかもしれない。

(string-collate-equalp (string ?\uFF40) (string ?\u1FEF))
     ⇒ t

オプション引数locale(文字列)は、照合用のカレントlocale識別子(current locale identifier)をオーバーライドする。値はシステムに依存する。たとえばPOSIXシステムでは"en_US.UTF-8"、MS-Windowsシステムでは"enu_USA.1252"のlocaleが適用できるだろう。

ignore-caseが非nilなら、文字を小文字に変換することによってcaseを区別せずに文字の比較を行う。ただし背景となるシステムライブラリーがlocale固有の照合ルールを提供していない場合には、この関数はstring-equalにフォールバックする。この場合にはignore-case引数を無視して、常にcaseを区別した比較を行う。

MS-WindowsシステムでUnicode互換の照合をエミュレートする場合、MS-Windowsではlocaleのコードセット部分を"UTF-8"にできないので、w32-collate-ignore-punctuationに非nil値をバインドすること。

あるlocale環境をシステムがサポートしなれければ、この関数はstring-equalと同様に振る舞う。

一般的にファイルシステムは照合ルールが実装するような文字列の言語学的な等価性を尊重しないので、この関数をファイル名の等価性の比較に使用しないこと。

Function: string< string1 string2 ¶

この関数は2つの文字列を1文字ずつ比較する。この関数は同時に2つの文字列をスキャンして、対応する文字同士がマッチしない最初のペアを探す。2つの文字列内で小さいほうの文字がstring1の文字ならstring1が小さいことになり、この関数はtをリターンする。小さいほうの文字がstring2の文字ならstring1が大きいことになり、この関数はnilをリターンする。2つの文字列が完全にマッチしたら値はnilになる。

文字のペアーは文字コードで比較される。ASCII文字セットでは英小文字は英大文字より高い数値をもつことに留意されたい。数字と区切り文字の多くは英大文字より低い数値をもつ。ASCII文字は任意の非ASCII文字より小さくなる。ユニバイトの非ASCII文字は、任意のマルチバイト非ASCII文字より常に小さくなります(テキストの表現方法を参照)。

(string< "abc" "abd")
     ⇒ t
(string< "abd" "abc")
     ⇒ nil
(string< "123" "abc")
     ⇒ t

文字列の長さが異なり、string1の長さまでマッチする場合、結果はtになる。string2の長さまでマッチする場合、結果はnilになる。文字を含まない文字列は、他の任意の文字列より小さくなる。

(string< "" "abc")
     ⇒ t
(string< "ab" "abc")
     ⇒ t
(string< "abc" "")
     ⇒ nil
(string< "abc" "ab")
     ⇒ nil
(string< "" "")
     ⇒ nil

引数としてシンボルを指定することもでき、この場合はシンボルのプリント名が比較される。

Function: string-lessp string1 string2 ¶: string-lesspはstring<の別名である。

Function: string-greaterp string1 string2 ¶: この関数は逆順でstring1とstring2を比較した結果をリタンーする。つまりこれは(string-lessp string2 string1)を呼び出すのと等価である。

Function: string-collate-lessp string1 string2 &optional locale ignore-case ¶

この関数は指定されたlocale (デフォルトはカレントのシステムlocale)の照合順において、string1がstring2より小さければtをリターンする。照合順はstring1とstring2に含まれる文字の辞書順だけではなく、それらの文字間の関係に関するルールによっても判断される。これは通常はEmacs実行中のlocale環境、およびEmacsとリンクされた標準Cライブラリーによって決定される。

たとえばソートでは区切り文字と空白文字は無視されるだろう(シーケンスを参照)。

(sort (list "11" "12" "1 1" "1 2" "1.1" "1.2") 'string-collate-lessp)
     ⇒ ("11" "1 1" "1.1" "12" "1 2" "1.2")

この振る舞いはシステム依存であり、例えばCygwinではlocaleに関係なく区切り文字と空白文字が無視されることは一切ない。

(sort (list "11" "12" "1 1" "1 2" "1.1" "1.2")
      (lambda (s1 s2) (string-collate-lessp s1 s2 "POSIX")))
     ⇒ ("1 1" "1 2" "1.1" "1.2" "11" "12")

locale環境をサポートしないシステムでは、この関数はstring-lesspと同様に振る舞う。

Function: string-version-lessp string1 string2 ¶: この関数は文字列を辞書順で比較するが、数字のシーケンスを10進数で構成されているかのように扱い、その数値を比較する。つまりたとえ辞書順で‘12’が‘2’より“小”だとしても、この述語に応じて‘foo12.png’より‘foo2.png’が“小”になる。

Function: string-prefix-p string1 string2 &optional ignore-case ¶: この関数はstring1がstring2のプレフィクス(たとえばstring2がstring1で始まる)なら、非nilをリターンする。オプションの引数ignore-caseが非nilなら、比較においてcaseの違いは無視される。

Function: string-suffix-p suffix string &optional ignore-case ¶: この関数はsuffixがstringのサフィックス(たとえばstringがsuffixで終わる)なら、非nilをリターンする。オプションの引数ignore-caseが非nilなら、比較においてcaseの違いは無視される。

Function: string-search needle haystack &optional start-pos ¶: haystack内で最初にneedle (いずれも文字列)が出現する位置をリターンする。start-posが非nilなら、検索はhaystack内のその位置から開始される。マッチ(一致するもの)が見つからなければnilをリターンする。この関数は比較を行う際にはテキストプロパティは無視して、文字列内の文字だけを考慮する。マッチングでは常にcaseを区別する。

Function: compare-strings string1 start1 end1 string2 start2 end2 &optional ignore-case ¶

この関数はstring1の指定部分をとstring2指定部分を比較する。string1の指定部分とは、インデックスstart1(その文字を含む)から、インデックスend1(その文字を含まない)まで。start1にnilを指定すると文字列の最初という意味になり、end1にnilを指定すると文字列の長さを意味する。同様にstring2の指定部分とはインデックスstart2からインデックスend2まで。

文字列は文字列内の文字の数値により比較される。たとえばstr1とstr2は、最初に異なる文字でstr1の文字の数値が小さければ小さいと判断される。ignore-caseが非nilなら比較を行なう前に、カレントバッファーのcaseテーブル(caseテーブルを参照)を使用して大文字に変換される。比較用にユニバイト文字列はマルチバイト文字列に変換されるので(テキストの表現方法を参照)、ユニバイト文字列とそれを変換したマルチバイト文字列は常に等しくなる。

2つの文字列の指定部分がマッチ(一致)した場合、値はtになる。それ以外なら値は整数で、何文字が一致してどちらの文字が小さいかを示す。この値の絶対値は、2つの文字列の先頭から一致した文字数に1加えた値になる。string1(または指定部分)のほうが小さければ符号は負になる。

Function: string-distance string1 string2 &optional bytecompare ¶

この関数はソース文字列string1とターゲット文字列string2の間のレーベンシュタイン距離(Levenshtein distance)をリターンする。レーベンシュタイン距離はソース文字列をターゲット文字列に変換(削除、挿入、置換)するために必要な単一文字の個数。これは文字列間の編集距離(edit distance)として使用可能な定義の1つである。

計算距離にとって文字列の英字のcase(大文字小文字)は意味をもつが、テキストプロパティは無視される。オプション引数bytecompareが非nilなら、この関数は文字ではなくバイトで計算する。バイト単位での比較はEmacsの内部的な文字表現を使用するので、rawバイトを含むマルチバイト文字列では不正確な結果を生成するかもしれない(テキストの表現方法を参照)。rawで正確な結果が必要なら、エンコードして文字列をユニバイトにすること(明示的なエンコードとデコードを参照)。

Function: assoc-string key alist &optional case-fold ¶: この関数はassocと同様に機能するが、keyは文字列かシンボルでなければならず、比較はcompare-stringsを使用して行なわれる。テストする前にシンボルは文字列に変換される。case-foldが非nilなら、keyとalistの要素は比較前に大文字に変換される。assocとは異なり、この関数はコンスではない文字列またはシンボルのalist要素もマッチできる。特にalistは実際のalistではなく、文字列またはリストでも可。連想リストを参照のこと。

バッファー内のテキストを比較する方法として、テキストの比較の関数compare-buffer-substringsも参照してください。文字列にたいして正規表現のマッチを行なう関数string-matchも、ある種の文字列比較に使用することができます。正規表現の検索を参照してください。

4.6 文字および文字列の変換

このセクションでは文字、文字列、整数の間で変換を行なう関数を説明します。format (文字列のフォーマットを参照)とprin1-to-string (出力関数を参照)もLispオブジェクトを文字列に変換できます。read-from-string (入力関数を参照)は、Lispオブジェクトの文字列表現をオブジェクトに“変換”できます。関数string-to-multibyteとstring-to-unibyteは、テキスト表現を文字列に変換します(テキスト表現の変換を参照)。

テキスト文字と一般的なインプットイベントにたいするテキスト記述を生成する関数(single-key-descriptionとtext-char-description)については、ドキュメントを参照してください。これらの関数は主にヘルプメッセージを作成するために使用されます。

Function: number-to-string number ¶

この関数はnumberの10進プリント表現からなる文字列をリターンする。引数が負ならリターン値はマイナス記号から開始される。

(number-to-string 256)
     ⇒ "256"

(number-to-string -23)
     ⇒ "-23"

(number-to-string -23.5)
     ⇒ "-23.5"

int-to-stringはこの関数にたいする半ば廃れたエイリアスである。

文字列のフォーマットの関数formatも参照されたい。

Function: string-to-number string &optional base ¶

この関数はstring内の文字の数値的な値をリターンする。baseが非nilなら値は2以上16以下でなければならず、整数はその基数に変換される。baseがnilなら基数に10が使用される。浮動小数点数の変換は基数が10のときだけ機能する。わたしたちは浮動小数点数にたいして他の基数を実装しない。なぜならこれには多くの作業を要し、その割にその機能が有用には思えないからだ。

パースではstringの先頭にあるスペースとタブはスキップして、与えられた基数で数字として解釈できるところまでstringを読み取る(スペースとタブだけではなく先頭にある他の空白文字を無視するシステムもある)。stringを数字として解釈できなければこの関数は0をリターンする。

(string-to-number "256")
     ⇒ 256
(string-to-number "25 is a perfect square.")
     ⇒ 25
(string-to-number "X256")
     ⇒ 0
(string-to-number "-4.5")
     ⇒ -4.5
(string-to-number "1e5")
     ⇒ 100000.0

string-to-intはこの関数にたいする半ば廃れたエイリアスである。

Function: char-to-string character ¶: この関数は1つの文字characterを含む新しい文字列をリターンする。関数stringのほうがより一般的であり、この関数は半ば廃れている。文字列の作成を参照のこと。

Function: string-to-char string ¶: この関数はstringの最初の文字をリターンする。これはほとんど(aref string 0)と同じで、例外は文字列が空のときに0をリターンすること(文字列の最初の文字がASCIIコード0のヌル文字のときも0をリターンする)。この関数は残すのに充分なほど有用と思えなければ、将来削除されるかもしれない。

以下は文字列へ／からの変換に使用できるその他の関数です:

concat: この関数はベクターまたはリストから文字列に変換する。文字列の作成を参照のこと。
vconcat: この関数は文字列をベクターに変換する。ベクターのための関数を参照のこと。
append: この関数は文字列をリストに変換する。コンスセルおよびリストの構築を参照のこと。
byte-to-string: この関数は文字データのバイトをユニバイト文字列に変換する。テキスト表現の変換を参照のこと。

4.7 文字列のフォーマット

フォーマット(formatting)とは、定数文字列内のさまざまな場所を計算された値で置き換えることにより、文字列を構築することを意味します。この定数文字列は他の値がどのようにプリントされるか、およびどこに表示するかを制御します。これはフォーマット文字列(format string)と呼ばれます。

表示されるメッセージを計算するためにフォーマットが便利なことがしばしばあります。実際に関数messageとerrorは、ここで説明する機能と同じフォーマットを提供します。これらの関数とformat-messageの違いはフォーマットされた結果を使用する方法だけです。

Function: format string &rest objects ¶

この関数はstringのすべてのフォーマット仕様を、対応するobjectsを復号化したものと置換したものと等しい文字列をリターンする。引数objectsはフォーマットされる計算値。

(もしあれば)string内のフォーマット仕様以外の文字はテキストプロパティを含めて出力に直接コピーされる。フォーマット仕様のすべてのテキストプロパティは引数objectsを表現する生成された文字列にコピーされる。

出力される文字列は新規に割り当てられる必要はない。たとえばxが文字列"foo"なら(eq x (format x))と(eq x (format "%s" x))はいずれもtとなるだろう。

Function: format-message string &rest objects ¶

この関数はformatと同様に機能するが、string内のすべてのグレイブアクセント(`)とアポストロフィー(')をtext-quoting-styleの各値に応じて変換する点が異なる。

フォーマット内のグレイブアクセントとアポストロフィーはマッチするcurved quotesに変換される("Missing `%s'"は"Missing ‘foo’"という結果になる)この変換の影響と回避についてはテキストのクォートスタイルを参照のこと。

フォーマット仕様(format specification)は‘%’で始まる文字シーケンスです。したがってstring内に‘%d’があるとformatはそれを、フォーマットされる値の1つ(引数objectsのうちの1つ)にたいするプリント表現で置き換えます。たとえば:

(format "The value of fill-column is %d." fill-column)
     ⇒ "The value of fill-column is 72."

formatは文字‘%’をフォーマット仕様と解釈するので、決して最初の引数に不定な文字列(arbitrary string)を渡すべきではありません。これは特に何らかのLispコードが生成した文字列の場合に当てはまります。その文字列が決して文字‘%’を含まないと確信できないならば、以下で説明するように最初の引数に"%s"を渡して、その不定な文字列を2番目の引数として渡します:

  (format "%s" arbitrary-string)

ある種のフォーマット仕様は特定の型の値を要求します。その要求に適合しない値を与えた場合にはエラーがシグナルされます。

以下は有効なフォーマット仕様のテーブルです:

‘%s’

フォーマット仕様を、クォートなしのオブジェクトのプリント表現で置き換える(つまりprin1ではなくprincを使用して置き換える。出力関数を参照されたい)。したがって文字列は‘"’文字なしの文字列内容だけが表示され、シンボルは‘\’文字なしで表される。

オブジェクトが文字列なら文字列のプロパティは出力にコピーされる。‘%s’のテキストプロパティ自身もコピーされるが、オブジェクトのテキストプロパティが優先される。

‘%S’

フォーマット仕様を、クォートありのオブジェクトのプリント表現で置き換える(つまりprin1を使用して変換する。出力関数を参照されたい)。したがって文字列は‘"’文字で囲まれ、必要となる特別文字の前に‘\’文字が表示される。

‘%o’ ¶

フォーマット仕様を整数の8進表現に置き換える。負の整数はプラットフォーム依存の方法でフォーマットされる。オブジェクトは浮動小数点数(小数部分を切り捨てて整数にフォーマット)でもよい。

‘%d’

フォーマット仕様を10進表現の符号つき整数で置き換える。オブジェクトは浮動小数点数(小数部分を切り捨てて整数にフォーマット)でもよい。

‘%x’ ¶

‘%X’

フォーマット仕様を16進表現の整数で置き換える。負の整数はプラットフォーム依存の方法でフォーマットされる。‘%x’なら小文字、‘%X’なら大文字が使用される。オブジェクトは小数部分を切り捨てて整数にフォーマットされた浮動小数点数でもよい。

‘%c’

フォーマット仕様を与えられた値の文字で置き換える。

‘%e’

フォーマット仕様を浮動小数点数の指数表現で置き換える。

‘%f’

フォーマット仕様を浮動小数点数にたいする10進小数表記で置き換える。

‘%g’

指数表記か小数点表記のいずれかを使用してフォーマット仕様を浮動小数点数にたいする表記に置き換える。指数が-4未満または精度(デフォルトは6)以上なら指数表記を使用する。デフォルトでは結果の小数部の末尾の0は削除されて、小数点が現れるのは後に数字が続く場合のみ。

‘%%’

フォーマット仕様を1つの‘%’で置き換える。このフォーマット仕様は唯一のフォームが素の‘%%’であり値を使用しないという点で特殊。たとえば(format "%% %d" 30)は"% 30"をリターンする。

他のフォーマット文字は‘Invalid format operation’エラーとなります。

以下は典型的なtext-quoting-styleのセッティングを想定した場合の例です:

(format "The octal value of %d is %o,
         and the hex value is %x." 18 18 18)
     ⇒ "The octal value of 18 is 22,
         and the hex value is 12."

(format-message
 "The name of this buffer is ‘%s’." (buffer-name))
     ⇒ "The name of this buffer is ‘strings-ja.texi’."

(format-message
 "The buffer object prints as `%s'." (current-buffer))
     ⇒ "The buffer object prints as ‘strings-ja.texi’."

フォーマット仕様はデフォルトではobjectsから連続して値を引き当てます。つまりstring内の1番目のフォーマット仕様は1番目の値、2番目のフォーマット仕様は2番目の値、...を使用します。余分なフォーマット仕様(対応する値がない場合)にはエラーとなります。フォーマットされる値が余分にある場合には無視されます。

フォーマット仕様はフィールド番号(field number)をもつことができます。これは最初の‘%’の直後に10進数字、その後にドル記号‘$’が続きます。これにより次の引数ではなく与えられた番号の引数をフォーマット仕様に変換させることができます。フィールド番号は1から始まります。フォーマットのフォーマット仕様が番号を含むことも含まないことも可能ですが、両方を含むことはできません。ただし例外は‘%%’であり、これは番号付きのフォーマット仕様と混交できます。

(format "%2$s, %3$s, %%, %1$s" "x" "y" "z")
     ⇒ "y, z, %, x"

‘%’とすべてのフィールド番号の後にフラグ文字(flag characters)を配置できます。

フラグ‘+’は非負の数の前にプラス符号を挿入するので、数には常に符号がつきます。フラグとしてスペースを指定すると、非負の数の前に1つのスペースが挿入されます(それ以外は非負の数は最初の数字から開始される)。これらのフラグは非負の数と負数にたいして確実に同じ列数を使用させるために有用です。これらは‘%d’、‘%e’、‘%f’、‘%g’以外では無視され、両方が指定された場合は‘+’が優先されます。

フラグ‘#’は代替形式(alternate form)を指定します。これは使用するフォーマットに依存します。‘%o’にたいしては結果を‘0’で開始させます。‘%x’と‘%X’にたいしては非0の結果のプレフィクスは‘0x’または‘0X’になります。‘%e’、‘%f’にたいしての‘#’フラグは、小数部が0のときにも小数点が含まれることを意味します。‘%g’にたいしては常に小数点が含まれるとともに、それ以外なら削除される小数点の後の末尾のすべての0も強制的に残されます。

フラグ‘0’はスペースの代わりに文字‘0’でパディングします。このフラグは‘%s’、‘%S’、‘%c’のような非数値のフォーマット仕様文字では無視されます。これらのフォーマット仕様文字で‘0’フラグを指定できますが、それでもスペースでパディングされます。

フラグ‘-’はフィールド幅指定子により挿入されるすべてのパディングに作用して、もしパディングが指定された場合には左側ではなく右側にパディングされます。‘-’と‘0’の両方が指定されると‘0’フラグは無視されます。

(format "%06d is padded on the left with zeros" 123)
     ⇒ "000123 is padded on the left with zeros"

(format "'%-6d' is padded on the right" 123)
     ⇒ "'123   ' is padded on the right"

(format "The word '%-7s' actually has %d letters in it."
        "foo" (length "foo"))
     ⇒ "The word 'foo    ' actually has 3 letters in it."

フォーマット仕様はフィールド幅(width)をもつことができます。これはすべてのフィールド番号とフラグの後にある10進の数字です。オブジェクトのプリント表現がこのフィールド幅より少ない文字を含む場合には、formatはパディングによりフィールド幅に拡張します。フォーマット仕様‘%%’ではフィールド幅の指定は無視されます。フィールド幅指定子により行なわれるパディングは、通常は左側に挿入されるスペースで構成されます:

(format "%5d is padded on the left with spaces" 123)
     ⇒ "  123 is padded on the left with spaces"

フィールド幅が小さすぎる場合でもformatはオブジェクトのプリント表現を切り詰めません。したがって情報を失う危険を犯すことなく、フィールドの最小幅を指定することができます。以下の2つの例では‘%7s’は最小幅に7を指定します。1番目の例では‘%7s’に挿入される文字列は3文字だけなので、4つのブランクスペースによりパディングされます。2番目の例では文字列"specification"は13文字ですが切り詰めはされません。

(format "The word '%7s' has %d letters in it."
        "foo" (length "foo"))
     ⇒ "The word '    foo' has 3 letters in it."
(format "The word '%7s' has %d letters in it."
        "specification" (length "specification"))
     ⇒ "The word 'specification' has 13 letters in it."

すべてのフォーマット仕様文字にはフィールド番号、フラグ、フィールド幅の後にオプションで精度(precision)を指定できます。精度は小数点‘.’と、その後に桁文字列(digit-string)を指定します。浮動小数点数のフォーマット仕様(‘%e’と‘%f’)では、精度は表示する小数点以下の桁数を指定します。0なら小数点も省略されます。%gの精度が0か未指定なら1として扱われます。‘%s’と‘%S’では精度として与えられた幅に文字列が切り詰められるので、‘%.3s’ではobjectの表現の最初の3文字だけが表示されます。その他の仕様文字では、printfファミリーのローカルライブラリーが生成する精度の効果が表れます。

‘%s’と‘%S’にたいしては、文字列を精度で指定された幅に切り詰めます。したがって‘%.3s’では、objectにたいするプリント表現の最初の3文字だけが表示されます。他のフォーマット仕様文字にたいしては、精度の効果はローカルライブラリーのprintf関数ファミリーが生成する効果となります。

フォーマット済みの値のコピーを取得するために後でreadを使用する予定なら、readが値を再構築する仕様を使用してください。この逆手順で数値をフォーマットするには‘%s’と‘%S’、整数だけなら‘%d’、非負の整数なら‘#x%x’と‘#o%o’も使用できます。その他のフォーマットでは問題があるかもしれません。たとえば‘%d’と‘%g’はNaNを誤って処理したり精度や型を失うかもしれず、‘#x%x’と‘#o%o’は負の整数を誤って処理するかもしれません。入力関数を参照してください。

このセクションでは仕様文字の固定セットを受け取る関数を説明します。次のセクションでは‘%a’や‘%z’のようなカスタム仕様文字を受け取ることができる関数format-specを説明します。

4.8 カスタムフォーマット文字列

ユーザーやLispプログラムが、カスタムフォーマットの制御文字列を介して特定のテキストが生成される方法を制御できるようにすると便利な場合があります。たとえばフォーマット文字列は人の姓や名、emailアドレスを表示する方法を制御できます。前のセクションで説明した関数formatを使用することにより、フォーマット文字列は"%s %s <%s>"のようになるかもしれません。しかしこのアプローチはどの仕様文字がどの情報に対応するかが不明瞭なのですぐに非実用的になります。

そのような場合には"%f %l <%e>"のようなフォーマット文字列のほうが便利かもしれません。このフォーマット文字列では仕様文字それぞれがより意味的な情報をもち、他の仕様文字に関連して簡単に再配置できるので、このようなフォーマット文字列はユーザーにより簡単にカスタマイズできます。

このセクションで説明する関数format-specはformatと同様の機能を処理しますが、任意の仕様文字を使用するフォーマットコントロール文字列を処理する点が異なります。

Function: format-spec template spec-alist &optional ignore-missing split ¶

この関数はspec-alistで指定された変換にしたがってフォーマット文字列templateから生成された文字列をリターンする。spec-alistは(letter . replacement)という形式のalist(連想リストを参照)。template内の仕様%letterはそれぞれ結果文字列のフォーマット時に置換される。

(もしあれば)template内のフォーマット仕様以外の文字はテキストプロパティを含めて出力に直接コピーされる。フォーマット仕様のすべてのテキストプロパティは置換先にコピーされる。

変換の指定にalistを使用することによって有用な特性がいくつか生成される:

template内に存在する一意な仕様文字より多くの一意なletterキーがspec-alistに含まれていると、使用されないキーは単に無視される。
同じletterにたいして複数の連想値がspec-alistに含まれていると、リスト先頭にもっとも近いものを使用する。
templateに同じ仕様文字が複数個含まれている場合には、その文字のすべての置換の基礎としてspec-alist内で見つけたreplacementを使用する。
template内の仕様の順序は、spec-alist内の連想値の順序に対応する必要はない。

REPLACEMENTは引数なしで呼び出されて置換に用いる文字列をリターンする関数でもよい。この関数はTEMPLATEで対応するLETTERが使用された際にのみ呼び出される。これはたとえば必要なとき以外は入力を求めるプロンプトの表示を避ける場合に役に立つかもしれない。

オプション引数ignore-missingは、spec-alistで見つからないtemplate内の仕様文字の処理方法を示す。nilか省略なら、関数はエラーをシグナルする。ignoreならこれらのフォーマット仕様は(もしあれば)テキストプロパティも含めてそのまま出力する。deleteならこれらのフォーマット仕様は出力から取り除かれる。これら以外の非nil値はignoreと同様に処理されるが、出力中に‘%%’があればそのまま残される。

オプション引数splitが非nilなら、format-specは単一文字列のかわりに置換場所を基準に結果を文字列リストに分割してリターンする。たとえば:

(format-spec "foo %b bar" '((?b . "zot")) nil t)
     ⇒ ("foo " "zot" " bar")

format-specが受け取るフォーマット仕様の構文はformatが受け取るフォーマット仕様と似ていますが同一ではありません。いずれの場合でもフォーマット仕様は‘%’で始まり‘s’のようなアルファベット文字で終わる文字シーケンスです。

仕様文字の固定セットに特定の意味を割り当てるformatとは異なり、format-specは任意の仕様文字を受け取ってそれらをすべて等しく扱います。たとえば:

(setq my-site-info
      (list (cons ?s system-name)
            (cons ?t (symbol-name system-type))
            (cons ?c system-configuration)
            (cons ?v emacs-version)
            (cons ?e invocation-name)
            (cons ?p (number-to-string (emacs-pid)))
            (cons ?a user-mail-address)
            (cons ?n user-full-name)))

(format-spec "%e %v (%c)" my-site-info)
     ⇒ "emacs 27.1 (x86_64-pc-linux-gnu)"

(format-spec "%n <%a>" my-site-info)
     ⇒ "Emacs Developers <emacs-devel@gnu.org>"

フォーマット仕様には置換の様相を変更するために、‘%’の直後に任意個数のフラグ文字を含めることができます。

‘0’: このフラグは指定された幅のパディングをスペースのかわりに‘0’で構成する。
‘-’: このフラグは指定された幅のパディングを左側ではなく右側に挿入する。
‘<’: このフラグはもし幅と精度が指定されたら置換の左側を切り捨てる。
‘>’: このフラグはもし幅と精度が指定されたら置換の右側を切り捨てる。
‘^’: このフラグは置換されるテキストを大文字に変換する(Lispでの大文字小文字変換を参照)。
‘_ (アンダースコアー)’: このフラグは置換されるテキストを小文字に変換する(Lispでの大文字小文字変換を参照)。

矛盾したフラグ(たとえば大文字と小文字)を使用した場合の結果は未定義です。

formatの場合と同様に幅(任意のフラグの後の10進数値)、精度(任意のフラグと幅の後の小数点‘.’に続く10進数)をフォーマット仕様に含めることができます。

指定した幅より置換の文字が少なければ左側がパディングされます。

(format-spec "%8a is padded on the left with spaces"
             '((?a . "alpha")))
     ⇒ "   alpha is padded on the left with spaces"

指定した精度より置換の文字が多ければ右側が切り詰められます。

(format-spec "%.2a is truncated on the right"
             '((?a . "alpha")))
     ⇒ "al is truncated on the right"

以下は前述の機能をいくつか組み合わせたより複雑な例です:

(setq my-battery-info
      (list (cons ?p "73")      ; パーセント表示
            (cons ?L "Battery") ; 状態
            (cons ?t "2:23")    ; 残り時間
            (cons ?c "24330")   ; 容量
            (cons ?r "10.6")))  ; 放電率

(format-spec "%>^-3L : %3p%% (%05t left)" my-battery-info)
     ⇒ "BAT :  73% (02:23 left)"

(format-spec "%>^-3L : %3p%% (%05t left)"
             (cons (cons ?L "AC")
                   my-battery-info))
     ⇒ "AC  :  73% (02:23 left)"

このセクションの例で示したように、format-specはさまざまな情報の断片を選択的にフォーマットするために頻繁に使用されます。これはプログラムが可能にする情報のサブセットだけをユーザーが通常の構文で望む順序で選択できるように、ユーザーにカスタマイズ可能なフォーマット文字列を提供するプログラムにとって有用です。

4.9 Lispでの大文字小文字変換

case変換関数(character case functions)は、1つの文字または文字列中の大文字小文字を変換します。関数は通常、アルファベット文字(英字‘A’から‘Z’と‘a’から‘z’、同様に非ASCIIの英字)だけを変換し、それ以外の文字は変換しません。caseテーブル(case table。caseテーブルを参照されたい)で指定することにより、caseの変換に異なるマッピングを指定できます。

これらの関数は引数として渡された文字列は変更しません。

以下の例では文字‘X’と‘x’を使用します。これらのASCIIコードは88と120です。

Function: downcase string-or-char ¶

この関数はstring-or-char(文字か文字列)を小文字に変換する。

string-or-charが文字列なら、この関数は引数の大文字を小文字に変換した新しい文字列をリターンする。string-or-charが文字なら、この関数は対応する小文字(整数)をリターンする。元の文字が小文字か非英字ならリターン値は元の文字と同じ。

(downcase "The cat in the hat")
     ⇒ "the cat in the hat"

(downcase ?X)
     ⇒ 120

Function: upcase string-or-char ¶

この関数はstring-or-char(文字か文字列)を大文字に変換する。

string-or-charが文字列なら、この関数は引数の小文字を大文字に変換した新しい文字列をリターンする。string-or-charが文字なら、この関数は対応する大文字(整数)をリターンする。元の文字が大文字か非英字ならリターン値は元の文字と同じ。

(upcase "The cat in the hat")
     ⇒ "THE CAT IN THE HAT"

(upcase ?x)
     ⇒ 88

Function: capitalize string-or-char ¶

この関数は文字列や文字をキャピタライズ(capitalize: 先頭が大文字で残りは小文字)する。この関数はstring-or-charが文字列ならstring-or-charの各単語をキャピタライズした新たなコピーをリターンする。これは各単語の最初の文字が大文字に変換され、残りは小文字に変換されることを意味する。

単語の定義はカレント構文テーブル(current syntax table)の単語構成構文クラス(word constituent syntax class)に割り当てられた、連続する文字の任意シーケンスである(構文クラスのテーブルを参照)。

string-or-charが文字ならこの関数はupcaseと同じことを行なう。

(capitalize "The cat in the hat")
     ⇒ "The Cat In The Hat"

(capitalize "THE 77TH-HATTED CAT")
     ⇒ "The 77th-Hatted Cat"

(capitalize ?x)
     ⇒ 88

Function: upcase-initials string-or-char ¶

この関数はstring-or-charが文字列なら、string-or-charの中の単語の頭文字をキャピタライズして、頭文字以外の文字は変更しない。この関数はstring-or-charの各単語の頭文字が大文字に変換された新しいコピーをリターンする。

upcase-initialsの引数が文字なら、upcase-initialsの結果はupcaseと同じ。

(upcase-initials "The CAT in the hAt")
     ⇒ "The CAT In The HAt"

case変換コードポイントを1対1でマップするものではなく、結果の文字列長は引数の文字列長と異なるかもしれません。さらに文字を渡すことによりリターンされる型にも文字が強制されるので、関数は正しい置換を行えずに1文字の文字列を処理する場合とは結果が異なるかもしれません。たとえば:

(upcase "ﬁ")  ; 注意: 1文字の合字 "fi"
     ⇒ "FI"

(upcase ?ﬁ)
     ⇒ 64257  ; つまり ?ﬁ

これを避けるためにはcase関数のいずれかに文字を渡す前にstring関数を使用して文字列に変換しなければなりません。もちろん結果の長さについて仮定はできません。

このような特殊ケースのマッピングはspecial-uppercase、special-lowercase、special-titlecaseから取得されます。文字のプロパティを参照してください。

文字列を比較する関数(caseの違いを無視するものや、オプションでcaseの違いを無視できるもの)については、文字および文字列の比較を参照されたい。

4.10 caseテーブル

特別なcaseテーブル(case table)をインストールすることにより、caseの変換をカスタマイズできます。caseテーブルは大文字と小文字の間のマッピングを指定します。caseテーブルはLispオブジェクトにたいするcase変換関数(前のセクションを参照)と、バッファー内のテキストに適用される関数の両方に影響します。それぞれのバッファーにはcaseテーブルがあります。新しいバッファーのcaseテーブルを初期化するために使用される、標準のcaseテーブル(standard case table)もあります。

caseテーブルは、サブタイプがcase-tableの文字テーブル(char-table。文字テーブルを参照)です。この文字テーブルはそれぞれの文字を対応する小文字にマップします。caseテーブルは、関連するテーブルを保持する3つの余分なスロットをもちます:

upcase: upcase(大文字)テーブルはそれぞれの文字を対応する大文字にマップする。
canonicalize: canonicalize(正準化)テーブルは、caseに関連する文字セットのすべてを、その文字セットの特別なメンバーにマップする。
equivalences: equivalence(同値)テーブルは、大文字・小文字に関連した文字セットのそれぞれを、そのセットの次の文字にマップする。

単純な例では、小文字へのマッピングを指定することだけが必要です。3つの関連するテーブルは、このマッピングから自動的に計算されます。

大文字と小文字が1対1で対応しない言語もいくつかあります。これらの言語では、2つの異なる小文字が同じ大文字にマップされます。このような場合、大文字と小文字の両方にたいするマップを指定する必要があります。

追加のcanonicalizeテーブルは、それぞれの文字を正準化された等価文字にマップします。caseに関連する任意の2文字は、同じ正準等価文字(canonical equivalent character)をもちます。たとえば‘a’と‘A’はcase変換に関係があるので、これらの文字は同じ正準等価文字(両方の文字が‘a’、または両方の文字が‘A’)をもつべきです。

追加のequivalencesテーブルは、等価クラスの文字(同じ正準等価文字をもつ文字)それぞれを循環的にマップします(通常のASCIIでは、これは‘a’を‘A’に‘A’を‘a’にマップし、他の等価文字セットにたいしても同様にマップする)。

caseテーブルを構築する際は、canonicalizeにnilを指定できます。この場合、Emacsは大文字と小文字のマッピングでこのスロットを充填します。equivalencesにたいしてnilを指定することもできます。この場合、Emacsはcanonicalizeからこのスロットを充填します。実際に使用されるcaseテーブルでは、これらのコンポーネントは非nilです。canonicalizeを指定せずにequivalencesを指定しないでください。

以下はcaseテーブルに作用する関数です:

Function: case-table-p object ¶: この述語は、objectが有効なcaseテーブルなら非nilをリターンする。

Function: set-standard-case-table table ¶: この関数はtableを標準caseテーブルにして、これ以降に作成される任意のバッファーにたいしてこのテーブルが使用されるようにする。

Function: standard-case-table ¶: これは標準caseテーブル(standard case table)をリターンする。

Function: current-case-table ¶: この関数はカレントバッファーのcaseテーブルをリターンする。

Function: set-case-table table ¶: これはカレントバッファーのcaseテーブルをtableにセットする。

Macro: with-case-table table body… ¶: with-case-tableマクロはカレントcaseテーブルを保存してから、tableをカレントcaseテーブルにセットし、その後にbodyフォームを評価してから、最後にcaseテーブルをリストアします。リターン値は、bodyの最後のフォームの値です。throwかエラー(非ローカル脱出を参照)により異常終了した場合でも、caseテーブルはリストアされます。

ASCII文字のcase変換を変更する言語環境(language environment)がいくつかあります。たとえばトルコ語の言語環境では、ASCIIの大文字‘I’にたいする小文字は、トルコ語のドットがないi(‘ı’)です。これは(ASCIIベースのネットワークプロトコル実装のような)ASCIIの通常のcase変換を要求するコードに干渉する可能性があります。このような場合には、変数ascii-case-tableにたいしてwith-case-tableマクロを使用してください。これにより変更されていないASCII文字セットのcaseテーブルが保存されます。

Variable: ascii-case-table ¶: ASCII文字セットにたいするcaseテーブル。すべての言語環境セッティングにおいて、これを変更するべきではない。

以下の3つの関数は、非ASCII文字セットを定義するパッケージにたいして便利なサブルーチンです。これらはcase-tableに指定されたcaseテーブルを変更します。これは標準構文テーブルも変更します。構文テーブルを参照してください。通常これらの関数は、標準caseテーブルを変更するために使用されます。

Function: set-case-syntax-pair uc lc case-table ¶: この関数は対応する文字のペアー(一方は大文字でもう一方は小文字)を指定する。

Function: set-case-syntax-delims l r case-table ¶: この関数は文字lとrを、case不変区切り(case-invariant delimiter)のマッチングペアーとする。

Function: set-case-syntax char syntax case-table ¶: この関数はcharを構文syntaxのcase不変(case-invariant)とする。

Command: describe-buffer-case-table ¶: このコマンドはカレントバッファーのcaseテーブルの内容にたいする説明を表示する。

5 リスト

リスト(list)は0個以上の要素(任意のLispオブジェクト)のシーケンスを表します。リストとベクターの重要な違いは、2つ以上のリストが構造の一部を共有できることです。加えて、リスト全体をコピーすることなく要素の挿入と削除ができます。

5.1 リストとコンスセル		コンスセルからリストが作られる方法。
5.2 リストのための述語		このオブジェクトはリストか? 2つのリストを比較する。
5.3 リスト要素へのアクセス		リストの一部を抽出する。
5.4 コンスセルおよびリストの構築		リスト構造の作成。
5.5 リスト変数の変更		変数に保存されたリストにたいする変更。
5.6 既存のリスト構造の変更		既存のリストに新しい要素を保存する。
5.7 集合としてのリストの使用		リストは有限な数学集合を表現できる。
5.8 連想リスト		リストは有限な関係またはマッピングを表現できる。
5.9 プロパティリスト		要素ペアのリスト。

5.1 リストとコンスセル

Lispでのリストは基本データ型ではありません。リストはコンスセル(cons cells)から構築されます(コンスセルとリスト型を参照)。コンスセルは順序つきペアを表現するデータオブジェクトです。つまりコンスセルは2つのスロットをもち、それぞれのスロットはLispオブジェクトを保持(holds)または参照(refers to)します。1つのスロットはCAR、もう1つはCDRです(これらの名前は歴史的なものである。コンスセルとリスト型を参照されたい)。CDRは“could-er(クダー)”と発音します。

わたしたちは、コンスセルのCARスロットに現在保持されているオブジェクトが何であれ、“このコンスセルのCARは、...”のような言い方をします。これはCDRの場合でも同様です。

リストとは互いに連なる(chained together)一連のコンスセルであり、各セルは次のセルを参照します。リストの各要素にたいして1つのコンスセルがあります。慣例によりコンスセルのCARはリストの要素を保持し、CDRはリストをチェーンするのに使用されます(CARとCDRの間の非対称性は完全に慣例的なものである。コンスセルのレベルではCARスロットとCDRスロットは同じようなプロパティをもつ)。したがって、リスト内の各コンスセルのCDRスロットは次のコンスセルを参照します。

これも慣例的なものですがリスト内の最後のコンスセルのCDRはnilです。わたしたちはこのようなnilで終端された構造を正リスト(proper list)と呼びます⁴。Emacs Lispではシンボルnilはシンボルであり、かつ要素なしのリストでもあります。便宜上、シンボルnilはそのCDR(とCAR)にnilをもつと考えます。

したがって正リストのCDRは常に正リストです。空でない正リストのCDRは1番目の要素以外を含む正リストです。

リストの最後のコンスセルのCDRがnil以外の何らかの値の場合、このリストのプリント表現はドットペア表記(dotted pair notation。ドットペア表記を参照のこと)を使用するので、わたしたちはこの構造をドットリスト(dotted list)と呼びます。他の可能性もあります。あるコンスセルのCDRが、そのリストのそれより前にある要素を指すかもしれません。わたしたちは、この構造を循環リスト(circular list)と呼びます。

ある目的においてはそのリストが正リストか循環リストなのか、あるいはドットリストなのかが問題にならない場合もあります。そのプログラムがリストを充分に辿って最後のコンスセルのCDRを確認しようとしないなら、これは問題になりません。しかしリストを処理する関数のいくつかは正リストを要求し、ドットリストの場合はエラーをシグナルします。リストの最後を探そうと試みる関数のほとんどは循環リストを与えると無限ループに突入します。リストが正リストかどうかを判断するためには、次セクションで説明する関数proper-list-p (proper-list-pを参照)を使うことができます。

ほとんどのコンスセルはリストの一部として使用されるので、わたしたちはコンスセルで構成される任意の構造をリスト構造(list structure)と呼びます。

5.2 リストのための述語

以下の述語はあるLispオブジェクトがアトムか、コンスセルか、リストなのか、またはオブジェクトがnilかどうかテストします(これらの述語の多くは他の述語で定義することもできるが、多用されるので個別に定義する価値がある)。

Function: consp object ¶: この関数はobjectがコンスセルならt、それ以外はnilをリターンする。たとえnilがリストであっても、コンスセルではない。

Function: atom object ¶

この関数はobjectがアトムならt、それ以外はnilをリターンする。シンボルnilはアトムであり、かつリストでもある。そのようなLispオブジェクトはnilだけである。

(atom object) ≡ (not (consp object))

Function: listp object ¶

この関数はobjectがコンスセルかnilならt、それ以外はnilをリターンする。

(listp '(1))
     ⇒ t

(listp '())
     ⇒ t

Function: nlistp object ¶

この関数はlistpの反対である。objectがリストでなければt、それ以外はnilをリターンする。

(listp object) ≡ (not (nlistp object))

Function: null object ¶

この関数はobjectがnilならt、それ以外はnilをリターンする。この関数はnotと等価だが、明解にするためにobjectをリストだと考えるときはnull、真偽値だと考えるときはnotを使用すること(組み合わせ条件の構築のnotを参照)。

(null '(1))
     ⇒ nil

(null '())
     ⇒ t

Function: proper-list-p object ¶

この関数はobjectが適正なリストならobjectの長さ、それ以外はnilをリターンする(リストとコンスセルを参照)。適正なリストとはlistpを満足することに加えて、循環リストやドットリストでもない。

(proper-list-p '(a b c))
    ⇒ 3

(proper-list-p '(a b . c))
    ⇒ nil

5.3 リスト要素へのアクセス

Function: car cons-cell ¶

この関数はコンスセルcons-cellの1番目のスロットが参照する値をリターンする。言い換えるとこの関数はcons-cellのCARをリターンする。

特別なケースとしてcons-cellがnilの場合、この関数はnilをリターンする。したがってリストはすべて引数として有効である。引数がコンスセルでもnilでもなければエラーがシグナルされる。

(car '(a b c))
     ⇒ a

(car '())
     ⇒ nil

Function: cdr cons-cell ¶

この関数はコンスセルcons-cellの2番目のスロットにより参照される値をリターンする。言い換えるとこの関数はcons-cellのCDRをリターンする。

特別なケースとしてcons-cellがnilの場合、この関数はnilをリターンする。したがってリストはすべて引数として有効である。引数がコンスセルでもnilでもければエラーがシグナルされる。

(cdr '(a b c))
     ⇒ (b c)

(cdr '())
     ⇒ nil

Function: car-safe object ¶

この関数により他のデータ型によるエラーを起こさずに、コンスセルのCARを取得できり。この関数はobjectがコンスセルならobjectのCAR、それ以外はnilをリターンする。この関数は、objectがリストでなければエラーをシグナルするcarとは対象的である。

(car-safe object)
≡
(let ((x object))
  (if (consp x)
      (car x)
    nil))

Function: cdr-safe object ¶

この関数により他のデータ型によるエラーを起こさずに、コンスセルのCDRを取得できる。この関数はobjectがコンスセルならobjectのCDR、それ以外はnilをリターンする。この関数は、objectがリストでないときはエラーをシグナルするcdrとは対象的である。

(cdr-safe object)
≡
(let ((x object))
  (if (consp x)
      (cdr x)
    nil))

Macro: pop listname ¶

このマクロはリストのCARを調べて、それをリストから取り去るのを一度に行なう便利な方法を提供する。この関数はlistnameに格納されたリストにたいして処理を行なう。この関数はリストから1番目の要素を削除して、CDRをlistnameに保存し、その後で削除した要素をリターンする。

もっとも単純なケースは、リストに名前をつけるためのクォートされていないシンボルの場合である。この場合、このマクロは(prog1 (car listname) (setq listname (cdr listname)))と等価である。

x
     ⇒ (a b c)
(pop x)
     ⇒ a
x
     ⇒ (b c)

より一般的なのはlistnameが汎変数(generalized variable)の場合である。この場合、このマクロはsetfを使用してlistnameに保存する。ジェネリック変数を参照のこと。

リストに要素を追加するpushマクロについてはリスト変数の変更を参照のこと。

Function: nth n list ¶

この関数はlistのn番目の要素をリターンする。要素は0から数えられるのでlistのCARは要素0になる。listの長さがn以下なら値はnil。

(nth 2 '(1 2 3 4))
     ⇒ 3

(nth 10 '(1 2 3 4))
     ⇒ nil

(nth n x) ≡ (car (nthcdr n x))

これは関数eltも類似しているが、任意の種類のシーケンスに適用される。歴史的な理由によりこの関数は逆の順序で引数を受け取る。シーケンスを参照のこと。

Function: nthcdr n list ¶

この関数はlistのn番目のCDRをリターンする。言い換えると、この関数はlistの最初のn個のリンクをスキップしてから、それ以降をリターンする。

nが0ならnthcdrはlist全体をリターンする。listの長さがn以下ならnthcdrはnilをリターンする。

(nthcdr 1 '(1 2 3 4))
     ⇒ (2 3 4)

(nthcdr 10 '(1 2 3 4))
     ⇒ nil

(nthcdr 0 '(1 2 3 4))
     ⇒ (1 2 3 4)

Function: take n list ¶

この関数はlistの最初のn個の要素をリターンする。要するにlistからnthcdrをスキップした部分をリターンする。

listの要素の数がnより少なければlist、nが0か負ならnilをリターンする。

(take 3 '(a b c d))
     ⇒ (a b c)

(take 10 '(a b c d))
     ⇒ (a b c d)

(take 0 '(a b c d))
     ⇒ nil

Function: ntake n list ¶

これは引数であるリストの構造を破壊的に変更することによって機能するバージョンのtakeである。これにより高速になるが、listの元の値は失われるだろう。

ntakeは要素の数がnより少なければ変更せずにlistを、nが0か負ならnilをリターンする。それ以外の場合には最初のn個の要素に切り詰められたlistをリターンする。

これはnが正だと判っていない場合には単純に切り詰め効果を信頼するのではなく、通常はリターン値を使うほうが賢明だということを意味している。

Function: last list &optional n ¶: この関数はlistの最後のリンクをリターンする。このリンクのcarはこのリストの最後の要素。listがnullならnilがリターンされる。nが非nilならn番目から最後までのリンクがリターンされる。nがlistの長さより大きければlist全体がリターンされる。

Function: safe-length list ¶

この関数はエラーや無限ループの危険なしで、listの長さをリターンする。この関数は一般的に、リスト内のコンスセルの個数をリターンする。しかし循環リストでは単に上限値が値となるため、非常に大きくなる場合があります。

listがnilとコンスセルのいずれでもなければsafe-lengthは0をリターンする。

循環リストを考慮しなくてもよい場合にリストの長さを計算するもっとも一般的な方法は、lengthを使う方法です。シーケンスを参照してください。

Function: caar cons-cell ¶: これは(car (car cons-cell))と同じ。

Function: cadr cons-cell ¶: これは(car (cdr cons-cell))か(nth 1 cons-cell)と同じ。

Function: cdar cons-cell ¶: これは(cdr (car cons-cell))と同じ。

Function: cddr cons-cell ¶: これは(cdr (cdr cons-cell))か(nthcdr 2 cons-cell)と同じ。

上記に加えてcxxxrやcxxxxrのようなcarとcdrで構成される24の関数が定義されています。ここでxはaかdのいずれかです。cadrとcaddrとcadddrはそれぞれリストの2つ目、3つ目、4つ目の要素です。cl-libは同じものをcl-second、cl-third、cl-fourthという名前で提供しています。List Functions in Common Lisp Extensionsを参照してください。

Function: butlast x &optional n ¶: この関数はリストxから、最後の要素か最後のn個の要素を削除してリターンする。nが0より大きければこの関数はリストのコピーを作成するので、元のリストに影響はない。一般的に(append (butlast x n) (last x n))は、xと等しいリストをリターンする。

Function: nbutlast x &optional n ¶: この関数はリストのコピーを作成するのではなく、cdrを適切な要素に変更することにより破壊的に機能するバージョンのbutlastである。

5.4 コンスセルおよびリストの構築

リストはLispの中核にあたる機能なので、リストを構築するために多くの関数があります。consはリストを構築する基本的な関数です。しかしEmacsのソースコードでは、consよりlistのほうが多く使用されているのは興味深いことです。

Function: cons object1 object2 ¶

この関数は新しいリスト構造を構築するための、もっとも基本的な関数である。この関数はobject1をCAR、object2をCDRとする新しいコンスセルを作成して、それから新しいコンスセルをリターンする。引数object1とobject2には任意のLispオブジェクトを指定できるが、ほとんどの場合object2はリストである。

(cons 1 '(2))
     ⇒ (1 2)

(cons 1 '())
     ⇒ (1)

(cons 1 2)
     ⇒ (1 . 2)

リストの先頭に1つの要素を追加するために、consがよく使用される。これをリストに要素をコンスすると言います。⁵たとえば:

(setq list (cons newelt list))

この例で使用されているlistという名前の変数と、以下で説明するlistという名前の関数は競合しないことに注意されたい。すべてのシンボルが、変数と関数の両方の役割を果たすことができる。

Function: list &rest objects ¶

この関数はobjectsを要素とするリストを作成する。結果となるリストは常にnilで終端される。objectsを指定しないと空リストがリターンされる。

(list 1 2 3 4 5)
     ⇒ (1 2 3 4 5)

(list 1 2 '(3 4 5) 'foo)
     ⇒ (1 2 (3 4 5) foo)

(list)
     ⇒ nil

Function: make-list length object ¶

この関数は各要素がobjectであるような、length個の要素からなるリストを作成する。make-listとmake-string(文字列の作成を参照)を比較してみよ。

(make-list 3 'pigs)
     ⇒ (pigs pigs pigs)

(make-list 0 'pigs)
     ⇒ nil

(setq l (make-list 3 '(a b)))
     ⇒ ((a b) (a b) (a b))
(eq (car l) (cadr l))
     ⇒ t

Function: append &rest sequences ¶

この関数はsequencesのすべての要素を含むリストをreturnします。sequencesにはリスト、ベクター、ブールベクター、文字列も指定できるが、通常は最後にリストを指定すること。最後の引数を除くすべての引数はコピーされるので、変更される引数はない(コピーを行なわずにリストを結合する方法についてはリストを再配置する関数のnconcを参照のこと)。

より一般的にはappendにたいする最後の引数は任意のLispオブジェクトを指定できる。最後の引数のコピーや変換は行わない。最後の引数は新しいリストの最後のコンスセルのCDRとなる。最後の引数もリストならば、このリストの要素は実質的には結果リストの要素になる。最後の要素がリストでなければ、最後のCDRが(正リストで要求される)nilではないので結果はドットリストになる(リストとコンスセルを参照)。

以下はappendを使用した例です:

(setq trees '(pine oak))
     ⇒ (pine oak)
(setq more-trees (append '(maple birch) trees))
     ⇒ (maple birch pine oak)

trees
     ⇒ (pine oak)
more-trees
     ⇒ (maple birch pine oak)

(eq trees (cdr (cdr more-trees)))
     ⇒ t

appendがどのように機能するか、ボックスダイアグラムで確認できます。変数treesはリスト(pine oak)にセットされ、それから変数more-treesにリスト(maple birch pine oak)がセットされます。しかし変数treesは継続して元のリストを参照します:

more-trees                trees
|                           |
|     --- ---      --- ---   -> --- ---      --- ---
 --> |   |   |--> |   |   |--> |   |   |--> |   |   |--> nil
      --- ---      --- ---      --- ---      --- ---
       |            |            |            |
       |            |            |            |
        --> maple    -->birch     --> pine     --> oak

空のシーケンスはappendによりリターンされる値に寄与しません。この結果、最後の引数にnilを指定すると、それより前の引数のコピーを強制することになります。

trees
     ⇒ (pine oak)

(setq wood (append trees nil))
     ⇒ (pine oak)

wood
     ⇒ (pine oak)

(eq wood trees)
     ⇒ nil

関数copy-sequenceが導入される以前は,これがリストをコピーする通常の方法でした。シーケンス、配列、ベクターを参照してください。

以下はappendの引数としてベクターと文字列を使用する例です:

(append [a b] "cd" nil)
     ⇒ (a b 99 100)

apply (関数の呼び出しを参照)の助けを借りることにより、リストのリストの中のすべてのリストをappendできます。

(apply 'append '((a b c) nil (x y z) nil))
     ⇒ (a b c x y z)

sequencesが与えられなければnilがリターンされます:

(append)
     ⇒ nil

以下は最後の引数がリストでない場合の例です:

(append '(x y) 'z)
     ⇒ (x y . z)
(append '(x y) [z])
     ⇒ (x y . [z])

2番目の例は最後の引数はリストではないシーケンスの場合で、このシーケンスの要素は、結果リストの要素にはなりません。かわりに最後の引数がリストでないときと同様、シーケンスが最後のCDRになります。

Function: copy-tree tree &optional vecp ¶

この関数はツリーtreeのコピーをリターンする。treeがコンスセルなら同じCARとCDRをもつ新しいコンスセルを作成してから、同じ方法によってCARとCDRを再帰的にコピーする。

treeがコンスセル以外の場合、通常はcopy-treeは単にtreeをリターンする。しかしvecpが非nilなら、この関数はベクターでもコピーします(そしてベクターの要素を再帰的に処理する)。

Function: flatten-tree tree ¶: この関数はtreeを“平坦化”したコピー( treeをルートとするコンスセルのツリーのすべての非nilな終端nodeとleave)をリターンする。リターンされたリストのleaveの順序はtreeでの順序と同じ。

(flatten-tree '(1 (2 . 3) nil (4 5 (6)) 7))
    ⇒(1 2 3 4 5 6 7)

Function: ensure-list object ¶

この関数はobjectをリストとしてリターンする。objectがすでにリストならそれをリターンし、それ以外ならobjectを含む1要素のリストをリターンする。

これは通常はリストのときもあればそうでないときもある変数を使用する場合に有用であり、たとえば以下のような記述ができる:

(dolist (elem (ensure-list foo))
  (princ elem))

Function: number-sequence from &optional to separation ¶

この関数はfromからseparationずつインクリメントして、toの直前で終わる数字のリストをリターンする。separationには正か負の数を指定でき、デフォルトは1。toがnil、または数値的にfromと等しければ、値は1要素のリスト(from)になる。separationが正でtoがfromより小さい、またはseparationが負でtoがfromより大きければ、これらの引数は空のシーケンスを指示することになるので、値はnilになる。

separationが0で、toがnilでもなく、数値的にfromとも等しくなければ、これらの引数は無限シーケンスを指示することになるので、エラーがシグナルされる。

引数はすべて数字である。浮動小数点数の計算は正確ではないので、浮動小数点数の引数には注意する必要がある。たとえばマシンへの依存により、(number-sequence 0.4 0.8 0.2)が3要素のリストをリターンして、(number-sequence 0.4 0.6 0.2)が1要素のリスト(0.4)をリターンすることがよく起こる。リストのn番目の要素は、厳密に(+ from (* n separation))という式により計算される。リストに確実にtoが含まれるようにするために、この式に適切な型のtoを渡すことができる。別の方法としてtoを少しだけ大きな値(separationが負なら少しだけ小さな値)に置き換えることもできる。

例をいくつか示す:

(number-sequence 4 9)
     ⇒ (4 5 6 7 8 9)
(number-sequence 9 4 -1)
     ⇒ (9 8 7 6 5 4)
(number-sequence 9 4 -2)
     ⇒ (9 7 5)
(number-sequence 8)
     ⇒ (8)
(number-sequence 8 5)
     ⇒ nil
(number-sequence 5 8 -1)
     ⇒ nil
(number-sequence 1.5 6 2)
     ⇒ (1.5 3.5 5.5)

5.5 リスト変数の変更

以下の関数と1つのマクロは、変数に格納されたリストを変更する便利な方法を提供します。

Macro: push element listname ¶

このマクロはCARがelementで、CDRがlistnameのリストであるような新しいリストを作成して、そのリストをlistnameに保存する。listnameがリストに名前をつけるクォートされていないシンボルのときは単純で、この場合マクロは(setq listname (cons element listname))と等価になる。

(setq l '(a b))
     ⇒ (a b)
(push 'c l)
     ⇒ (c a b)
l
     ⇒ (c a b)

より一般的なのはlistnameが汎変数の場合である。この場合、このマクロは(setf listname (cons element listname))と等価になる。ジェネリック変数を参照のこと。

リストから1番目の要素を取り出すpopマクロについては、リスト要素へのアクセスを参照されたい。

以下の2つの関数は、変数の値であるリストを変更します。

Function: add-to-list symbol element &optional append compare-fn ¶

この関数はelementがsymbolの値のメンバーでなければ、symbolにelementをコンスすることにより、変数symbolをセットする。この関数はリストが更新されているか否かに関わらず、結果のリストをリターンする。symbolの値は呼び出し前にすでにリストであることが望ましい。elementがリストの既存メンバーか比較するために、add-to-listはcompare-fnを使用する。compare-fnがnilならequalを使用する。

elementが追加される場合は、通常はsymbolの前に追加されるが、オプションの引数appendが非nilなら最後に追加される。

引数symbolは暗黙にクォートされない。setqとは異なりadd-to-listはsetのような通常の関数である。クォートしたい場合には自分で引数をクォートすること。

symbolがレキシカル変数を参照する際にはこの関数を使用しないこと。

以下にadd-to-listを使用する方法をシナリオで示します:

(setq foo '(a b))
     ⇒ (a b)

(add-to-list 'foo 'c)     ;; cを追加
     ⇒ (c a b)

(add-to-list 'foo 'b)     ;; 効果なし
     ⇒ (c a b)

foo                       ;; fooが変更された
     ⇒ (c a b)

以下は(add-to-list 'var value)と等価な式です:

(if (member value var)
    var
  (setq var (cons value var)))

Function: add-to-ordered-list symbol element &optional order ¶

この関数は古い値のorder (リストであること)で指定された位置に、elementを挿入して変数symbolをセットする。elementがすでにこのリストのメンバなら、リスト内の要素の位置はorderにしたがって調整される。メンバーか否かはeqを使用してテストされる。この関数は更新されているかどうかに関わらず、結果のリストをリターンする。

orderは通常は数字(整数か浮動小数点数)で、リストの要素はその数字の昇順で並べられる。

orderは省略またはnilを指定できる。これによりリストにelementがすでに存在するなら、elementの数字順序は変更されない。それ以外ならelementは数字順序をもたない。リストの数字順序をもたない要素はリストの最後に配置され、特別な順序はつかない。

orderに他の値を指定すると、elementがすでに数字順序をもつときは数字順序が削除される。それ以外はならnilと同じ。

引数symbolは暗黙にクォートされない。add-to-ordered-listはsetqなどとは異なり、setのような通常の関数である。必要なら引数を自分でクォートすること。

順序の情報はsymbolのlist-orderプロパティにハッシュテーブルで保存される。symbolはレキシカル変数を参照できない。

以下にadd-to-ordered-listを使用する方法をシナリオで示します:

(setq foo '())
     ⇒ nil

(add-to-ordered-list 'foo 'a 1)     ;; aを追加
     ⇒ (a)

(add-to-ordered-list 'foo 'c 3)     ;; cを追加
     ⇒ (a c)

(add-to-ordered-list 'foo 'b 2)     ;; bを追加
     ⇒ (a b c)

(add-to-ordered-list 'foo 'b 4)     ;; bを移動
     ⇒ (a c b)

(add-to-ordered-list 'foo 'd)       ;; dを後に追加
     ⇒ (a c b d)

(add-to-ordered-list 'foo 'e)       ;; eを追加
     ⇒ (a c b e d)

foo                       ;; fooが変更された
     ⇒ (a c b e d)

5.6 既存のリスト構造の変更

プリミティブsetcarとsetcdrでコンスセルのCARおよびCDRのコンテンツを変更できます。これらは既存のリスト構造を変更するので破壊的な操作です。破壊的操作はmutable(変更可能)なリスト、すなわちcons、list、または類似の操作により構築される必要があります。クォートにより作成されたリストはプログラムの一部であり、破壊的な操作により変更するべきではありません。可変性を参照してください。

Common Lispに関する注意: Common Lispはリスト構造の変更にrplacaとrplacdを使用する。これらはsetcarやsetcdrと同じ方法でリスト構造を変更するが、setcarとsetcdrは新しいCARやCDRをリターンするのにたいして、Common Lispの関数はコンスセルをリターンする。

5.6.1 `setcar`によるリスト要素の変更

コンスセルのCARの変更はsetcarで行ないます。リストにたいして使用するとsetcarはリストの1つの要素を別の要素に置き換えます。

Function: setcar cons object ¶

この関数は以前のCARを置き換えて、consの新しいCARにobjectを格納する。言い換えると、この関数はconsのCARスロットをobjectを参照するように変更する。この関数は値objectをリターンする。たとえば:

(setq x (list 1 2))
     ⇒ (1 2)

(setcar x 4)
     ⇒ 4

x
     ⇒ (4 2)

コンスセルが複数のリストを共有する構造の一部なら、コンスに新しいCARを格納することにより、これら共有されたリストの各1つの要素を変更します。以下は例です:

;; 部分的に共有された2つのリストを作成
(setq x1 (list 'a 'b 'c))
     ⇒ (a b c)
(setq x2 (cons 'z (cdr x1)))
     ⇒ (z b c)

;; 共有されたリンクのCARを置き換え
(setcar (cdr x1) 'foo)
     ⇒ foo
x1                           ; 両方のリストが変更された
     ⇒ (a foo c)
x2
     ⇒ (z foo c)

;; 共有されていないリンクのCARを置き換え
(setcar x1 'baz)
     ⇒ baz
x1                           ; 1つのリストだけが変更された
     ⇒ (baz foo c)
x2
     ⇒ (z foo c)

なぜbを置き換えると両方が変更されるのかを説明するために、変数x1とx2の2つのリストによる共有構造を視覚化してみましょう:

        --- ---        --- ---      --- ---
x1---> |   |   |----> |   |   |--> |   |   |--> nil
        --- ---        --- ---      --- ---
         |        -->   |            |
         |       |      |            |
          --> a  |       --> b        --> c
                 |
       --- ---   |
x2--> |   |   |--
       --- ---
        |
        |
         --> z

同じ関係を別のボックス図で示すと、以下のようになります:

x1:
 --------------       --------------       --------------
| car   | cdr  |     | car   | cdr  |     | car   | cdr  |
|   a   |   o------->|   b   |   o------->|   c   |  nil |
|       |      |  -->|       |      |     |       |      |
 --------------  |    --------------       --------------
                 |
x2:              |
 --------------  |
| car   | cdr  | |
|   z   |   o----
|       |      |
 --------------

5.6.2 リストのCDRの変更

CDRを変更するもっとも低レベルのプリミティブ関数はsetcdrです:

Function: setcdr cons object ¶: この関数は前のCDRを置き換えて、consの新しいCDRにobjectを格納する。言い換えると、この関数はconsのCDRがobjectを参照するように変更する。この関数は値objectをリターンする。

以下はリストのCDRを、他のリストに置き換える例です。1番目の要素以外のすべての要素は、別のシーケンスまたは要素のために取り除かれます。1番目の要素はリストのCARなので変更されず、CDRを通じて到達することもできないからです。

(setq x (list 1 2 3))
     ⇒ (1 2 3)

(setcdr x '(4))
     ⇒ (4)

x
     ⇒ (1 4)

リスト内のコンスセルのCDRを変更することにより、リストの途中から要素を削除できます。たとえば以下では、1番目のコンスセルのCDRを変更することにより、2番目の要素bをリスト(a b c)から削除します。

(setq x1 (list 'a 'b 'c))
     ⇒ (a b c)
(setcdr x1 (cdr (cdr x1)))
     ⇒ (c)
x1
     ⇒ (a c)

以下に結果をボックス表記で示します:

                   --------------------
                  |                    |
 --------------   |   --------------   |    --------------
| car   | cdr  |  |  | car   | cdr  |   -->| car   | cdr  |
|   a   |   o-----   |   b   |   o-------->|   c   |  nil |
|       |      |     |       |      |      |       |      |
 --------------       --------------        --------------

以前は要素bを保持していた2番目のコンスセルは依然として存在し、そのCARもbのままですが、すでにこのリストの一部を形成していません。

CDRを変更して新しい要素を挿入するのも同じくらい簡単です:

(setq x1 (list 'a 'b 'c))
     ⇒ (a b c)
(setcdr x1 (cons 'd (cdr x1)))
     ⇒ (d b c)
x1
     ⇒ (a d b c)

以下に結果をボックス表記で示します:

 --------------        -------------       -------------
| car  | cdr   |      | car  | cdr  |     | car  | cdr  |
|   a  |   o   |   -->|   b  |   o------->|   c  |  nil |
|      |   |   |  |   |      |      |     |      |      |
 --------- | --   |    -------------       -------------
           |      |
     -----         --------
    |                      |
    |    ---------------   |
    |   | car   | cdr   |  |
     -->|   d   |   o------
        |       |       |
         ---------------

5.6.3 リストを再配置する関数

以下ではリストの構成要素であるコンスセルのCDRを変更することにより、リストを破壊的に再配置する関数をいくつか示します。これらの関数が破壊的だという理由は、これらの関数が引数として渡された元のリストを処理してリターン値となる新しいリストを形成するために、リストのコンスセルを再リンクするからです。

コンスセルを変更する他の関数については、集合としてのリストの使用のdelqを参照してください。

Function: nconc &rest lists ¶

この関数はlistsの要素すべてを含むリストをリターンする。append (コンスセルおよびリストの構築を参照)とは異なり、listsはコピーされない。かわりにlistsの各リストの最後のCDRが次のリストを参照するように変更される。listsの最後のリストは変更されない。たとえば:

(setq x (list 1 2 3))
     ⇒ (1 2 3)

(nconc x '(4 5))
     ⇒ (1 2 3 4 5)

x
     ⇒ (1 2 3 4 5)

nconcの最後の引数は変更されないので、上記の例のように'(4 5)のような定数リストを使用するのが合理的である。また同じ理由により最後の引数がリストである必要はない。

(setq x (list 1 2 3))
     ⇒ (1 2 3)

(nconc x 'z)
     ⇒ (1 2 3 . z)

x
     ⇒ (1 2 3 . z)

しかし他の(最後を除くすべての)引数はmutableリストでなければなければならない。

一般的な落とし穴としては、nconcにたいしてリスト定数を最後以外の引数として使用した場合である。これを行なった場合の結果としての挙動は未定義である(自己評価を行うフォームを参照)。実行するごとにプログラムはリスト定数を変更する可能性がある! (必ず発生する保証はないが)以下のようなことが起こり得る:

(defun add-foo (x)            ; この関数ではfoo
  (nconc '(foo) x))           ;   を引数の前に追加したい

(symbol-function 'add-foo)
     ⇒ (lambda (x) (nconc '(foo) x))

(setq xx (add-foo '(1 2)))    ; 動いているように見える
     ⇒ (foo 1 2)

(setq xy (add-foo '(3 4)))    ; 何が起きているのか?
     ⇒ (foo 1 2 3 4)

(eq xx xy)
     ⇒ t

(symbol-function 'add-foo)
     ⇒ (lambda (x) (nconc '(foo 1 2 3 4) x))

5.7 集合としてのリストの使用

リストは順序なしの数学的集合 — リスト内に要素があれば集合の要素の値としてリスト内の順序は無視される — を表すことができます。2つの集合を結合(union)するには、(重複する要素を気にしなければ)appendを使用します。equalである重複を取り除くにはdelete-dupsやseq-uniqを使用します。集合にたいする他の有用な関数にはmemqやdelqや、それらのequalバージョンであるmemberとdeleteが含まれます。

Common Lispに関する注意: 集合を処理するためにCommon Lispには関数union (要素の重複がない)とintersectionがある。Emacs Lispではcl-libがこれらの変種を提供する。Lists as Sets in Common Lisp Extensionsを参照のこと。

Function: memq object list ¶

この関数はobjectがlistのメンバーかどうかをテストする。メンバーならmemqは、objectで最初に見つかった要素から開始されるリストをリターンする。メンバーでなければnilをリターンする。memqの文字‘q’は、この関数がobjectとリスト内の要素の比較にeqを使用することを示す。たとえば:

(memq 'b '(a b c b a))
     ⇒ (b c b a)

(memq '(2) '((1) (2)))    ; 2つの(2)がeqである必要はない
     ⇒ 未定義; nilか((2))かも

Function: delq object list ¶

この関数はlistからobjectとeqであるような、すべての要素を破壊的に取り除いて結果のリストをリターンする。delqの文字‘q’は、この関数がobjectとリスト内の要素の比較にeqを使用することを示す(memqやremqと同様)。

delqを呼び出すときは、通常は元のリストを保持していた変数にリターン値を割り当てて使用する必要がある(理由は以下参照)。

delq関数がリストの先頭にある要素を削除する場合は、単にリストを読み進めてこの要素の後から開始される部分リストをリターンします。つまり:

(delq 'a '(a b c)) ≡ (cdr '(a b c))

リストの途中にある要素を削除するときは、必要なCDR (リストのCDRの変更を参照)を変更することで削除を行います。

(setq sample-list (list 'a 'b 'c '(4)))
     ⇒ (a b c (4))

(delq 'a sample-list)
     ⇒ (b c (4))

sample-list
     ⇒ (a b c (4))

(delq 'c sample-list)
     ⇒ (a b (4))

sample-list
     ⇒ (a b (4))

(delq 'a sample-list)は何も取り除きませんが(単に短いリストをリターンする)、(delq 'c sample-list)は3番目の要素を取り除いてsample-listを変更することに注意してください。引数listを保持するように形成された変数が、実行後にもっと少ない要素になるとか、元のリストを保持すると仮定しないでください! かわりにdelqの結果を保存して、それを使用してください。元のリストを保持していた変数に結果を書き戻すことはよく行なわれます。

(setq flowers (delq 'rose flowers))

以下の例では、delqが比較しようとしている(list 4)とsample-list内の(4)は、equalですがeqではありません:

(delq (list 4) sample-list)
     ⇒ (a c (4))

与えられた値とequalな要素を削除したい場合には、delete (以下参照)を使用してください。

Function: remq object list ¶

この関数はobjectとeqなすべての要素が除かれた、listのコピーをリターンする。remqの文字‘q’は、この関数がobjectとリスト内の要素の比較にeqを使用することを示す。

(setq sample-list (list 'a 'b 'c 'a 'b 'c))
     ⇒ (a b c a b c)

(remq 'a sample-list)
     ⇒ (b c b c)

sample-list
     ⇒ (a b c a b c)

Function: memql object list ¶

関数memqlはeql(浮動小数点数の要素は値で比較される)を使用してメンバーとeqlを比較することにより、objectがlistのメンバーかどうかをテストする。objectがメンバーなら、memqlはlist内で最初に見つかった要素から始まるリスト、それ以外ならnilをリターンする。

memqと比較してみよう:

(memql 1.2 '(1.1 1.2 1.3))  ; 1.2と1.2はeql。
     ⇒ (1.2 1.3)

(memq 1.2 '(1.1 1.2 1.3))  ; 2つの1.2がeqである必要はない
     ⇒ 未定義; nilか(1.2 1.3)かもしれない

以下の3つの関数はmemq、delq、remqと似ていますが、要素の比較にeqではなくequalを使用します。同等性のための述語を参照してください。

Function: member object list ¶

関数memberは、メンバーとobjectをequalを使用して比較して、objectがlistのメンバーかどうかをテストする。objectがメンバーなら、memberはlistで最初に見つかったところから開始されるリスト、それ以外ならnilをリターンする。

memqと比較してみよう:

(member '(2) '((1) (2)))  ; (2) and (2) are equal.
     ⇒ ((2))

(memq '(2) '((1) (2)))    ; 2つの(2)がeqである必要はない
     ⇒ 未定義; nilか(2)かもしれない

;; 同じ内容の2つの文字列はequal
(member "foo" '("foo" "bar"))
     ⇒ ("foo" "bar")

Function: delete object sequence ¶

この関数はsequenceからobjectとequalな要素を取り除いて、結果のシーケンスをリターンする。

sequenceがリストなら、deleteがdelqに対応するように、memberはmemqに対応する。つまりこの関数はmemberと同様、要素とobjectの比較にequalを使用する。マッチする要素が見つかったら、delqが行なうようにその要素を取り除く。delqと同様、通常は元のリストを保持していた変数にリターン値を割り当てて使用する。

sequenceがベクターか文字列なら、deleteはobjectとequalなすべての要素を取り除いたsequenceのコピーをリターンする。

たとえば:

(setq l (list '(2) '(1) '(2)))
(delete '(2) l)
     ⇒ ((1))
l
     ⇒ ((2) (1))
;; lの変更に信頼性を要するときは
;; (setq l (delete '(2) l))と記述する。

(setq l (list '(2) '(1) '(2)))
(delete '(1) l)
     ⇒ ((2) (2))
l
     ⇒ ((2) (2))
;; このケースではlのセットの有無に違い
;; はないが他のケースに倣ってセットするべき

(delete '(2) [(2) (1) (2)])
     ⇒ [(1)]

Function: remove object sequence ¶

この関数はdeleteに対応する非破壊的な関数である。この関数はobjectとequalな要素を取り除いた、sequence(リスト、ベクター、文字列)のコピーをリターンする。たとえば:

(remove '(2) '((2) (1) (2)))
     ⇒ ((1))

(remove '(2) [(2) (1) (2)])
     ⇒ [(1)]

Common Lispに関する注意: GNU Emacs Lispの関数member、delete、removeはCommon Lispではなく、Maclispを継承する。Common Lispでは比較にequalを使用しない。

Function: member-ignore-case object list ¶: この関数はmemberと同様だが、objectが文字列でcaseとテキスト表現の違いを無視する。文字の大文字と小文字は等しいものとして扱われ、比較に先立ちユニバイト文字列はマルチバイト文字列に変換される。

Function: delete-dups list ¶: この関数はlistからすべてのequalな重複を破壊的に取り除いて、結果をlistに保管してそれをリターンする。list内の要素にequalな要素がいくつかあるなら、delete-dupsは最初の要素を残す。非破壊的な操作についてはseq-uniqを参照してください(シーケンスを参照)。

変数に格納されたリストへの要素の追加や、それを集合として使用する方法については、リスト変数の変更の関数add-to-listも参照してください。

5.8 連想リスト

連想リスト(association list、短くはalist)は、キーと値のマッピングを記録します。これは連想(associations)と呼ばれるコンスセルのリストです。各コンスセルにおいてCARはキー(key)で、CDRは連想値(associated value)となります。⁶

以下はalistの例です。キーpineは値cones、キーoakはacorns、キーmapleはseedsに関連付けられます。

((pine . cones)
 (oak . acorns)
 (maple . seeds))

alist内の値とキーには、任意のLispオブジェクトを指定できます。たとえば以下のalistでは、シンボルaは数字1、文字列"b"はリスト(2 3)(alist要素のCDR)に関連付けられます。

((a . 1) ("b" 2 3))

要素のCDRのCARに連想値を格納するようにalistデザインするほうがよい場合があります。以下はそのようなalistです。

((rose red) (lily white) (buttercup yellow))

この例では、redがroseに関連付けられる値だと考えます。この種のalistの利点は、CDRのCDRの中に他の関連する情報 — 他のアイテムのリストでさえも — を格納することができることです。不利な点は、与えられた値を含む要素を見つけるためにrassq(以下参照)を使用できないことです。これらを検討することが重要でない場合には、すべての与えられたalistにたいして一貫している限り、選択は好みの問題といえます。

上記で示したのと同じalistは、要素のCDRに連想値をもつと考えることができます。この場合、roseに関連付けられる値はリスト(red)になるでしょう。

連想リストは新しい連想値を簡単にリストの先頭に追加できるので、スタックに保持したいような情報を記録するのによく使用されます。連想リストから与えられたキーにたいして連想値を検索する場合、それが複数ある場合は、最初に見つかったものがreturnされます。

Emacs Lispでは、連想リストがコンスセルでなくても、それはエラーではありません。alist検索関数は、単にそのような要素を無視します。多くの他のバージョンのLispでは、このような場合はエラーをシグナルします。

いくつかの観点において、プロパティリストは連想リストと似ていることに注意してください。それぞれのキーが一度だけ出現するような場合、プロパティリストは連想リストと同様に振る舞います。プロパティリストと連想リストの比較については、プロパティリストを参照してください。

Function: assoc key alist &optional testfn ¶

この関数はalist要素にたいしてtestfnが関数ならtestfn、それ以外ならequalを使用して、alist内からkeyをもつ最初の連想をリターンする。testfnが関数の場合にはalistの要素のCARとkeyの2つの引数で呼び出される。testfnでテストした結果、CARがkeyと一致する連想がalistになければ、この関数はnilをリターンする。たとえば:

(setq trees '((pine . cones) (oak . acorns) (maple . seeds)))
     ⇒ ((pine . cones) (oak . acorns) (maple . seeds))
(assoc 'oak trees)
     ⇒ (oak . acorns)
(cdr (assoc 'oak trees))
     ⇒ acorns
(assoc 'birch trees)
     ⇒ nil

以下はキーと値がシンボルでない場合の例である:

(setq needles-per-cluster
      '((2 "Austrian Pine" "Red Pine")
        (3 "Pitch Pine")
        (5 "White Pine")))

(cdr (assoc 3 needles-per-cluster))
     ⇒ ("Pitch Pine")
(cdr (assoc 2 needles-per-cluster))
     ⇒ ("Austrian Pine" "Red Pine")

関数assoc-stringはassocと似ていますが、文字列間の特定の違いを無視する点が異なります。文字および文字列の比較を参照してください。

Function: rassoc value alist ¶

この関数はalistの中から値valueをもつ最初の連想をリターンする。CDRがvalueとequalであるような連想値がalistになければ、この関数はnilをリターンする。

rassocはassocと似てイルが、CARではなくalistの連想値のCDRを比較する。この関数は与えられた値に対応するキーを探す、assocの逆バージョンと考えることができよう。

Function: assq key alist ¶

この関数はalistからkeyをもつ最初の連想値をリターンする点はassocと同様だが、比較にeqを使用する点が異なる。CARがkeyとeqであるような連想値がalist内に存在しなければassqはnilをリターンする。eqはequalより高速であり、ほとんどのalistはキーにシンボルを使用するので、この関数はassocより多用される。同等性のための述語を参照のこと。

(setq trees '((pine . cones) (oak . acorns) (maple . seeds)))
     ⇒ ((pine . cones) (oak . acorns) (maple . seeds))
(assq 'pine trees)
     ⇒ (pine . cones)

逆にキーがシンボルではないalistでは、通常はassqは有用ではない:

(setq leaves
      '(("simple leaves" . oak)
        ("compound leaves" . horsechestnut)))

(assq "simple leaves" leaves)
     ⇒ 未定義; nilか("simple leaves" . oak)かもしれない
(assoc "simple leaves" leaves)
     ⇒ ("simple leaves" . oak)

Function: alist-get key alist &optional default remove testfn ¶

この関数はassqと似ている。これはalistの要素のkeyを比較して最初の連想(key . value)を見つける。連想が見つからなければ、関数はdefaultをリターンする。alistにたいするkeyの比較にはtestfnで指定された関数を使用する(デフォルトはeq)。

これはsetfでの値の変更に使用できる汎変数(ジェネリック変数を参照)である。値の設定にこれを使用する際にオプション引数removeがnilの場合は、新たな値がdefaultとeqlならalistからkeyの連想を削除することを意味する。

Function: rassq value alist ¶

この関数は、alist内から値valueをもつ最初の連想値をリターンする。alist内にCDRがvalueとeqであるような連想値が存在しないならnilをリターンする。

rassqはassqと似ていますが、CARではなくalistの各連想のCDRを比較します。この関数を、与えられた値に対応するキーを探すassqの逆バージョンと考えることができます。

たとえば:

(setq trees '((pine . cones) (oak . acorns) (maple . seeds)))

(rassq 'acorns trees)
     ⇒ (oak . acorns)
(rassq 'spores trees)
     ⇒ nil

rassqは要素のCDRのCARに保管された値の検索はできません:

(setq colors '((rose red) (lily white) (buttercup yellow)))

(rassq 'white colors)
     ⇒ nil

この場合、連想(lily white)のCDRはwhiteではなくリスト(white)です。これは連想をドットペア表記で記述すると明確になります:

(lily white) ≡ (lily . (white))

Function: assoc-default key alist &optional test default ¶

この関数は、keyにたいするマッチをalistから検索する。alistの各要素にたいして、この関数はkeyと要素(アトムの場合)、または要素のCAR(コンスの場合)を比較する。比較はtestに2つの引数 — 要素(か要素のCAR)とkey — を与えて呼び出すことにより行なわれる。引数はこの順番で渡されるので、正規表現(正規表現の検索を参照)を含むalistでは、string-matchを使用することにより有益な結果を得ることができる。testが省略またはnilなら比較にequalが使用される。

alistの要素がこの条件によりkeyとマッチすると、assoc-defaultはその要素の値をリターンする。要素がコンスなら値は要素のCDR、それ以外ならリターン値はdefaultとなる。

keyにマッチする要素がalistに存在しないなら、assoc-defaultはnilをリターンする。

Function: copy-alist alist ¶

この関数は深さのレベルが2のalistのコピーをリターンする。この関数は各連想の新しいコピーを作成するので、元のalistを変更せずに新しいalistを変更できる。

(setq needles-per-cluster
      '((2 . ("Austrian Pine" "Red Pine"))
        (3 . ("Pitch Pine"))

        (5 . ("White Pine"))))
⇒
((2 "Austrian Pine" "Red Pine")
 (3 "Pitch Pine")
 (5 "White Pine"))

(setq copy (copy-alist needles-per-cluster))
⇒
((2 "Austrian Pine" "Red Pine")
 (3 "Pitch Pine")
 (5 "White Pine"))

(eq needles-per-cluster copy)
     ⇒ nil
(equal needles-per-cluster copy)
     ⇒ t
(eq (car needles-per-cluster) (car copy))
     ⇒ nil
(cdr (car (cdr needles-per-cluster)))
     ⇒ ("Pitch Pine")

(eq (cdr (car (cdr needles-per-cluster)))
    (cdr (car (cdr copy))))
     ⇒ t

以下の例は、copy-alistを使用して、他方のコピーへの影響なしに一方のコピーの連想を変更することが可能である方法を示す:

(setcdr (assq 3 copy) '("Martian Vacuum Pine"))
(cdr (assq 3 needles-per-cluster))
     ⇒ ("Pitch Pine")

Function: assq-delete-all key alist ¶

この関数は、delqを使用してマッチする要素を1つずつ削除するときのように、CARがkeyとeqであるようなすべての要素をalistから削除する。この関数は短くなったalistをリターンし、alistの元のリスト構造を変更することもよくある。正しい結果を得るために、alistに保存された値ではなくassq-delete-allのリターン値を使用すること。

(setq alist (list '(foo 1) '(bar 2) '(foo 3) '(lose 4)))
     ⇒ ((foo 1) (bar 2) (foo 3) (lose 4))
(assq-delete-all 'foo alist)
     ⇒ ((bar 2) (lose 4))
alist
     ⇒ ((foo 1) (bar 2) (lose 4))

Function: assoc-delete-all key alist &optional test ¶: この関数はassq-delete-allと同様だが、オプション引数test ( alist内のキーを比較するための述語関数)を受け取る点が異なる。testが省略かnilならデフォルトはequal。この関数はassq-delete-allのように、多くの場合はalistの元のリスト構造を変更する。

Function: rassq-delete-all value alist ¶: この関数は、alistからCDRがvalueとeqであるようなすべての要素を削除する。この関数は短くなったリストをリターンし、alistの元のリスト構造を変更することもよくある。rassq-delete-allはassq-delete-allと似ているが、CARではなくalistの各連想のCDRを比較する。

Macro: let-alist alist body ¶

連想リストalistのキーとして使用される先頭にドットを付したシンボルそれぞれにたいしてバインディングを作成する。これは同じ連想リスト内の複数のアイテムにアクセスする際に有用かもしれない。理解するためにもっともよいのは以下のシンプルな例だろう:

(setq colors '((rose . red) (lily . white) (buttercup . yellow)))
(let-alist colors
  (if (eq .rose 'red)
      .lily))
     ⇒ white

bodyをコンパイル時に検査して、body内に出現する先頭文字として‘.’を付したシンボルだけがバインドされる。キーの検索はassq、このassqのリターン値のcdrがそのバインディングにたいする値として割り当てられる。

ネストされた連想リストをサポートする:

(setq colors '((rose . red) (lily (belladonna . yellow) (brindisi . pink))))
(let-alist colors
  (if (eq .rose 'red)
      .lily.belladonna))
     ⇒ yellow

互いに内部にlet-alistをネストすることが可能だが、内側のlet-alistは外側のlet-alistがバインドする変数にはアクセスできない。

5.9 プロパティリスト

プロパティリスト(property list、短くはplist)は、ペアになった要素のリストです。各ペアはプロパティ名(通常はシンボル)とプロパティ値を対応づけます。以下はプロパティリストの例です:

(pine cones numbers (1 2 3) color "blue")

このプロパティリストはpineをcones、numbersを(1 2 3)、colorを"blue"に関連づけます。プロパティ名とプロパティ値には任意のLispオブジェクトを指定できますが、通常プロパティ名は(この例のように)シンボルです。

いくつかのコンテキストでプロパティリストが使用されます。たとえば関数put-text-propertyはプロパティリストを引数にとり、文字列やバッファー内のテキストにたいして、テキストプロパティとテキストに適用するプロパティ値を指定します。テキストのプロパティを参照してください。

プロパティリストが頻繁に使用される他の例は、シンボルプロパティの保管です。すべてのシンボルはシンボルに関する様々な情報を記録するために、プロパティのリストを処理します。これらのプロパティはプロパティリストの形式で保管されます。シンボルのプロパティを参照してください。

Function: plistp object ¶: この述語関数はobjectが有効なプロパティリストなら非nilをリターンする。

5.9.1 プロパティリストと連想リスト

連想リスト(連想リストを参照)は、プロパティリストとよく似ています。連想リストとは対照的にプロパティ名は一意でなければならないので、プロパティリスト内でペアの順序に意味はありません。

様々なLisp関数や変数に情報を付加するためには、連想リストよりプロパティリストの方が適しています。プログラムでこのような情報すべてを1つの連想リストに保持する場合は、特定のLisp関数や変数にたいする連想をチェックする度にリスト全体を検索する必要が生じ、それにより遅くなる可能性があります。対照的に関数名や変数自体のプロパティリストに同じ情報を保持すれば、検索ごとにそのプロパティリストの長さだけを検索するようになり、通常はこちらの方が短時間で済みます。変数のドキュメントがvariable-documentationという名前のプロパティに記録されているのはこれが理由です。同様にバイトコンパイラーも、特別に扱う必要がある関数を記録するためにプロパティを使用します。

とはいえ連想リストにも独自の利点があります。アプリケーションに依存しますが、プロパティを更新するより連想リストの先頭に連想を追加する方が高速でしょう。シンボルにたいするすべてのプロパティは同じプロパティリストに保管されるので、プロパティ名を異なる用途のために使用すると衝突の可能性があります(この理由により、そのプログラムで通常の変数や関数の名前につけるプレフィクスをプロパティ名の先頭につけて、一意と思われるプロパティ名を選ぶのはよいアイデアだと言える)。連想リストは、連想をリストの先頭にpushして、その後にある連想は無視されるので、スタックと同様に使用できます。これはプロパティリストでは不可能です。

5.9.2 プロパティリストと外部シンボル

以下の関数はプロパティリストを操作するために使用されます。これらの関数はすべて、デフォルトではプロパティ名の比較にeqを使用します。

Function: plist-get plist property &optional predicate ¶

この関数はプロパティリストplistに保管された、プロパティpropertyの値をリターンする。比較はpredicate (デフォルトはeq)で行われる。この関数には不正な形式(malformed)のplist引数を指定できる。plistでpropertyが見つからないと、この関数はnilをリターンする。たとえば、

(plist-get '(foo 4) 'foo)
     ⇒ 4
(plist-get '(foo 4 bad) 'foo)
     ⇒ 4
(plist-get '(foo 4 bad) 'bad)
     ⇒ nil
(plist-get '(foo 4 bad) 'bar)
     ⇒ nil

Function: plist-put plist property value &optional predicate ¶

この関数はプロパティリストplistに、プロパティpropertyの値としてvalueを保管する。比較はpredicate (デフォルトはeq)で行われる。この関数はplistを破壊的に変更するかもしれず、元のリスト構造を変更せずに新しいリストを構築することもある。この関数は変更されたプロパティリストをリターンするので、plistを取得した場所に書き戻すことができる。たとえば、

(setq my-plist (list 'bar t 'foo 4))
     ⇒ (bar t foo 4)
(setq my-plist (plist-put my-plist 'foo 69))
     ⇒ (bar t foo 69)
(setq my-plist (plist-put my-plist 'quux '(a)))
     ⇒ (bar t foo 69 quux (a))

Function: lax-plist-get plist property ¶: この廃れた関数はplist-getと同様だが、プロパティの比較にeqではなくequalを使用する。

Function: lax-plist-put plist property value ¶: この廃れた関数はplist-putと同様だが、プロパティの比較にeqではなくequalを使用する。

Function: plist-member plist property &optional predicate ¶: この関数は与えられたpropertyがplistに含まれるなら非nilをリターンする。比較はpredicate (デフォルトはeq)で行われる。plist-getとは異なりこの関数は存在しないプロパティと、値がnilのプロパティを区別できる。実際にリターンされる値は、carがpropertyで始まるplistの末尾部分である。

6 シーケンス、配列、ベクター

シーケンス(sequence)型は2つの異なるLisp型 — リストと配列 — を結合した型です。言い換えると任意のリストはシーケンスであり任意の配列はシーケンスです。すべてのシーケンスがもつ共通な属性は、それぞれが順序づけされた要素のコレクションであることです。

配列(array)はスロットがその要素であるような、固定長のオブジェクトです。すべての要素に一定時間でアクセスできます。配列の4つの型として文字列、ベクター、文字テーブル、ブールベクターがあります。

リストは要素のシーケンスですが、要素は単一の基本オブジェクトではありません。リストはコンスセルにより作られ、要素ごとに1つのセルをもちます。n番目の要素を探すにはn個のコンスセルを走査する必要があるので、先頭から離れた要素ほどアクセスに時間を要します。しかしリストは要素の追加や削除が可能です。

以下の図はこれらの型の関連を表しています:

          _____________________________________________
         |                                             |
         |          Sequence                           |
         |  ______   ________________________________  |
         | |      | |                                | |
         | | List | |             Array              | |
         | |      | |    ________       ________     | |
         | |______| |   |        |     |        |    | |
         |          |   | Vector |     | String |    | |
         |          |   |________|     |________|    | |
         |          |  ____________   _____________  | |
         |          | |            | |             | | |
         |          | | Char-table | | Bool-vector | | |
         |          | |____________| |_____________| | |
         |          |________________________________| |
         |_____________________________________________|

6.1 シーケンス		任意の種類のシーケンスを許す関数。
6.2 配列		Emacs Lispの配列の特徴。
6.3 配列を操作する関数		配列に特化した関数。
6.4 ベクター		Emacs Lispベクターの特質。
6.5 ベクターのための関数		ベクターのための特別な関数。
6.6 文字テーブル		文字テーブルを扱う方法。
6.7 ブールベクター		ブールベクターを扱う方法。
6.8 オブジェクト用固定長リングの管理		オブジェクトの固定サイズのリングを管理する。

6.1 シーケンス

このセクションでは任意の種類のシーケンスを許す関数を説明します。

Function: sequencep object ¶: この関数はobjectがリスト、ベクター、文字列、ブールベクター、文字テーブルならt、それ以外はnilをリターンする。以下のseqpも参照のこと。

Function: length sequence ¶

この関数はsequence内の要素の数をリターンする。sequenceがシーケンス以外、またはドットリストならwrong-type-argumentエラーをシグナルする。引数が循環リストならcircular-listエラーをシグナルする。文字テーブルではEmacsの最大文字コードより1大きい値が常にリターンされる。

関連する関数safe-lengthについてはDefinition of safe-lengthを参照のこと。

(length '(1 2 3))
    ⇒ 3

(length ())
    ⇒ 0

(length "foobar")
    ⇒ 6

(length [1 2 3])
    ⇒ 3

(length (make-bool-vector 5 nil))
    ⇒ 5

テキストの表現方法のstring-bytesも参照されたい。

ディスプレイ上での文字列の幅を計算する必要があるなら、文字数だけを数えて各文字のディスプレイ幅を計算しないlengthではなく、string-width (表示されるテキストのサイズを参照)を使用すること。

Function: length< sequence length ¶: sequenceがlengthより短ければ非nilをリターンする。これはsequenceが長いリストの場合にsequenceの長さを計算するより効率的かもしれない。

Function: length> sequence length ¶: sequenceがlengthより長ければ非nilをリターンする。

Function: length= sequence length ¶: sequenceの長さがlengthなら非nilをリターンする。

Function: elt sequence index ¶

この関数はindexによりインデックスづけされた、sequenceの要素をリターンする。indexの値として妥当なのは、0からsequenceの長さより1小さい数までの範囲の整数。sequenceがリストなら範囲外の値はnthと同じように振る舞う。Definition of nthを参照のこと。それ以外なら範囲外の値はargs-out-of-rangeエラーを引き起こす。

(elt [1 2 3 4] 2)
     ⇒ 3

(elt '(1 2 3 4) 2)
     ⇒ 3

;; eltがどの文字をreturnするか明確にするためにstringを使用
(string (elt "1234" 2))
     ⇒ "3"

(elt [1 2 3 4] 4)
     error→ Args out of range: [1 2 3 4], 4

(elt [1 2 3 4] -1)
     error→ Args out of range: [1 2 3 4], -1

この関数はaref (配列を操作する関数を参照)とnth (Definition of nthを参照)を一般化したものである。

Function: copy-sequence seqr ¶

この関数はseqr (シーケンスかレコードであること)のコピーをリターンする。コピーはオリジナルと同じオブジェクト型であり、同じ要素を同じ順序でもつ。しかしseqrが空なら長さが0の文字列やベクターと同じように関数がリターンする値はコピーではないかもしれないが、seqrと同じ型の空のオブジェクトである。

コピーに新しい要素を格納するのは元のseqrに影響を与えずその逆も真である。しかし新しいシーケンス内の要素はコピーではなく、元のシーケンスの要素と同一(eq)になる。したがってコピーされたシーケンスを介して見つかった要素を変更するとオリジナルでも変更を見ることができる。

引数がテキストプロパティをもつ文字列なら、コピー内のプロパティリスト自身もコピーとなり、元のシーケンスのプロパティリストと共有はされない。しかしプロパティリストの実際の値は共有される。テキストのプロパティを参照のこと。

この関数はドットリストでは機能しない。循環リストのコピーは無限ループを起こすだろう。

シーケンスをコピーする別の方法についてはコンスセルおよびリストの構築のappend、文字列の作成のconcat、ベクターのための関数のvconcatも参照されたい。

(setq bar (list 1 2))
     ⇒ (1 2)

(setq x (vector 'foo bar))
     ⇒ [foo (1 2)]

(setq y (copy-sequence x))
     ⇒ [foo (1 2)]

(eq x y)
     ⇒ nil

(equal x y)
     ⇒ t

(eq (elt x 1) (elt y 1))
     ⇒ t

;; 一方のシーケンスの要素を置き換え
(aset x 0 'quux)
x ⇒ [quux (1 2)]
y ⇒ [foo (1 2)]

;; 共有された要素の内部を変更
(setcar (aref x 1) 69)
x ⇒ [quux (69 2)]
y ⇒ [foo (69 2)]

Function: reverse sequence ¶

この関数はsequenceの要素を反転した要素をもつ新たなシーケンスを作成する。元となる引数sequenceは変更されない。文字テーブルは反転できないことに注意。

(setq x '(1 2 3 4))
     ⇒ (1 2 3 4)

(reverse x)
     ⇒ (4 3 2 1)
x
     ⇒ (1 2 3 4)

(setq x [1 2 3 4])
     ⇒ [1 2 3 4]

(reverse x)
     ⇒ [4 3 2 1]
x
     ⇒ [1 2 3 4]

(setq x "xyzzy")
     ⇒ "xyzzy"

(reverse x)
     ⇒ "yzzyx"
x
     ⇒ "xyzzy"

Function: nreverse sequence ¶

この関数はsequenceの要素を反転する。reverseとは異なり、元となるsequenceは変更されるかもしれない。

たとえば:

(setq x (list 'a 'b 'c))
     ⇒ (a b c)

x
     ⇒ (a b c)
(nreverse x)
     ⇒ (c b a)

;; 先頭にあったコンスセルが末尾となった
x
     ⇒ (a)

混乱しないように、通常は元となるリストを保持する同じ変数に、nreverseの結果を書き戻す:

(setq x (nreverse x))

お馴染の例(a b c)のnreverseを以下に図示する:

Original list head:                       Reversed list:
 -------------        -------------        ------------
| car  | cdr  |      | car  | cdr  |      | car | cdr  |
|   a  |  nil |<--   |   b  |   o  |<--   |   c |   o  |
|      |      |   |  |      |   |  |   |  |     |   |  |
 -------------    |   --------- | -    |   -------- | -
                  |             |      |            |
                   -------------        ------------

setqが不要なのでベクターはより単純になる:

(setq x (copy-sequence [1 2 3 4]))
     ⇒ [1 2 3 4]
(nreverse x)
     ⇒ [4 3 2 1]
x
     ⇒ [4 3 2 1]

reverseとは異なり、この関数は文字列では機能しない。asetを使用して文字列データを変更できても、たとえmutableであったとしても文字列は不変として扱うことを強く推奨する。可変性を参照のこと。

Function: sort sequence predicate ¶

この関数はsequenceを安定ソートする。この関数はすべてのシーケンスにたいしては機能せず、リストとベクターにたいしてのみ使用できることに注意されたい。sequenceがリストなら破壊的に変更される。この関数はソートされたsequenceをリターンして、要素の比較にはpredicateを使用する。安定ソートでは、ソートキーが等しい要素の相対順序がソートの前後で保たれる。この安定性は異なる条件により要素を並べ替えるために、連続してソートを行う場合に重要となる。

引数predicateは2つの引数を受け取る関数でなければならない。これはsequenceの2つの要素で呼び出される。昇順でソートするなら、1つ目の要素が2つ目の要素より“小”なら非nil、それ以外ならnilをリターンすること。

比較関数predicateは、少なくともsortの単一の呼び出しにおいて、与えられた任意の引数ペアにたいして信頼できる結果をリターンしなければならない。これは非対照的(antisymmetric)、すなわちaがbより小なら、bがaより小であってはならず、推移律(transitive)、すなわちaがbより小、かつbがcより小なら、aはcより小でなければならない。これらの要件に合致しない比較関数を使用すると、sortの結果は予想できない。

sortのリストにたいする破壊的側面は、コンスセルによって形成されたsequenceの内容を、もしかしたら違う順序に再配置するような変更を施すことによって再利用することである。これは入力リストのソート後の値が未定義であることを意味する。定義された有効な値は、sortによってリターンされるリストだけである。

(setq nums (list 2 1 4 3 0))
(sort nums #'<)
     ⇒ (0 1 2 3 4)
     ; この時点においてnumsは予測不可能

元のリストを保持していた変数に結果を書き戻す場合がほとんどだろう:

(setq nums (sort nums #'<))

元の値話破壊せずにソート済みのコピーが欲しければ、まずコピーしてからソートすること:

(setq nums (list 2 1 4 3 0))
(sort (copy-sequence nums) #'<)
     ⇒ (0 1 2 3 4)

nums
     ⇒ (2 1 4 3 0)

安定ソートの何たるかをより理解するには、以下のベクターのサンプルを考えてみよ。ソート後、carが8であるようなすべてのアイテムはvectorの先頭にグループ化されるが、それらの相対的な順序は保たれる。carが9であるようなすべてのアイテムはvectorの末尾にグループ化されるが、それらの相対的な順序も保たれる。

(setq
  vector
  (vector '(8 . "xxx") '(9 . "aaa") '(8 . "bbb") '(9 . "zzz")
          '(9 . "ppp") '(8 . "ttt") '(8 . "eee") '(9 . "fff")))
     ⇒ [(8 . "xxx") (9 . "aaa") (8 . "bbb") (9 . "zzz")
         (9 . "ppp") (8 . "ttt") (8 . "eee") (9 . "fff")]

(sort vector (lambda (x y) (< (car x) (car y))))
     ⇒ [(8 . "xxx") (8 . "bbb") (8 . "ttt") (8 . "eee")
         (9 . "aaa") (9 . "zzz") (9 . "ppp") (9 . "fff")]

ソートを行う他の関数についてはテキストのソートを参照のこと。sortの有用な例は、ドキュメント文字列へのアクセスのdocumentationを参照されたい。

seq.elライブラリーは、以下のようなプレフィクスseq-がついたシーケンス操作用の追加のマクロと関数を提供します。

このライブラリー内で定義されたすべての関数は、副作用をもちません。これらは引数として渡されたすべてのシーケンス(リスト、ベクター、文字列)を変更しません。特に明記しなければ、結果は入力と同じ型のシーケンスです。述語を受け取る関数では、それらは単一の関数である必要があります。

seq.elライブラリーは、シーケンシャルなデータ構造の追加型で機能するように拡張可能です。そのためにすべての関数はcl-defgenericを使用して定義されています。cl-defgenericを使用した拡張の追加に関する詳細は、ジェネリック関数を参照してください。

Function: seq-elt sequence index ¶

この関数はindex(有効な範囲は0からsequenceの長さより1少ない整数)で指定されたsequenceの要素をリターンする。ビルトインのシーケンス型にたいする範囲外(out-of-range)の値にたいして、seq-eltはeltと同様に振る舞う。詳細はDefinition of eltを参照のこと。

(seq-elt [1 2 3 4] 2)
⇒ 3

seq-eltはsetfを使用してセット可能なplaceをリターンする(setfマクロを参照)。

(setq vec [1 2 3 4])
(setf (seq-elt vec 2) 5)
vec
⇒ [1 2 5 4]

Function: seq-length sequence ¶: この関数はsequence内の要素の個数をリターンする。ビルトインのシーケンス型にたいしてseq-lengthはlengthと同様に振る舞う。Definition of lengthを参照のこと。

Function: seqp object ¶

この関数はobjectがシーケンス(リストか配列)、またはseq.elのジェネリック関数を通じて定義されたすべての追加シーケンス型なら非nilをリターンする。これはsequencepの拡張された変種である。

(seqp [1 2])
⇒ t

(seqp 2)
⇒ nil

Function: seq-drop sequence n ¶

この関数はsequenceの最初のn個(整数)を除く、すべての要素をリターンする.nが0以下なら結果はsequence。

(seq-drop [1 2 3 4 5 6] 3)
⇒ [4 5 6]

(seq-drop "hello world" -4)
⇒ "hello world"

Function: seq-take sequence n ¶

この関数はsequenceの最初のn個(整数)の要素をリターンする。nが0以下なら結果はnil。

(seq-take '(1 2 3 4) 3)
⇒ (1 2 3)

(seq-take [1 2 3 4] 0)
⇒ []

Function: seq-take-while predicate sequence ¶

この関数はsequenceのメンバーを順にリターンし、predicateが最初にnilをリターンした要素の前で停止する。

(seq-take-while (lambda (elt) (> elt 0)) '(1 2 3 -1 -2))
⇒ (1 2 3)

(seq-take-while (lambda (elt) (> elt 0)) [-1 4 6])
⇒ []

Function: seq-drop-while predicate sequence ¶

この関数はpredicateが最初にnilをリターンした要素から、sequenceのメンバーを順にリターンする。

(seq-drop-while (lambda (elt) (> elt 0)) '(1 2 3 -1 -2))
⇒ (-1 -2)

(seq-drop-while (lambda (elt) (< elt 0)) [1 4 6])
⇒ [1 4 6]

Function: seq-split sequence length ¶

この関数は(最大で)長さlengthのsequenceの部分シーケンスから構成されるリストをリターンする(sequenceの長さがlengthの倍数でなければ最後の要素の長さはlengthより短くなるかもしれない)。

(seq-split [0 1 2 3 4] 2)
⇒ ([0 1] [2 3] [4])

Function: seq-do function sequence ¶: この関数はsequenceの各要素にたいして、(恐らくは副作用を得るために)順番にfunctionを適用して、sequenceをリターンする。

Function: seq-map function sequence ¶

この関数はsequenceの各要素にfunctionを適用した結果をリターンする。リターン値はリスト。

(seq-map #'1+ '(2 4 6))
⇒ (3 5 7)

(seq-map #'symbol-name [foo bar])
⇒ ("foo" "bar")

Function: seq-map-indexed function sequence ¶

この関数はsequenceの各要素およびseqであるようなインデックスにfunctionを適用した結果をリターンする。リターン値はリスト。

(seq-map-indexed (lambda (elt idx)
                   (list idx elt))
                 '(a b c))
⇒ ((0 a) (1 b) (2 c))

Function: seq-mapn function &rest sequences ¶

この関数はsequencesの各要素にfunctionを適用した結果をリターンする。 functionのarity (関数が受け取れる引数の個数。subr-arityを参照)はシーケンスの個数にマッチしなければならない。マッピングは最短のシーケンス終端で停止する。リターン値はリスト。

(seq-mapn #'+ '(2 4 6) '(20 40 60))
⇒ (22 44 66)

(seq-mapn #'concat '("moskito" "bite") ["bee" "sting"])
⇒ ("moskitobee" "bitesting")

Function: seq-filter predicate sequence ¶

この関数はpredicateが非nilをリターンしたsequence内のすべての要素のリストをリターンする。

(seq-filter (lambda (elt) (> elt 0)) [1 -1 3 -3 5])
⇒ (1 3 5)

(seq-filter (lambda (elt) (> elt 0)) '(-1 -3 -5))
⇒ nil

Function: seq-remove predicate sequence ¶

この関数はpredicateがnilをリターンしたsequence内のすべての要素のリストをリターンする。

(seq-remove (lambda (elt) (> elt 0)) [1 -1 3 -3 5])
⇒ (-1 -3)

(seq-remove (lambda (elt) (< elt 0)) '(-1 -3 -5))
⇒ nil

Function: seq-remove-at-position sequence n ¶

この関数はインデックスn (0基準)にある要素が削除されたsequenceのコピーをリターンする。結果のタイプはsequenceと同じ。

(seq-remove-at-position [1 -1 3 -3 5] 0)
⇒ [-1 3 -3 5]

(seq-remove-at-position [1 -1 3 -3 5] 3)
⇒ [1 -1 3 5]

Function: seq-keep function sequence ¶

この関数はsequenceの要素それぞれにたいしてfunctionを呼び出して、結果が非nilだった要素すべてからなるリストをリターンする。

(seq-keep #'cl-digit-char-p '(?6 ?a ?7))
⇒ (6 7)

Function: seq-reduce function sequence initial-value ¶

この関数はinitial-valueとsequenceの1つ目の要素でfunctionを呼び出し、次にその結果とsequenceの2つ目の要素でfunctionを呼び出し、その次にその結果とsequenceの3つ目の要素で、...と呼び出した結果をリターンする。functionは引数が2つの関数であること。

functionは2つの引数で呼び出される。1つ目の引数としてinitial-value (その後は累積値)、2つ目の引数としてsequence内の要素が使用される。

sequenceが空なら、functionを呼び出さずにinitial-valueをリターンする。

(seq-reduce #'+ [1 2 3 4] 0)
⇒ 10

(seq-reduce #'+ '(1 2 3 4) 5)
⇒ 15

(seq-reduce #'+ '() 3)
⇒ 3

Function: seq-some predicate sequence ¶

この関数はsequenceの各要素に順にpredicateを適用してリターンされた、最初の非nil値をリターンする。

(seq-some #'numberp ["abc" 1 nil])
⇒ t

(seq-some #'numberp ["abc" "def"])
⇒ nil

(seq-some #'null ["abc" 1 nil])
⇒ t

(seq-some #'1+ [2 4 6])
⇒ 3

Function: seq-find predicate sequence &optional default ¶

この関数はpredicateが非nilをリターンした、sequence内の最初の要素をリターンする。predicateにマッチする要素がなければ、この関数はdefaultをリターンする。

この関数は見つかった要素がdefaultと等しい場合、要素が見つかったかどうかを知る術がないので曖昧さをもつことに注意。

(seq-find #'numberp ["abc" 1 nil])
⇒ 1

(seq-find #'numberp ["abc" "def"])
⇒ nil

Function: seq-every-p predicate sequence ¶

この関数はsequenceの各要素にpredicateを適用して、すべてが非nilをリターンしたら非nilをリターンする。

(seq-every-p #'numberp [2 4 6])
⇒ t

(seq-every-p #'numberp [2 4 "6"])
⇒ nil

Function: seq-empty-p sequence ¶

この関数はsequenceが空ならnilをリターンする。

(seq-empty-p "not empty")
⇒ nil

(seq-empty-p "")
⇒ t

Function: seq-count predicate sequence ¶

この関数はsequence内でpredicateが非nilをリターンした要素の個数をリターンする。

(seq-count (lambda (elt) (> elt 0)) [-1 2 0 3 -2])
⇒ 2

Function: seq-sort function sequence ¶: この関数はfunctionに応じてソートされたsequenceのコピーをリターンする。functionは2つの引数を受け取り、1つ目の引数が2つ目より前にソートされるべきなら非nilをリターンする。

Function: seq-sort-by function predicate sequence ¶

この関数はseq-sortと似ているがソート前にsequenceの要素にfunctionを適用して変換する点が異なる。functionは単一の引数を受け取る関数。

(seq-sort-by #'seq-length #'> ["a" "ab" "abc"])
⇒ ["abc" "ab" "a"]

Function: seq-contains-p sequence elt &optional function ¶

この関数はsequence内の少なくとも1つの要素がeltとequalなら非nilをリターンする。オプション引数functionが非nilなら、それはデフォルトのequalのかわりに使用する2つの引数を受け取る関数であること。

(seq-contains-p '(symbol1 symbol2) 'symbol1)
⇒ t

(seq-contains-p '(symbol1 symbol2) 'symbol3)
⇒ nil

Function: seq-set-equal-p sequence1 sequence2 &optional testfn ¶

この関数は順序とは無関係にsequence1とsequence2が同じ要素を含むかどうかをチェックする。オプション引数testfnが非nilなら、デフォルトのequalのかわりに使用する2つの引数を受け取る関数であること。

(seq-set-equal-p '(a b c) '(c b a))
⇒ t

(seq-set-equal-p '(a b c) '(c b))
⇒ nil

(seq-set-equal-p '("a" "b" "c") '("c" "b" "a"))
⇒ t

(seq-set-equal-p '("a" "b" "c") '("c" "b" "a") #'eq)
⇒ nil

Function: seq-position sequence elt &optional function ¶

この関数はeltとequalであるようなsequence内の最初の要素のインデックス(0基準)をリターンする。オプション引数functionが非nilなら、それはデフォルトのequalのかわりに使用する2つの引数を受け取る関数であること。

(seq-position '(a b c) 'b)
⇒ 1

(seq-position '(a b c) 'd)
⇒ nil

Function: seq-positions sequence elt &optional testfn ¶

この関数はsequenceの要素それぞれにたいして、eltとともに引数としてtestfnを呼び出し、非nilをリターンするような要素のインデックス(0基準)のリストをリターンする。testfnのデフォルトはequal。

(seq-positions '(a b c a d) 'a)
⇒ (0 3)

(seq-positions '(a b c a d) 'z)
⇒ nil

(seq-positions '(11 5 7 12 9 15) 10 #'>=)
⇒ (0 3 5)

Function: seq-uniq sequence &optional function ¶

この関数は重複を削除したsequenceの要素のリストをリターンする。オプション引数functionが非nilなら、それはデフォルトのequalのかわりに使用する2つの引数を受け取る関数であること。

(seq-uniq '(1 2 2 1 3))
⇒ (1 2 3)

(seq-uniq '(1 2 2.0 1.0) #'=)
⇒ (1 2)

Function: seq-subseq sequence start &optional end ¶

この関数はsequenceのstartからend(いずれも整数)までのサブセットをリターンする(endのデフォルトは最後の要素)。startかendが負ならsequenceの最後から数える。

(seq-subseq '(1 2 3 4 5) 1)
⇒ (2 3 4 5)

(seq-subseq '[1 2 3 4 5] 1 3)
⇒ [2 3]

(seq-subseq '[1 2 3 4 5] -3 -1)
⇒ [3 4]

Function: seq-concatenate type &rest sequences ¶

この関数はsequencesを結合して作成されたtype型のシーケンスをリターンする。typeはvector、list、stringのいずれか。

(seq-concatenate 'list '(1 2) '(3 4) [5 6])
⇒ (1 2 3 4 5 6)

(seq-concatenate 'string "Hello " "world")
⇒ "Hello world"

Function: seq-mapcat function sequence &optional type ¶

この関数はsequenceの各要素にfunctionを適用した結果に、seq-concatenateを適用した結果をリターンする。結果はtype型のシーケンス、またはtypeがnilならリストである。

(seq-mapcat #'seq-reverse '((3 2 1) (6 5 4)))
⇒ (1 2 3 4 5 6)

Function: seq-partition sequence n ¶

この関数は長さnのサブシーケンスへグループ化したsequenceの要素のリストをリターンする。最後のシーケンスに含まれる要素はnより少ないかもしれない。nは整数であること。nが0以下の整数ならリターン値はnil。

(seq-partition '(0 1 2 3 4 5 6 7) 3)
⇒ ((0 1 2) (3 4 5) (6 7))

Function: seq-union sequence1 sequence2 &optional function ¶

この関数はsequence1とsequence2のいずれかに出現する要素のリストをリターンする。リターンされるリストの要素はすべて、2要素を比較してequalにならないという意味において一意である。オプション引数functionが非nilなら、それはデフォルトのequalのかわりに比較に使用する2つの引数を受け取る関数であること。

(seq-union [1 2 3] [3 5])
⇒ (1 2 3 5)

Function: seq-intersection sequence1 sequence2 &optional function ¶

この関数はsequence1とsequence2の両方に出現する要素のリストをリターンする。オプション引数functionが非nilなら、それはデフォルトのequalのかわりに比較に使用する2つの引数を受け取る関数であること。

(seq-intersection [2 3 4 5] [1 3 5 6 7])
⇒ (3 5)

Function: seq-difference sequence1 sequence2 &optional function ¶

この関数はsequence1に出現するがsequence2に出現しない要素のリストをリターンする。オプション引数functionが非nilなら、それはデフォルトのequalのかわりに比較に使用する2つの引数を受け取る関数であること。

(seq-difference '(2 3 4 5) [1 3 5 6 7])
⇒ (2 4)

Function: seq-group-by function sequence ¶

この関数はsequenceの各要素にfunctionを適用して、その結果をキーとしてsequenceをalistに分割する。キーの比較にはequalを使用する。

(seq-group-by #'integerp '(1 2.1 3 2 3.2))
⇒ ((t 1 3 2) (nil 2.1 3.2))

(seq-group-by #'car '((a 1) (b 2) (a 3) (c 4)))
⇒ ((b (b 2)) (a (a 1) (a 3)) (c (c 4)))

Function: seq-into sequence type ¶

この関数はシーケンスsequenceをtype型のシーケンスに変換する。typeはvector、string、listのいずれかであること。

(seq-into [1 2 3] 'list)
⇒ (1 2 3)

(seq-into nil 'vector)
⇒ []

(seq-into "hello" 'vector)
⇒ [104 101 108 108 111]

Function: seq-min sequence ¶

この関数はsequenceの最小の要素をリターンする。sequenceの要素は数字かマーカー(マーカーを参照)でなければならない。

(seq-min [3 1 2])
⇒ 1

(seq-min "Hello")
⇒ 72

Function: seq-max sequence ¶

この関数はsequenceの最大の要素をリターンする。sequenceの要素は数字かマーカーでなければならない。

(seq-max [1 3 2])
⇒ 3

(seq-max "Hello")
⇒ 111

Macro: seq-doseq (var sequence) body… ¶: このマクロはdolist (dolistを参照)と同様だが、sequenceにリスト、ベクター、文字列のいずれかを指定できる点が異なる。これ主な利点は副作用である。

Macro: seq-let var-sequence val-sequence body… ¶

このマクロはvar-sequence内で定義される変数にval-sequenceの対応する要素をバインドする。これは分割代入(destructuring binding)として知られている。var-sequenceの要素は、ネストされた非構造化を許容することにより自身にシーケンスを含むことができる。

var-sequenceシーケンスには、val-sequenceの残りにバインドされる変数名が後続するような&restマーカーを含めることもできる。

(seq-let [first second] [1 2 3 4]
  (list first second))
⇒ (1 2)

(seq-let (_ a _ b) '(1 2 3 4)
  (list a b))
⇒ (2 4)

(seq-let [a [b [c]]] [1 [2 [3]]]
  (list a b c))
⇒ (1 2 3)

(seq-let [a b &rest others] [1 2 3 4]
  others)

⇒ [3 4]

pcaseパターンは分割代入にたいする代替えの機能を提供する。pcaseパターンによる分解を参照のこと。

Macro: seq-setq var-sequence val-sequence ¶

このマクロはseq-letと同様に機能するが、letではなくあたかもsetqで値が変数にバインドされる点が異なる。

(let ((a nil)
      (b nil))
  (seq-setq (_ a _ b) '(1 2 3 4))
  (list a b))
⇒ (2 4)

Function: seq-random-elt sequence ¶

この関数はsequenceの要素をランダムにリターンする。

(seq-random-elt [1 2 3 4])
⇒ 3
(seq-random-elt [1 2 3 4])
⇒ 2
(seq-random-elt [1 2 3 4])
⇒ 4
(seq-random-elt [1 2 3 4])
⇒ 2
(seq-random-elt [1 2 3 4])
⇒ 1

sequenceが空ならこの関数はエラーをシグナルする。

6.2 配列

配列(array)オブジェクトは、いくつかのLispオブジェクトを保持するスロットをもち、これらのオブジェクトは配列の要素と呼ばれます。配列内の任意の要素は一定時間でアクセスされます。対照的にリスト内の要素のアクセスに要する時間は、その要素がリスト内のどの位置にあるかに比例します。

Emacsは4つの配列型 —文字列(strings、文字列型を参照)、ベクター(vectors、ベクター型を参照)、ブールベクター(bool-vectors、ブールベクター型を参照)、文字テーブル(char-tables、文字テーブル型を参照) — を定義しており、これらはすべて1次元です。ベクターと文字テーブルは任意の型の要素を保持できますが、文字列は文字だけ、ブールベクターはtかnilしか保持できません。

4種のすべての配列はこれらの特性を共有します:

配列の1番目の要素はインデックス0、2番目はインデックス1、...となる。これは0基準(zero-origin)のインデックスづけと呼ばれる。たとえば4要素の配列のインデックスは0、1、2、3。
配列の長さは一度配列が作成されたら固定されるので、既存の配列の長さは変更できない。
評価において配列は定数 — つまりそれ自身へと評価される。
配列の要素は関数arefで参照したり、関数asetで変更できる(配列を操作する関数を参照)。

配列を作成したとき、文字テーブル以外では長さを指定しなければなりません。文字テーブルの長さは文字コードの範囲により決定されるので長さを指定できません。

原則として、テキスト文字の配列が欲しい場合は、文字列とベクターのどちらかを使用できます。実際のところ4つの理由により,そのような用途にたいしては、わたしたちは常に文字列を選択します:

文字列は同じ要素をもつベクターと比較して占めるスペースが1/4である。
文字列の内容はテキストとして、より明解な方法によりプリントされる。
文字列はテキストプロパティを保持できる。テキストのプロパティを参照のこと。
Emacsの特化した編集機能とI/O機能の多くが文字列だけに適用される。たとえば文字列をバッファーに挿入する方法では、文字のベクターをバッファーに挿入できない。文字列と文字を参照のこと

対照的に、(キーシーケンスのような)キーボード入力文字の配列では、多くのキーボード入力文字は文字列に収まる範囲の外にあるので、ベクターが必要になるでしょう。キーシーケンス入力を参照してください。

6.3 配列を操作する関数

このセクションではすべての型の配列に適用される関数を説明します。

Function: arrayp object ¶

この関数はobjectが配列(ベクター、文字列、ブールベクター、文字テーブル)ならtをリターンする。

(arrayp [a])
     ⇒ t
(arrayp "asdf")
     ⇒ t
(arrayp (syntax-table))    ;; 文字テーブル
     ⇒ t

Function: aref arr index ¶

この関数はarr (配列かレコード)のindex番目の要素をリターンする。1番目の要素のインデクスは0。

(setq primes [2 3 5 7 11 13])
     ⇒ [2 3 5 7 11 13]
(aref primes 4)
     ⇒ 11

(aref "abcdefg" 1)
     ⇒ 98           ; ‘b’のASCIIコードは98

シーケンスの関数eltも参照されたい。

Function: aset array index object ¶

この関数はarrayのindex番目の要素をobjectにセットする。この関数はobjectをリターンする。

(setq w (vector 'foo 'bar 'baz))
     ⇒ [foo bar baz]
(aset w 0 'fu)
     ⇒ fu
w
     ⇒ [fu bar baz]

;; copy-sequenceは後で変更する文字列をコピーする
(setq x (copy-sequence "asdfasfd"))
     ⇒ "asdfasfd"
(aset x 3 ?Z)
     ⇒ 90
x
     ⇒ "asdZasfd"

arrayはmutableであること。可変性を参照のこと。

arrayが文字列でobjectが文字でなければ、結果はwrong-type-argumentエラーとなる。この関数は文字列の挿入で必要なら、ユニバイト文字列をマルチバイト文字列に変換する。

Function: fillarray array object ¶

この関数は配列arrayをobjectで充填するので、arrayのすべての要素はobjectになる。この関数はarrayをリターンする。

(setq a (copy-sequence [a b c d e f g]))
     ⇒ [a b c d e f g]
(fillarray a 0)
     ⇒ [0 0 0 0 0 0 0]
a
     ⇒ [0 0 0 0 0 0 0]

(setq s (copy-sequence "When in the course"))
     ⇒ "When in the course"
(fillarray s ?-)
     ⇒ "------------------"

arrayが文字列でobjectが文字でなければ、結果はwrong-type-argumentエラーとなる。

配列と判っているオブジェクトにたいしては、一般的なシーケンス関数copy-sequenceとlengthが有用なときがよくあります。シーケンスを参照してください。

6.4 ベクター

ベクター(vector)とは任意のLispオブジェクトを要素にもつことができる、一般用途のための配列です(対照的に文字列の要素は文字のみ。文字列と文字を参照)。Emacsではベクターはキーシーケンス(キーシーケンスを参照)、シンボル検索用のテーブル(シンボルの作成とinternを参照)、バイトコンパイルされた関数表現の一部(バイトコンパイルを参照)などの多くの目的で使用されます。

他の配列と同様、ベクターは0基準のインデックスづけを使用し、1番目の要素はインデックス0になります。

ベクターは角カッコ(square brackets)で囲まれた要素としてプリントされます。したがってシンボルa、b、aを要素にもつベクターは、[a b a]とプリントされます。Lisp入力として同じ方法でベクターを記述できます。

文字列や数値と同様にベクターは定数として評価され、評価された結果は同じベクターになります。ベクターの要素は評価も確認もされません。自己評価を行うフォームを参照してください。角カッコ(square brackets)で記述されたベクターをasetや他の破壊的操作を通じて修正しないでください。可変性を参照してください。

以下はこれらの原理を表す例です:

(setq avector [1 two '(three) "four" [five]])
     ⇒ [1 two '(three) "four" [five]]
(eval avector)
     ⇒ [1 two '(three) "four" [five]]
(eq avector (eval avector))
     ⇒ t

6.5 ベクターのための関数

ベクターに関連した関数をいくつか示します:

Function: vectorp object ¶

この関数はobjectがベクターならtをリターンする。

(vectorp [a])
     ⇒ t
(vectorp "asdf")
     ⇒ nil

Function: vector &rest objects ¶

この関数は引数objectsを要素にもつベクターを作成してリターンする。

(vector 'foo 23 [bar baz] "rats")
     ⇒ [foo 23 [bar baz] "rats"]
(vector)
     ⇒ []

Function: make-vector length object ¶

この関数は各要素がobjectに初期化された、length個の要素からなる新しいベクターをリターンする。

(setq sleepy (make-vector 9 'Z))
     ⇒ [Z Z Z Z Z Z Z Z Z]

Function: vconcat &rest sequences ¶

この関数はsequencesのすべての要素を含む新しいベクターをリターンする。引数sequencesは正リスト、ベクター、文字列、ブールベクター。sequencesが与えられければ空のベクターがリターンされる。

値は空のベクター、またはすべての既存ベクターとeqではないような空ではない新しいベクターのいずれか。

(setq a (vconcat '(A B C) '(D E F)))
     ⇒ [A B C D E F]
(eq a (vconcat a))
     ⇒ nil

(vconcat)
     ⇒ []
(vconcat [A B C] "aa" '(foo (6 7)))
     ⇒ [A B C 97 97 foo (6 7)]

vconcat関数は、引数としてバイトコード関数オブジェクトも受け取ることができる。これはバイトコード関数オブジェクトの内容全体にアクセスするのを容易にするための特別な機能である。バイトコード関数オブジェクトを参照のこと。

結合を行なう他の関数については関数のマッピングのmapconcat、文字列の作成のconcat、コンスセルおよびリストの構築のappendを参照されたい。

append関数はベクターを同じ要素をもつリストに変換する方法も提供します:

(setq avector [1 two (quote (three)) "four" [five]])
     ⇒ [1 two '(three) "four" [five]]
(append avector nil)
     ⇒ (1 two '(three) "four" [five])

6.6 文字テーブル

文字テーブル(char-table)はベクターとよく似ていますが、文字テーブルは文字コードによりインデックスづけされます。文字テーブルのインデックスには、修飾キーをともなわない任意の有効な文字コードを使用できます。他の配列と同様に、arefとasetで文字テーブルの要素にアクセスできます。加えて、文字テーブルは追加のデータを保持するために、特定の文字コードに関連づけられていないエキストラスロット(extra slots)をもつことができます。ベクターと同様、文字テーブルは定数として評価され、任意の型の要素を保持できます。

文字テーブルはそれぞれサブタイプ(subtype)をもち、これは2つの目的をもつシンボルです:

サブタイプはそれがなんのための文字テーブルなのかを簡単に表す方法を提供する。たとえばディスプレイテーブル(display tables)はサブタイプがdisplay-tableの文字テーブルであり、構文テーブル(syntax tables)はサブタイプがsyntax-tableの文字テーブル。以下で説明するように関数char-table-subtypeを使用してサブタイプの問い合わせが可能。
サブタイプは文字テーブル内のいくつかのエキストラスロット(extra slots)を制御する。エキストラスロットの数は、そのサブタイプのchar-table-extra-slotsシンボルプロパティ(シンボルのプロパティを参照)により指定され、値は0から10の整数。サブタイプにそのようなシンボルプロパティがなければ、その文字テーブルはエキストラスロットをもたない。

文字テーブルは親(parent)をもつことができ、これは他の文字テーブルです。文字テーブルが親をもつ場合、その文字テーブルで特定の文字cにたいしてnilが指定されていたら、親と指定された文字テーブルで指定された値を継承します。言い方を変えると、文字テーブルchar-tableでcにnilが指定されていたら、(aref char-table c)はchar-tableの親の値をリターンします。

文字テーブルはデフォルト値(default value)をもつこともできます。デフォルト値をもつとき、文字テーブルchar-tableがcにたいしてnil値を指定すると、(aref char-table c)はデフォルト値をリターンします。

Function: make-char-table subtype &optional init ¶

サブタイプsubtype(シンボル)をもつ、新たに作成された文字テーブルをリターンする。各要素はinitに初期化され、デフォルトはnil。文字テーブルが作成された後で、文字テーブルのサブタイプを変更することはできない。

すべての文字テーブルは、インデックスとなる任意の有効な文字テーブルのための空間をもつので、文字テーブルの長さを指定する引数はない。

subtypeがシンボルプロパティchar-table-extra-slotsをもつなら、それはその文字列テーブル内のエキストラスロットの数を指定する。値には0から10の整数を指定し、これ以外ならmake-char-tableはエラーとなる。subtypeがシンボルプロパティchar-table-extra-slots(プロパティリストを参照)をもたなければ、その文字テーブルはエキストラスロットをもたない。

Function: char-table-p object ¶: この関数はobjectが文字テーブルならt、それ以外はnilをリターンする。

Function: char-table-subtype char-table ¶: この関数はchar-tableのサブタイプのシンボルをリターンする。

文字テーブルのデフォルト値にアクセスするための特別な関数は存在しません。これを行なうにはchar-table-rangeを使用します(以下参照)。

Function: char-table-parent char-table ¶: この関数はchar-tableの親をリターンする。親は常にnilか他の文字テーブルである。

Function: set-char-table-parent char-table new-parent ¶: この関数はchar-tableの親をnew-parentにセットする。

Function: char-table-extra-slot char-table n ¶: この関数はchar-tableのエキストラスロットn (0基準)の内容をリターンする。文字テーブルのエキストラスロットの数は文字テーブルのサブタイプにより決定される。

Function: set-char-table-extra-slot char-table n value ¶: この関数はchar-tableのエキストラスロットn (0基準)にvalueを格納する。

文字テーブルは1つの文字コードにたいして1つの要素値(element value)を指定できます。文字テーブルは文字セット全体にたいして値を指定することもできます。

Function: char-table-range char-table range ¶

この関数は文字範囲rangeにたいしてchar-tableで指定された値をリターンする。可能なrangeは以下のとおり:

nil: デフォルト値への参照。
char: 文字charにたいする要素への参照(charは有効な文字コードであると仮定)。
(from . to): 包括的な範囲‘[from..to]’内のすべての文字を参照するコンスセル。この関数は場合にはfromで指定された文字にたいする値をリターンする。

Function: set-char-table-range char-table range value ¶

この関数はchar-table内の文字範囲rangeにたいして値をセットする。可能なrangeは以下のとおり:

nil: デフォルト値への参照。
t: 文字コード範囲の全体を参照。
char: 文字charにたいする要素への参照(charは有効な文字コードであると仮定)。
(from . to): 包括的な範囲‘[from..to]’内のすべての文字を参照するコンスセル。

Function: map-char-table function char-table ¶

この関数はchar-tableの非nil値ではない各要素にたいして引数functionを呼び出す。functionの呼び出しでは2つの引数(keyとvalue)が指定される。keyはchar-table-rangeにたいする可能なrange (有効な文字か、同じ値を共有する文字範囲を指定するコンスセル(from . to))。valueは(char-table-range char-table key)がリターンする値。

全体として、functionに渡されるkey-valueのペアはchar-tableに格納されたすべての値を表す。

リターン値は常にnilである。map-char-table呼び出しを有用にするためにfunctionは副作用をもつこと。たとえば以下は構文テーブルを調べる方法:

(let (accumulator)
   (map-char-table
    (lambda (key value)
      (setq accumulator
            (cons (list
                   (if (consp key)
                       (list (car key) (cdr key))
                     key)
                   value)
                  accumulator)))
    (syntax-table))
   accumulator)
⇒
(((2597602 4194303) (2)) ((2597523 2597601) (3))
 ... (65379 (5 . 65378)) (65378 (4 . 65379)) (65377 (1))
 ... (12 (0)) (11 (3)) (10 (12)) (9 (0)) ((0 8) (3)))

6.7 ブールベクター

ブールベクター(bool-vector)はベクターとよく似ていますが、値にtとnilしか格納できません。ブールベクターの要素に非nil値の格納を試みると、そこにはtが格納されます。すべての配列と同様、ブールベクターのインデックスは0から開始され、一度ブールベクターが作成されたら長さを変更することはできません。ブールベクターは定数として評価されます。

ブールベクターを処理する特別な関数がいくつかあります。その関数以外にも、他の種類の配列に使用されるのと同じ関数でブールベクターを操作できます。

Function: make-bool-vector length initial ¶: initialに初期化されたlength要素の新しいブールベクターをリターンする。

Function: bool-vector &rest objects ¶: この関数は引数objectsを要素にもつブールベクターを作成してリターンする。

Function: bool-vector-p object ¶: この関数はobjectがブールベクターであればt、それ以外はnilをリターンする。

以下で説明するように、ブールベクターのセット処理を行なう関数がいくつかあります:

Function: bool-vector-exclusive-or a b &optional c ¶: ブールベクターaとbのビットごとの排他的論理和(bitwise exclusive or)をリターンする。オプション引数cが与えられたら、この処理の結果はcに格納される。引数にはすべて同じ長さのブールベクターを指定すること。

Function: bool-vector-union a b &optional c ¶: ブールベクターaとbのビットごとの論理和(bitwise or)をリターンする。オプション引数cが与えられたら、この処理の結果はcに格納される。引数にはすべて同じ長さのブールベクターを指定すること。

Function: bool-vector-intersection a b &optional c ¶: ブールベクターaとbのビットごとの論理積(bitwise and)をリターンする。オプション引数cが与えられたら、この処理の結果はcに格納される。引数にはすべて同じ長さのブールベクターを指定すること。

Function: bool-vector-set-difference a b &optional c ¶: ブールベクターaとbの差集合(set difference)をリターンする。オプション引数cが与えられたら、この処理の結果はcに格納される。引数にはすべて同じ長さのブールベクターを指定すること。

Function: bool-vector-not a &optional b ¶: ブールベクターaの補集合(set complement)をリターンする。オプション引数bが与えられたら、この処理の結果はbに格納される。引数にはすべて同じ長さのブールベクターを指定すること。

Function: bool-vector-subsetp a b ¶: a内のすべてのt値がbでもt値ならt、それ以外はnilをリターンする。引数にはすべて同じ長さのブールベクターを指定すること。

Function: bool-vector-count-consecutive a b i ¶: iから始まるaの、bと等しい連続する要素の数をリターンする。aはブールベクターで、bはtかnil、iはaのインデックス。

Function: bool-vector-count-population a ¶: ブールベクターaからtであるような要素の数をリターンする。

長さ8以下のブール値のプリント表記は1文字で表されます。

(bool-vector t nil t nil)
     ⇒ #&4"^E"
(bool-vector)
     ⇒ #&0""

他のベクター同様、vconcatを使用してブールベクターをプリントできます:

(vconcat (bool-vector nil t nil t))
     ⇒ [nil t nil t]

以下はブールベクターを作成、確認、更新する別の例です:

(setq bv (make-bool-vector 5 t))
     ⇒ #&5"^_"
(aref bv 1)
     ⇒ t
(aset bv 3 nil)
     ⇒ nil
bv
     ⇒ #&5"^W"

control-_の2進コードは11111、control-Wは10111なので、この結果は理にかなっています。

6.8 オブジェクト用固定長リングの管理

リング(ring)は挿入、削除、ローテーション、剰余(modulo)でインデックスづけされた、参照と走査(traversal)をサポートする固定長のデータ構造です。ringパッケージにより効率的なリングデータ構造が実装されています。このパッケージは、このセクションにリストした関数を提供します。

Emacsにあるkillリングやマークリングのようないくつかのリングは、実際には単なるリストとして実装されていることに注意してください。したがってこれらのリングにたいしては、以下の関数は機能しないでしょう。

Function: make-ring size ¶: この関数はsizeオブジェクトを保持できる、新しいリングをリターンする。sizeは整数。

Function: ring-p object ¶: この関数はobjectがリングならt、それ以外はnilをリターンする。

Function: ring-size ring ¶: この関数はringの最大の要素数をリターンする。

Function: ring-length ring ¶: この関数はringに現在含まれるオブジェクトの数をリターンする。値がring-sizeのリターンする値を超えることはない。

Function: ring-elements ring ¶: この関数はring内のオブジェクトのリストをリターンする。リストの順序は新しいオブジェクトが先頭になる。

Function: ring-copy ring ¶: この関数は新しいリングとしてringのコピーをリターンする。新しいリングはringと同じ(eqな)オブジェクトを含む。

Function: ring-empty-p ring ¶: この関数はringが空ならt、それ以外はnilをリターンする。

リング内の一番新しい要素は常にインデックス0をもちます。より大きいインデックスは、より古い要素に対応します。インデックスはリング長のmoduloにより計算されます。インデックス-1は一番古い要素、-2は次に古い要素、...となります。

Function: ring-ref ring index ¶: この関数はインデックスindexにあるring内のオブジェクトをリターンする。indexには負やリング長より大きい数を指定できる。ringが空ならring-refはエラーをシグナルする。

Function: ring-insert ring object ¶

この関数は一番新しい要素としてobjectをringに挿入してobjectをリターンする。

リングが満杯なら新しい要素用の空きを作るために、挿入により一番古い要素が削除される。

Function: ring-remove ring &optional index ¶: ringからオブジェクトを削除してそのオブジェクトをリターンする。引数indexはどのアイテムを削除するかを指定する。これがnilなら、それは一番古いアイテムを削除することを意味する。ringが空ならring-removeはエラーをシグナルする。

Function: ring-insert-at-beginning ring object ¶

この関数は一番古い要素としてobjectをringに挿入する。リターン値に意味はない。

リングが満杯なら、この関数は挿入される要素のための空きを作るために一番新しい要素を削除する。

Function: ring-resize ring size ¶: ringのサイズをsizeにセットする。新たなサイズのほうが小さければリング内の古いアイテムは破棄される。

リングサイズを超過しないよう注意すれば、そのリングをFIFO(first-in-first-out: 先入れ先出し)のキューとして使用することができます。たとえば:

(let ((fifo (make-ring 5)))
  (mapc (lambda (obj) (ring-insert fifo obj))
        '(0 one "two"))
  (list (ring-remove fifo) t
        (ring-remove fifo) t
        (ring-remove fifo)))
     ⇒ (0 t one t "two")

7 レコード

レコードの目的はEmacsにビルトインされていない新たな型のオブジェクトをプログラマーが作成できるようにすることです。これらはcl-defstructやdefclassのインスタンスを表現する基礎として使用されています。

レコードオブジェクトは内部的にはベクターと似ています。レコードオブジェクトのスロットはarefを使用してアクセス可能であり、copy-sequenceを使用してコピーできます。しかし最初のスロットはtype-ofがリターンする型を保持するために使用されます。更に現実装ではレコードは最大で4096スロットを所有できますが、ベクターはそれより多くのスロットを所有できます。レコードは配列と同じように0基準のインデックスを使用するので、最初のスロットはインデックスが0になります。

型スロット(type slot)はシンボルか型記述子であるべきです。型記述子なら型を命名するシンボルがリターンされます。型記述子を参照してください。その他の種類のオブジェクトはすべてそのままリターンされます。

レコードのプリント表現では‘#s’の後にコンテンツを指定するリストが続きます。リストの最初の要素はそのレコードの型である必要があります。後続の要素はレコードのスロットです。

レコードの型を新たに定義するLispプログラムは他の型名との衝突を避けるために、通常はレコード型を導入する部分では型名にパッケージの命名規約を使用するべきです。衝突する可能性がある型名は、パッケージが定義したレコード型のロード時には不明かもしれないことに注意してください。これらは将来のある時点でロードされる可能性があります。

レコードは評価にたいして定数とみなされます。評価すると結果は同じレコードになります。レコードは評価されずにスロットのチェックさえ行われません。自己評価を行うフォームを参照してください。

7.1 レコード関数

Function: recordp object ¶

この関数はobjectがレコードならtをリターンする。

(recordp #s(a))
     ⇒ t

Function: record type &rest objects ¶

この関数は型がtypeであり、残りのスロットが残りの引数objectsであるようなレコードを作成してリターンする。

(record 'foo 23 [bar baz] "rats")
     ⇒ #s(foo 23 [bar baz] "rats")

Function: make-record type length object ¶

この関数は型がtype、objectで初期化されたスロット数がlengthの新たなレコードをリターンする。

(setq sleepy (make-record 'foo 9 'Z))
     ⇒ #s(foo Z Z Z Z Z Z Z Z Z)

7.2 後方互換

レコードを使用しない古いバージョンのcl-defstructでコンパイルされたコードを新しいEmacsで実行したときに問題が発生するかもしれません。この魔問題を軽減するために、Emacsは古いcl-defstructの使用を検知した際に古い構造体オブジェクトがレコードであるかのように処理するモードを有効にします。

Function: cl-old-struct-compat-mode arg ¶: argが正なら旧スタイルの構造体にたいする後方互換を有効にする。

8 ハッシュテーブル

ハッシュテーブル(hash table)は非常に高速なルックアップテーブルの一種で、キーに対応する値をマップするという点ではalist(連想リストを参照)に似ています。ハッシュテーブルは以下の点でalistと異なります:

ハッシュテーブルでのルックアップ(lookup: 照合)は、巨大なテーブルにたいして非常に高速である — 実際のところルックアップに必要な時間は、そのテーブルに格納されている要素数とは基本的に無関係である。ハッシュテーブルには一定のオーバーヘッドが多少あるので、小さいテーブル(数十の要素)ではalistのほうが高速だろう。
ハッシュテーブル内の対応関係に特定の順序はない。
2つのalistで共通の末尾(tail)を共有させるような、2つのハッシュテーブル間で構造を共有する方法はない。

Emacs Lispは一般的な用途のハッシュテーブルデータ型とともに、それらを処理する一連の関数を提供します。ハッシュテーブルは‘#s’、その後にハッシュテーブルのプロパティと内容を指定するリストが続く、特別なプリント表現をもちます。ハッシュテーブルの作成を参照してください(ハッシュ表記の最初に使用される‘#’文字は、読み取り表現をもたないオブジェクトのプリント表現であり、これはハッシュテーブルに何も行わない。プリント表現と読み取り構文を参照のこと)。

obarray(オブジェクト配列)もハッシュテーブルの一種ですが、これらは異なる型のオブジェクトであり、intern(インターン)されたシンボルを記録するためだけに使用されます(シンボルの作成とinternを参照)。

8.1 ハッシュテーブルの作成

ハッシュテーブルを作成する基本的な関数はmake-hash-tableです。

Function: make-hash-table &rest keyword-args ¶

この関数は指定された引数に対応する新しいハッシュテーブルを作成する。引数はキーワード(特別に認識される独自のシンボル)と、それに対応する値を交互に指定することで構成される。

make-hash-tableではいくつかのキーワードが意味をもつが、実際に知る必要があるのは:testと:weaknessの2つだけである。

:test test

これはそのハッシュテーブルにたいしてキーを照合する方法を指定する。デフォルトはeqlであり他の代替としてはeqやequalがある:

eql: キーが数字ならそれらがequal、つまりそれらの値が等しくどちらも整数か浮動小数点数なら同一。それ以外なら別の2つのオブジェクトは決して同一とならない。
eq: 別の2つのLispオブジェクトはすべて別のキーになる。
equal: 別の2つのLispオブジェクトで、それらがequalなら同一のキーである。

testにたいして追加の選択肢を定義するために、define-hash-table-test (ハッシュの比較の定義を参照)を使用することができる。

:weakness weak

ハッシュテーブルのweakness(強度)は、ハッシュテーブル内に存在するキーと値をガーベージコレクションから保護するかどうかを指定する。

値weakにはnil、key、value、key-or-value、key-and-value、またはt(key-and-valueのエイリアス)のいずれかを指定しなければならない。weakがkeyならそのハッシュテーブルは、(キーが他の場所で参照されていなければ)ハッシュテーブルのキーがガーベージコレクトされるのを妨げられない。ある特定のキーがガーベージコレクトされると、それに対応する連想はハッシュテーブルから削除される。

weakがvalueならそのハッシュテーブルは、(値が他の場所で参照されていなければ)ハッシュテーブルの値がガベージコレクトされるのを妨げられない。ある特定の値がガーベージコレクトされると、それに対応する連想はハッシュテーブルから削除される。

weakがkey-and-value(かt)なら、その連想を保護するためにはキーと値の両方が生きていなければならない。したがってそのハッシュテーブルは、キーと値の一方だけをガーベージコレクトから守ることはしない。キーか値のどちらか一方がガーベージコレクトされたら、その連想は削除される。

weakがkey-or-valuenara、キーか値のどちらか一方で、その連想を保護することができる。したがってキーと値の両方がガベージコレクトされたときだけ(それがハッシュテーブル自体にたいする参照でなければ)、ハッシュテーブルからその連想が削除される。

weakのデフォルトはnilなので、ハッシュテーブルから参照されているキーと値はすべてガーベージコレクションから保護される。

:size size

これはそのハッシュテーブルに保管しようとしている、連想の数にたいするヒントを指定する。数が概算で判っていれば、この方法でそれを指定して処理を若干効率的にすることができる。小さすぎるサイズを指定すると、そのハッシュテーブルは必要に応じて自動的に拡張されるが、これを行なうために時間が余計にかかる。

デフォルトのサイズは65。

:rehash-size rehash-size

ハッシュテーブルに連想を追加するとき、そのテーブルが満杯ならテーブルを自動的に拡張する。この値はその際にどれだけハッシュテーブルを拡張するかを指定する。

rehash-sizeが整数(正であること)なら、通常のサイズにrehash-sizeに近い値を加えることによりハッシュテーブルが拡張される。rehash-sizeが浮動小数(1より大きい方がよい)なら、古いサイズにその数に近い値を乗じることによりハッシュテーブルが拡張される。

デフォルト値は1.5。

:rehash-threshold threshold

これはハッシュテーブルが一杯(なのでもっと大きく拡張する必要がある)だと判断される基準を指定する。thresholdの値は1以下の正の浮動小数点数であること。実際のエントリー数が通常のサイズにたいする指定した割合に近い値を超えるとハッシュテーブルは一杯(full)になる。thresholdのデフォルトは0.8125。

ハッシュテーブルのプリント表現を使用してハッシュテーブルを作成することもできます。指定されたハッシュテーブル内の各要素が、有効な入力構文(プリント表現と読み取り構文を参照)をもっていれば、Lispリーダーはこのプリント表現を読み取ることができます。たとえば以下は値val1 (シンボル)と300 (数字)に関連づけられた、キーkey1とkey2 (両方ともシンボル)をハッシュテーブルに指定します。

#s(hash-table size 30 data (key1 val1 key2 300))

しかしこれをEmacs Lispコードで使用する際には、ハッシュテーブルを新たに作成するかどうかは未定義であることに注意してください。ハッシュテーブルを新たに作成したければ、常にmake-hash-tableを使う必要があります(自己評価を行うフォームを参照)。

ハッシュテーブルのプリント表現は‘#s’と、その後の‘hash-table’で始まるリストにより構成されます。このリストの残りの部分はそのハッシュテーブルのプロパティと初期内容を指定する、0個以上のプロパティと値からなるペアで構成されるべきです。プロパティと値はそのまま読み取られます。有効なプロパティ名はsize、test、weakness、rehash-size、rehash-threshold、dataです。dataプロパティは、初期内容にたいするキーと値のペアからなるリストであるべきです。他のプロパティは、上記で説明したmake-hash-tableのキーワード(:size、:testなど)と同じ意味をもちます。

バッファーやフレームのような、入力構文をもたないオブジェクトを含んだ初期内容をもつハッシュテーブルを指定できないことに注意してください。そのようなオブジェクトは、ハッシュテーブルを作成した後に追加します。

8.2 ハッシュテーブルへのアクセス

このセクションではハッシュテーブルにアクセスしたり、連想を保管する関数を説明します。比較方法による制限がない限り、一般的には任意のLispオブジェクトをハッシュキーとして使用できます。

Function: gethash key table &optional default ¶: この関数はtableのkeyを照合してそれに関連づけられたvalue、table内にkeyをもつ連想が存在しなければdefaultをリターンする。

Function: puthash key value table ¶: この関数はtable内に値valueをもつkeyの連想を挿入します。tableがすでにkeyの連想をもつなら、valueで古い連想値を置き換える。この関数は常にvalueをリターンする。

Function: remhash key table ¶

この関数はtableにkeyの連想があればそれを削除する。keyが連想をもたなければremhashは何も行なわない。

Common Lispに関する注意: Common Lispではremhashが実際に連想を削除したときは非nil、それ以外はnilをリターンする。Emacs Lispではremhashは常にnilをリターンする。

Function: clrhash table ¶: この関数はハッシュテーブルtableからすべての連想を削除するので、そのハッシュテーブルは空になる。これはハッシュテーブルのクリーニング(clearing)とも呼ばれる。clrhashは空のtableをリターンする。

Function: maphash function table ¶: この関数はtable内の各連想にたいして一度ずつfunctionを呼び出す。関数functionは2つの引数 — tableにリストされたkeyと、それに関連づけられたvalue — を受け取ること。maphashはnilをリターンする。

8.3 ハッシュの比較の定義

define-hash-table-testでキーを照合する新しい方法を定義できます。この機能を使用するにはハッシュテーブルの動作方法と、ハッシュコード(hash code)の意味を理解する必要があります。

概念的にはハッシュテーブルを1つの連想を保持できるスロットがたくさんある巨大な配列として考えることができます。キーを照合するにはまず、gethashがキーから整数(ハッシュコード)を計算します。配列の長さを法(modulo)としてこの整数を縮小して(訳注:配列の長さで割った余りの整数にして)、配列内のインデックスを生成することができます。それから探しているキーが見つかったかどうか確認するためにそのスロット、必要なら近くのスロットを調べます。

したがってキーを照合する新たな方法を定義するにはキーからハッシュコードを計算する関数、および2つのキーを直接比較する関数の両方を指定する必要があります。この2つの関数は互いに一貫性をもつ必要があります。すなわちキーを比較してequalなら、2つのキーのハッシュコードは同一であるべきです。さらに(ガーベージコレクターからの呼び出しのように)2つの関数は任意のタイミングで呼び出される可能性があるので、関数が副作用をもたないこと、すぐにリターンすること、そしてこれらの関数の挙動はそのキーの不変の性質だけに依存する必要があります。

Function: define-hash-table-test name test-fn hash-fn ¶

この関数はnameという名前の新たなハッシュテーブルテストを定義します。

この方法でnameを定義した後は、make-hash-tableの引数testにこれを使用することができる。これを行なう際は、そのハッシュテーブルのキー値の比較にtest-fn、キー値からハッシュコードを計算するためにhash-fnを使用することになる。

関数test-fnは2つの引数(2つのキー)をとり、それらが同一と判断されたときは非nilをリターンする。

関数hash-fnは1つの引数(キー)を受け取り、そのキーのハッシュコード(整数)をリターンすること。よい結果を得るために、その関数は負のfixnumを含むfixnumの全範囲をハッシュコードに使用すること。

指定された関数は、プロパティhash-table-testの配下の、nameというプロパティリストに格納される。そのプロパティの値形式は(test-fn hash-fn)。

Function: sxhash-equal obj ¶

この関数はLispオブジェクトobjのハッシュコードをリターンする。リターン値はobjと、それが指す別のLispオブジェクトの内容を表す整数。

2つのオブジェクトobj1とobj2がequalならば(sxhash-equal obj1)と(sxhash-equal obj2)は同じ整数になる。

2つのオブジェクトがequalでなければ、通常ならsxhash-equalがリターンする値は異なるが常に異なるとも限らない。sxhash-equalはネストされた構造体を深く再帰しないことによって十分高速になるようデザインされている(ハッシュテーブルのインデックス作成に使用するため)。加えて稀に(運次第)ではあるがsxhash-equalが同じ結果を与える、2つの異なって見えるシンプルなオブジェクトに出会うことがあるかもしれない。したがって一般的にはオブジェクトが変更されたかどうかのチェックにsxhash-equalを用いることはできない。

Common Lispに関する注意: Common Lispではこれに似た関数はsxhashと呼ばれる。Emacsは互換性のためにsxhash-equalにたいするエイリアスとしてこの名前を提供している。

Function: sxhash-eq obj ¶

この関数はLispオブジェクトobjにたいするハッシュコードをリターンする。結果はobjの識別値であり内容が反映されているわけではない。

2つのオブジェクトobj1とobj2がeqなら(sxhash-eq obj1)と(sxhash-eq obj2)は同じ整数になる。

Function: sxhash-eql obj ¶

この関数はeqlによる比較に適したLispオブジェクトobjにたいするハッシュコードをリターンする。つまり浮動小数点数とbignum以外のobjなら、それにたいする識別値(浮動小数点数ならその値にたいするハッシュコード)を生成する。

2つのオブジェクトobj1とobj2がeqlなら(sxhash-eql obj1)と(sxhash-eql obj2)は同じ整数になる。

以下はcaseを区別しない文字列のキーをもつハッシュテーブルを作成する例です。

(defun string-hash-ignore-case (a)
  (sxhash-equal (upcase a)))

(define-hash-table-test 'ignore-case
  'string-equal-ignore-case 'string-hash-ignore-case)

(make-hash-table :test 'ignore-case)

以下は事前に定義されたテスト値equalと等価なテストを行なうハッシュテーブルを定義できるという例です。キーは任意のLispオブジェクトで、equalに見えるオブジェクトは同じキーと判断されます。

(define-hash-table-test 'contents-hash 'equal 'sxhash-equal)

(make-hash-table :test 'contents-hash)

ハッシュ関数の実装はセッション間や異なるアークテクチャー間で変わる可能性のあるオブジェクトストレージのいくつかの詳細を使用するので、LispプログラムはEmacsセッションの間はハッシュコードが保存されることに依存するべきではありません。

8.4 ハッシュテーブルのためのその他関数

以下はハッシュテーブルに作用する他の関数です。

Function: hash-table-p table ¶: この関数はtableがハッシュテーブルオブジェクトなら非nilをリターンする。

Function: copy-hash-table table ¶: この関数はtableのコピーを作成してリターンする。そのテーブル自体がコピーされたものである場合のみ、キーと値が共有される。

Function: hash-table-count table ¶: この関数はtable内の実際のエントリー数をリターンする。

Function: hash-table-test table ¶: この関数はハッシュを行なう方法と、キーを比較する方法を指定するために、table作成時に与えられたtestの値をリターンする。ハッシュテーブルの作成のmake-hash-tableを参照されたい。

Function: hash-table-weakness table ¶: この関数はハッシュテーブルtableに指定されたweakの値をリターンする。

Function: hash-table-rehash-size table ¶: この関数はtableのrehash-sizeをリターンする。

Function: hash-table-rehash-threshold table ¶: この関数はtableのrehash-thresholdをリターンする。

Function: hash-table-size table ¶: この関数はtableの現在の定義されたサイズをリターンする。

9 シンボル

シンボル(symbol)は一意な名前をもつオブジェクトです。このチャプターではシンボル、シンボルの構成要素とプロパティリスト、およびシンボルの作成とインターンする方法を説明します。別のチャプターではシンボルを変数として使用したり、関数名として使用する方法が説明されています。変数と関数を参照してください。シンボルの正確な入力構文については、シンボル型を参照してください。

symbolpを使用して、任意のLispオブジェクトがシンボルかどうかをテストできます:

Function: symbolp object ¶: この関数はobjectがシンボルならt、それ以外はnilをリターンする。

9.1 シンボルの構成要素		シンボルは名前、値、関数定義、プロパティリストをもつ。
9.2 シンボルの定義		定義はシンボルが使用される方法を示す。
9.3 シンボルの作成とintern		シンボルが一意に保たれる方法。
9.4 シンボルのプロパティ		さまざまな情報を記録するために各シンボルはプロパティリストをもつ。
9.5 ショートハンド		シンボル名のタイプ量を少なくしつつ正しく組織化するには。
9.6 位置をもつシンボル		整数の位置を含んだシンボルの変種

9.1 シンボルの構成要素

各シンボルは4つの構成要素(もしくは“セル”)をもち、構成要素はそれぞれ別のオブジェクトを参照します:

プリント名(print name) ¶: そのシンボルの名前。
値(value) ¶: 変数としてのそのシンボルの現在値。
関数(function) ¶: そのシンボルの関数定義。シンボル、キーマップ、キーボードマクロも保持できる。
プロパティリスト(property list) ¶: そのシンボルのプロパティリスト。

プリント名のセルは常に文字列を保持し、それを変更することはできません。他の3つのセルには、任意のLispオブジェクトをセットすることができます。

プリント名のセルはシンボルの名前となる文字列を保持します。シンボルはシンボル名によりテキストとして表されるので、2つのシンボルが同じ名前をもたないことが重要です。Lispリーダーはシンボルを読み取るごとに、それを新規作成する前に、指定されたシンボルがすでに存在するかを調べます。シンボルの名前を得るには関数symbol-name(シンボルの作成とinternを参照)を使用します。しかしシンボルがそれぞれ一意なプリント名(print name)を1つだけもつとしても、“ショートハンド(shorthand)”と呼ばれる違うエイリアス名を通じて同じシンボルを参照することは可能です(ショートハンドを参照)。

値セルは変数としてのシンボルの値(そのシンボル自身がLisp式として評価されたときに得る値)を保持します。ローカルバインディング(local binding)やスコーピングルール(scoping rules)等のような複雑なものを含めて、変数のセットや取得方法については変数を参照してください。ほとんどのシンボルは値として任意のLispオブジェクトをもつことができますが、一部の特別なシンボルは変更できない値をもちます。これらにはnil、t、および名前が‘:’で始まるすべてのシンボル(キーワード(keyword)と呼ばれる)が含まれます。変更不可な変数を参照してください。

関数セルはシンボルの関数定義を保持します。実際はにはfooの関数セルの中に保管されている関数を意味するときに、“関数foo”といってそれを参照することがよくあります。わたしたちは必要なときだけ、これを明確に区別することにします。関数セルは通常は関数(関数を参照)か、マクロ(マクロを参照)を保持するために使用されます。しかし関数セルはシンボル(シンボル関数インダイレクションを参照)、キーボードマクロ(キーボードマクロを参照)、キーマップ(キーマップを参照)、またはオートロードオブジェクト(自動ロードを参照)を保持するためにも使用できます。シンボルの関数セルの内容を得るには、関数symbol-function (関数セルの内容へのアクセスを参照)を使用します。

プロパティリストのセルは、通常は正しくフォーマットされたプロパティリストを保持するべきです。シンボルのプロパティリストを得るには関数symbol-plistを使用します。シンボルのプロパティを参照してください。

マクロセルと値セルがvoid(空)のときもあります。voidとはそのセルがどのオブジェクトも参照していないことを意味します(これはシンボルvoidを保持するのともシンボルnilを保持するのとも異なる)。voidの関数セルまたは値セルを調べようとすると結果は‘Symbol's value as variable is void’のようなエラーとなります。

各シンボルは値セルと関数セルを別個にもつので、変数名と関数名が衝突することはありません。たとえばシンボルbuffer-file-nameが値(カレントバッファーでvisitされているファイルの名前)をもつと同様に、関数定義(ファイルの名前をリターンするプリミティブ関数)をもつことができます:

buffer-file-name
     ⇒ "/gnu/elisp/symbols-ja.texi"
(symbol-function 'buffer-file-name)
     ⇒ #<subr buffer-file-name>

9.2 シンボルの定義

定義(definition)とは、特別な方法での使用の意図を宣言する特別な種類のLisp式です。定義とは通常はシンボルにたいする値を指定するか、シンボルにたいする1つの種類の使用についての意味とその方法で使用する際のシンボルの意味のドキュメントを指定します。したがってシンボルを変数として定義すると、その変数の初期値に加えてその変数のドキュメントを提供できます。

defvarとdefconstはグローバル変数(global variable) — Lispプログラムの任意の箇所からアクセスできる変数 — として定義するためのスペシャルフォームです。変数についての詳細は変数を参照してください。カスタマイズ可能な変数を定義するにはdefcustom (サブルーチンとしてdefvarも呼び出す)を使用します(カスタマイゼーション設定を参照)。

最初にシンボルが変数として定義されているかどうかに関わらず、原則としてsetqで任意のシンボルに値を割り当てることができます。しかし使用したいグローバル変数それぞれにたいして変数定義を記述するべきです。さもないとレキシカルスコープ(変数のバインディングのスコーピングルールを参照)が有効なときに変数が評価されると、Lispプログラムが正しく動作しないかもしれません。

defunはラムダ式(lambda expression)を生成して、そのシンボルの関数セルに格納することにより、そのシンボルを関数として定義します。したがってこのシンボルの関数定義は、そのラムダ式になります(関数セルの内容を意味する用語“関数定義(function definition)”は、defunがシンボルに関数としての定義を与えるというアイデアに由来する)。関数を参照してください。

defmacroはシンボルをマクロとして定義します。これはマクロオブジェクトを作成してシンボルの関数セルにそれを格納します。シンボルにはマクロと関数を与えることができますが、マクロと関数定義はどちらも関数セルに保持されるのにたいし、関数セルに保持できるのは常にただ1つのLispオブジェクトなので、一度に両方を行なうことはできないことに注意してください。マクロを参照してください。

前に注記したようにEmacs Lispではシンボルを(たとえばdefvarで)変数として定義して、同じシンボルを(たとえばdefunで)関数やマクロとして両方定義することができます。このような定義は衝突しません。

これらの定義は、プログラミングツールのガイドを果たすこともできます。たとえば、C-h fおよびC-h vコマンドは、関係ある変数、関数、マクロ定義へのリンクを含むヘルプバッファーを作成します。Name Help in The GNU Emacs Manualを参照してください。

9.3 シンボルの作成とintern

GNU Emacs Lispでシンボルが作成される方法を理解するには、Lispがシンボルを読み取る方法を理解しなければなりません。Lispは同じコンテキストで同じ文字シーケンスを読み取ったら、毎回同じシンボルを見つけることを保証しなければなりません。これに失敗すると、完全な混乱を招くでしょう。

ソースコード内でシンボルを参照する名前に出会うと、Lispリーダーはその名前の文字すべてを読み取ります。それからプログラマーが意図したシンボルを見つけるために、obarray(オブジェクト配列)と呼ばれるテーブルでその名前を照合します。この照合に使用されるテクニックは“ハッシュ化(hashing)”と呼ばれています。これは照合を行う際に文字シーケンスを“ハッシュコード(hash code)”として知られる数値に変換する効率的な手法です。たとえばJan Jonesを見つけるときは、電話帳を表紙から1頁ずつ探すのではなくJの頁から探し始めます。これはハッシュ化の簡単なバージョンです。obarrayの各要素は与えられたハッシュコードとともに、すべてのシンボルを保持するバケット(bucket)です。与えられた名前を探すためには、バケットの中からハッシュコードがその名前であるような、すべてのシンボルを探すのが効果的です(同じアイデアは一般的なEmacsのハッシュテーブルでも使用されていがこれらはデータ型が異なる。ハッシュテーブルを参照されたい)。

Lispリーダーは名前の照合時には“ショートハンド(shorthands 速記、簡略表記)”も考慮します。プログラマーがショートハンドを提供した場合には、たとえソースコード内でシンボル名が完全な形式で与えられなくても、リーダーはシンボルを見つけることができます。もちろんリーダーはそのようなショートハンドに関して事前に既定されたコンテキストを認識する必要があり、同様に“Jan”という名前だけでJan Jonesを一意に参照できるコンテキストが必要です。これはJonesの中にいるときや、Janが最近言及されていれば問題はないでしょうが、他の状況下では非常に曖昧です。ショートハンドを参照してください。

探している名前のシンボルが見つかったら、リーダーはそのシンボルを使用します。obarrayにその名前のシンボルが含まれなければ、リーダーは新しいシンボルを作成してそれをobarrayに追加します。特定の名前のシンボルを探して追加することをインターン(intern)と言い、これが行なわれた後はそのシンボルはインターンされたシンボル(interned symbol)と呼ばれます。

インターンすることによりある特定の名前のシンボルは、各obarrayに1つだけであることが保証されます。同じ名前のシンボルが他に存在するかもしれませんが、同じobarrayには存在しません。したがってリーダーは、(同じobarrayを読みつづける限り)同じ名前にたいして同じシンボルを取得します。

インターンは通常はリーダー内で自動的に発生しますが、他のプログラムがこれを行ないたい場合もあるかもしれません。たとえばM-xコマンドはその後にミニバッファーを使用してコマンド名を文字列として取得して、その文字列をインターンしてからインターンされたその名前のシンボルを得ます。別の例として、照合する人名それぞれをシンボル名としてインターンする架空の電話帳プログラムは、たとえそれがobarrayに含まれていなくても、誰かが最後にそれを照合した際に情報をアタッチできるようにする場合などです。

すべてのシンボルを含むobarrayはありません。実際にどのobarrayにも含まれないシンボルがいくつかあります。これらはインターンされていないシンボル(uninterned symbols)と呼ばれます。インターンされていないシンボルも、他のシンボルと同じく4つのセルをもちます。しかしインターンされていないシンボルへのアクセスを得る唯一の方法は、他の何らかのオブジェクトとして探すか、変数の値として探す方法だけです。インターンされていないシンボルはLispコード生成時に有用な場合があります。以下を参照してください。

Emacs Lispではobarrayはベクターです。ベクター内の各要素がバケットになります。要素の値は、名前がそのバケットにハッシュされるようなインターンされたシンボル、またはバケットが空のときは0です。インターンされたシンボルは、そのバケット内の次のシンボルへの内部リンク(ユーザーからは見えない)をもちます。これらのリンクは不可視なので、mapatoms (以下参照)を使用する方法をのぞき、obarray内のすべてのシンボルを探す方法はありません。バケット内のシンボルの順番に意味はありません。

空のobarrayではすべての要素が0なので、(make-vector length 0)でobarrayを作成することができます。obarrayを作成する有効な方法はこれだけです。長さに素数を指定するとよいハッシュ化がされる傾向があります。2の累乗から1減じた長さもよい結果を生む傾向があります。

自分でobarrayにシンボルを置かないでください。これはうまくいきません — obarrayに正しくシンボルを入力できるのはinternだけです。

Common Lispに関する注意: Common Lispとは異なりEmacs Lispでは複数の異なる“パッケージ”における同一の名前のインターンは提供されていないので、異なるパッケージごとに同じ名前のシンボルが複数作成される。Emacs Lispは“ショートハンド”と呼ばれる別の名前空間システムを提供する(ショートハンドを参照)。

以下の関数のほとんどは、引数に名前とobarrayをとります。名前が文字列以外、またはobarrayがベクター以外ならwrong-type-argumentエラーがシグナルされます。

Function: symbol-name symbol ¶

この関数はsymbolの名前を文字列としてリターンする。たとえば:

(symbol-name 'foo)
     ⇒ "foo"

警告: この関数がリターンした文字列は絶対変更してはならない。これを行うことによってEmacsの機能が損なわれるかもしれず、Emacsのクラッシュすら招きかねない。

インターンされていないシンボルの作成は、Lispコードを生成するとき有用です。なぜなら作成されたコード内で変数として使用されているインターンされていないシンボルは、他のLispプログラムで使用されている任意の変数と競合することはありえないからです。

Function: make-symbol name ¶

この関数は新たに割り当てられた、名前がname(文字列でなければならない)であるような、インターンされていないシンボルをリターンする。このシンボルの値と関数はvoidで、プロパティリストはnil。以下の例ではsymの値はfooとeqではない。なぜならこれは名前が‘foo’という、インターンされていないシンボルだからである。

(setq sym (make-symbol "foo"))
     ⇒ foo
(eq sym 'foo)
     ⇒ nil

Function: gensym &optional prefix ¶: この関数はmake-symbolを使用してprefixにgensym-counterを付加した名前のシンボルをリターンする。更にこの関数を複数回呼び出しても同一名のシンボルが生成されないことを保証するためにカウンターを増加する。プレフィックスのデフォルトは"g"。

意図せず生成したコードのプリント表現をインターンした際の問題を避けるために、make-symbolではなくgensymの使用をお勧めします。(プリント表現と読み取り構文を参照)。

Function: intern name &optional obarray ¶

この関数は名前がnameであるような、インターンされたシンボルをリターンする。オブジェクト配列obarrayの中にそのようなシンボルが存在しなければ、internは新たにシンボルを作成してobarrayに追加してそれをリターンする。obarrayが省略されると、グローバル変数obarrayの値が使用される。

(setq sym (intern "foo"))
     ⇒ foo
(eq sym 'foo)
     ⇒ t

(setq sym1 (intern "foo" other-obarray))
     ⇒ foo
(eq sym1 'foo)
     ⇒ nil

Common Lispに関する注意: Common Lispでは既存のシンボルをobarrayにインターンできる。Emacs Lispではinternの引数はシンボルではなく文字列なのでこれを行なうことはできない。

Function: intern-soft name &optional obarray ¶

この関数はobarray内の名前がnameのシンボル、obarrayにその名前のシンボルが存在しなければnilをリターンする。したがって与えられた名前のシンボルがすでにインターンされているかテストするために、intern-softを使用することができる。obarrayが省略されるとグローバル変数obarrayの値が使用される。

引数nameにはシンボルも使用できる。この場合、指定されたobarrayにnameがインターンされていればname、それ以外ならnilをリターンする。

(intern-soft "frazzle")        ; そのようなシンボルは存在しない
     ⇒ nil
(make-symbol "frazzle")        ; インターンされていないシンボルを作成する
     ⇒ frazzle

(intern-soft "frazzle")        ; そのようなシンボルは見つからない
     ⇒ nil

(setq sym (intern "frazzle"))  ; インターンされたシンボルを作成する
     ⇒ frazzle

(intern-soft "frazzle")        ; シンボルが見つかった!
     ⇒ frazzle

(eq sym 'frazzle)              ; そしてそれは同じシンボル
     ⇒ t

Variable: obarray ¶: この変数はinternとreadが使用する標準のobarrayである。

Function: mapatoms function &optional obarray ¶

この関数はオブジェクト配列obarrayの中の各シンボルにたいして、functionを一度呼び出しその後nilをリターンする。obarrayが省略されると、通常のシンボルにたいする標準のオブジェクト配列obarrayの値がデフォルトになる。

(setq count 0)
     ⇒ 0
(defun count-syms (s)
  (setq count (1+ count)))
     ⇒ count-syms
(mapatoms 'count-syms)
     ⇒ nil
count
     ⇒ 1871

mapatomsを使用する他の例については、ドキュメント文字列へのアクセスのdocumentationを参照のこと。

Function: unintern symbol obarray ¶

この関数はオブジェクト配列obarrayからsymbolを削除する。obarrayの中にsymbolが存在しなければ、uninternは何も行なわない。obarrayがnilなら現在のobarrayが使用される。

symbolにシンボルではなく文字列を与えると、それはシンボルの名前を意味する。この場合、uninternは(もしあれば)obarrayからその名前のシンボルを削除する。そのようなシンボルが存在するならuninternは何も行なわない。

uninternがシンボルを削除したらt、それ以外はnilをリターンする。

9.4 シンボルのプロパティ

シンボルはそのシンボルについての様々な情報を記録するために使用される、任意の数のシンボルプロパティ(symbol properties)をもつことができます。たとえばシンボルのrisky-local-variableプロパティがnilなら、その変数の名前が危険なファイルローカル変数(ファイルローカル変数を参照)であることを意味します。

シンボルのプロパティとプロパティ値はそれぞれ、シンボルのプロパティリストセル(シンボルの構成要素を参照)に、プロパティリスト形式(プロパティリストを参照)で格納されます。

9.4.1 シンボルのプロパティへのアクセス

以下の関数を使用してシンボルプロパティにアクセスできます。

Function: get symbol property ¶

この関数はsymbolのプロパティリスト内の、名前がpropertyというプロパティの値をリターンする。そのようなプロパティが存在しなければnilをリターンする。したがって値がnilのときとプロパティが存在しないときの違いはない。

名前propertyはeqを使用して既存のプロパティと比較されるので、すべてのオブジェクトがプロパティとして適正である。

putの例を参照のこと。

Function: put symbol property value ¶

この関数はsymbolのプロパティリストの、プロパティ名propertyにvalueをputして、前のプロパティ値を置き換える。put関数はvalueをリターンする。

(put 'fly 'verb 'transitive)
     ⇒'transitive
(put 'fly 'noun '(a buzzing little bug))
     ⇒ (a buzzing little bug)
(get 'fly 'verb)
     ⇒ transitive
(symbol-plist 'fly)
     ⇒ (verb transitive noun (a buzzing little bug))

Function: symbol-plist symbol ¶: この関数はsymbolのプロパティリストをリターンする。

Function: setplist symbol plist ¶

この関数はsymbolのプロパティリストをplistにセットする。plistは通常は適正なプロパティリストであるべきだが、これは強制ではない。リターン値はplistです。

(setplist 'foo '(a 1 b (2 3) c nil))
     ⇒ (a 1 b (2 3) c nil)
(symbol-plist 'foo)
     ⇒ (a 1 b (2 3) c nil)

通常の用途には使用されない特別なobarray内のシンボルでは、非標準的な方法でプロパティリストセルを使用することに意味があるかもしれない。実際にabbrev(abbrevとabbrev展開を参照)のメカニズムでこれを行なっている。

以下のようにsetplistとplist-putでputを定義できる:

(defun put (symbol prop value)
  (setplist symbol
            (plist-put (symbol-plist symbol) prop value)))

Function: function-get symbol property &optional autoload ¶: この関数はgetと等価だがsymbolが関数のエイリアス名なら。実際の関数を命名するシンボルのプロパティリストを照合する点が異なる。関数の定義を参照のこと。オプション引数autoloadが非nilで、symbolが自動ロードされていれば、その自動ロードによりsymbolのpropertyがセットされるかもしれないので、この関数はそれの自動ロードを試みるだろう。autoloadがシンボルmacroなら、symbolが自動ロードされたマクロのときだけ自動ロードを試みる。

Function: function-put function property value ¶: この関数はfunctionのpropertyにvalueをセットする。functionはシンボルであること。関数のプロパティのセットには、putよりこの関数を呼び出すほうがよい。この関数を使用すれば、いつか古いプロパティから新しいプロパティへのリマップを実装することができるからである。

9.4.2 シンボルの標準的なプロパティ

Emacsで特別な目的のために使用されるシンボルプロパティを以下に一覧します。以下のテーブルで、“命名される関数(the named function)”と言うときは、関数名がそのシンボルであるような関数を意味します。“命名される変数(the named variable)”等の場合も同様です。

:advertised-binding: このプロパティリストは、命名される関数のドキュメントを表示する際に優先されるキーバインディングを指定する。ドキュメント内でのキーバインディングの置き換えを参照のこと。
char-table-extra-slots: 値が非nilなら、それは命名される文字テーブル型の追加スロットの数を指定する。文字テーブルを参照のこと。
customized-face
face-defface-spec
saved-face
theme-face: これらのプロパティはフェイスの標準のフェイス仕様(face specs)と、フォント仕様のsaved-face、customized-face、themed-faceを記録するために使用される。これらのプロパティを直接セットしないこと。これらのプロパティはdeffaceと関連する関数により管理される。フェイスの定義を参照のこと。
customized-value
saved-value
standard-value
theme-value: これらのプロパティは、カスタマイズ可能な変数のstandard-value、saved-value、customized-value(しかし保存はされない)、themed-valueを記録するために使用される。これらのプロパティを直接セットしないこと。これらはdefcustomと関連する関数により管理される。カスタマイゼーション変数の定義を参照のこと。
definition-name: このプロパティはソースファイルのテキスト検索ではシンボルの定義を見つけるのが困難な際に、ソースコードから定義を見つけるために使用される。たとえばdefine-derived-mode (派生モードの定義を参照)によってモード固有の関数や変数が暗黙裡に定義されたのかもしれないし、Lispプログラム実行時にdefunを呼び出して関数を定義したのかもしれない(関数の定義を参照)。このようなケースや類似したケースにおいては、そのシンボルのdefinition-nameプロパティはテキスト検索によって検索可能な定義をもち、そのコードによって元のシンボルを定義するような別のシンボルであることが必要になる。define-derived-modeの例では、定義される関数および変数にたいするこのプロパティの値がモードシンボルであることが必要になる。C-h f (Help in The GNU Emacs Manualを参照)のようなEmacsのヘルプコマンドでは、そのシンボルのドキュメントを表示する*Help*バッファーのボタンを通じてシンボルの定義を表示するためにこのプロパティが使用されている。
disabled: 値が非nilなら命名される関数はコマンドとして無効になる。コマンドの無効化を参照のこと。
face-documentation: 値には命名されるフェイスのドキュメント文字列が格納される。これはdeffaceにより自動的にセットされる。フェイスの定義を参照のこと。
history-length: 値が非nilなら、命名されるヒストリーリスト変数のミニバッファーヒストリーの最大長を指定する。ミニバッファーのヒストリーを参照のこと。
interactive-form: この値は命名される関数のインタラクティブ形式である。通常はこれを直接セットするべきではない。かわりにスペシャルフォームinteractiveを使用すること。インタラクティブな呼び出しを参照されたい。
menu-enable: この値は命名されるメニューアイテムが、メニュー内で有効であるべきか否かを決定するための式である。単純なメニューアイテムを参照のこと。
mode-class: 値がspecialなら命名されるメジャーモードはspecial(特別)である。メジャーモードの慣習を参照のこと。
permanent-local: 値が非nilなら命名される変数はバッファーローカル変数となり、メジャーモードの変更によって変数の値はリセットされない。バッファーローカルなバインディングの作成と削除を参照のこと。
permanent-local-hook: 値が非nilなら、命名される関数はメジャーモード変更時にフック変数のローカル値から削除されない。フックのセットを参照のこと。
pure ¶: 値が非nilの場合には、名づけられた関数は純粋(pure)だとみなされる。定数の引数で呼び出された場合には、コンパイル時に評価することができる。これは実行時のエラーをコンパイル時へとシフトする。純粋ストレージ(pure storage)と混同しないこと(純粋ストレージを参照)。
risky-local-variable: 値が非nilなら、命名される変数はファイルローカル変数としては危険だとみなされる。ファイルローカル変数を参照のこと。
safe-function: 値が非nilなら、命名される関数は評価において一般的に安全だとみなされます。安全に関数を呼び出せるかどうかの判断を参照のこと。
safe-local-eval-function: 値が非nilなら、命名される関数はファイルローカルの評価フォーム内で安全に呼び出すことができる。ファイルローカル変数を参照のこと。
safe-local-variable: この値は命名される変数にたいして、ファイルローカル値が安全かを判断する関数を指定する。ファイルローカル変数を参照のこと。この値はファイルのロード時に参照されるので、指定する関数は効率的かつ安全性判断のために理想的にはライブラリーを何もロードしない(autoload関数にしない)ようにする必要がある。
side-effect-free ¶: 非nil値は命名される関数が副作用(関数とは?を参照)をもたないことを示すので、バイトコンパイラーは値が使用されない呼び出しを無視する。このプロパティの値がerror-freeなら、バイトコンパイラーはそのような呼び出しの削除すら行うかもしれない。バイトコンパイラーの最適化に加えて、このプロパティは関数の安全性を判断するためにも使用される(安全に関数を呼び出せるかどうかの判断を参照)。
undo-inhibit-region: 非nilの場合には、命名される関数の直後にundoが呼び出されると、undo操作をアクティブなリージョンに限定することを抑止する。アンドゥを参照のこと。
variable-documentation: 非nilなら、それは命名される変数のドキュメント文字列を指定する。ドキュメント文字列はdefvarと関連する関数により自動的にセットされる。フェイスの定義を参照のこと。

9.5 ショートハンド

“名前変更シンボル(renamed symbols)”と呼ばれることもあるシンボルのショートハンド(shorthands: 速記、簡略表記)とは、Lispソースで目にする抽象形式です。これらは正規の抽象形式と類似していますが、Lispリーダーがそれらに遭遇した際に別の通常はもっと長いプリント名(print name)を生成する点が異なリます(シンボルの構成要素を参照)。

ショートハンドを意図するシンボルの完全名にたいする略語(abbreviating)と考えることは有益です。その点を除けばAbbrevシステム(abbrevとabbrev展開を参照)とショートハンドを混同しないでください。

ショートハンドによりEmacs Lispのネームスペース作法(namespacing etiquette)にしたがうことが容易になります。すべてのシンボルは単一のobarray (シンボルの作成とinternを参照)に格納されるので、一般的にプログラマーはシンボル名それぞれにたいして出自ライブラリー名をプレフィクスとして付加します。たとえば関数text-property-search-forwardとtext-property-search-backwardはどちらもtext-property-search.elライブラリーに属しています(ロードを参照)。シンボル名に正しくプレフィクスを付加することによって、異なるライブラリーに属する別のことを行う同一名シンボル間でのクラッシュを効果的に回避できます。しかしこれを実践してしばらくすると、一般的にはタイプしにくく読み難い、非常に長いシンボル名となります。これらの問題をショートハンドは明快な方法により解決します。

Variable: read-symbol-shorthands ¶

この変数の値は要素が(shorthand-prefix . longhand-prefix)という形式であるようなalist。それぞれの要素はLispリーダーにたいして、shorthand-prefixで始まるすべてのシンボルを、longhand-prefixで始まるシンボルとして読み取るよう指示する。

この変数はファイルローカル変数としてのみセットできる(Local Variables in Files in The GNU Emacs Manualを参照)。

以下は架空の文字列操作ライブラリーsome-nice-string-utils.elでショートハンドを使用する例です。

(defun some-nice-string-utils-split (separator s &optional omit-nulls)
  "match-dataを保存する`split-string'の変種"
  (save-match-data (split-string s separator omit-nulls)))

(defun some-nice-string-utils-lines (s)
  "文字列Sを改行文字で分割して文字列リストにする"
  (some-nice-string-utils-split "\\(\r\n\\|[\n\r]\\)" s))

見ての通りタイプするシンボル名が非常に長いので、このコードを読んだり開発するのはとても退屈です。これの緩和にショートハンドが使用できます。

(defun snu-split (separator s &optional omit-nulls)
  "match-dataを保存する`split-string'の変種"
  (save-match-data (split-string s separator omit-nulls)))

(defun snu-lines (s)
  "文字列Sを改行文字で分割して文字列リストにする"
  (snu-split "\\(\r\n\\|[\n\r]\\)" s))

;; Local Variables:
;; read-symbol-shorthands: (("snu-" . "some-nice-string-utils-"))
;; End:

この2つの例が異なるように見えても、これらをLispリーダーが処理した後はまったく同じです。どちらもインターン(シンボルの作成とinternを参照)される同一のシンボルへと導かれます。したがって2つのファイルのどちらをバイトコンパイルしても、同じ結果が得られます。2つ目のバージョンのショートハンドsnu-splitとsnu-linesはobarrayにインターンされません。これはショートハンド使用箇所にポイントを移動して、ポイント位置のシンボルの真のシンボル名のヒントをElDoc (Local Variables in Files in The GNU Emacs Manualを参照)がエコーエリアに表示するのを待つことで容易に確認できます。

read-symbol-shorthandsはファイルローカル変数なので、some-nice-string-utils-lines.elに依存する複数のライブラリーが同一のシンボルを異なるショートハンドで参照したり、あるいはショートハンドをまったく使用せずに参照することが可能になります。次の例ではmy-tricks.elライブラリーがsnu-ではなく、sns-というプレフィクスを使用してシンボルsome-nice-string-utils-linesを参照しています。

(defun t-reverse-lines (s) (string-join (reverse (sns-lines s)) "\n")

;; Local Variables:
;; read-symbol-shorthands: (("t-" . "my-tricks-")
;;                          ("sns-" . "some-nice-string-utils-"))
;; End:

9.5.1 例外

ショートハンド変換適用を管理するにあたって2つの例外があります:

Emacs Lispシンボル構成クラス(構文クラスのテーブルを参照)の文字だけでシンボルフォーム全体が形成される場合には変換されない。たとえば-や/=をショートハンドプレフィクスとして使用するのは可能だが、それらの名前は算術の関数をシャドーしない。
名前が‘#_’で始まるシンボルフォームは変換されない。

9.6 位置をもつシンボル

位置つきシンボル(symbol with position)とはbareシンボル(bare symbol: 裸のシンボル)と位置(position)と呼ばれる符号なし整数を合わせたシンボルのことです。これらのオブジェクトはバイトコンパイラーによって使用されます。バイトコンパイラーはシンボルそれぞれの出現位置を記録して、警告メッセージやエラーメッセージでそれらの位置を使用します。

位置つきシンボルのプリント表現には、プリント表現と読み取り構文で概説したハッシュ表記が使用されます。‘#<symbol foo at 12345>’のようなプリント表現であり、入力構文はありません。プリント操作の前後で変数print-symbols-bareを非nilにバインドすれば、bareシンボルだけをプリントさせることができます。バイトコンパイラーはコンパイル済みLispファイルへ書き込む前にこれを行っています。

フラグ変数symbols-with-pos-enabledが非nilであっても、ほとんどの用途にたいして位置つきシンボルはbareシンボルと同じように動作します。たとえばこの変数がセットされている場合には、‘(eq #<symbol foo at 12345> foo)’の値はtになります(ただしセットされていなければnil)。Emacsではほとんどの場合この変数はnilですが、バイトコンパイラーの実行時にはtにバインドされます。

位置つきシンボルは通常はバイトコンパイラーがリーダー関数read-positioning-symbolsを呼び出すことによって作成されます(入力関数を参照)が、関数position-symbolによって作成することもできます。

Variable: symbols-with-pos-enabled ¶: この変数が非nilの際には、位置つきシンボルはそれに内包されているbareシンボルと同様に振る舞う。この場合にはEmacsの実行が少しだけ遅くなる。

Variable: print-symbols-bare ¶: 非nilにバインドされていると、Lispプリンターは位置つきシンボルの位置は無視してbareシンボルだけをプリントする。

Function: symbol-with-pos-p symbol. ¶: この関数はsymbolがシンボルならt、それ以外はnilをリターンする。

Function: bare-symbol symbol ¶: この関数はsymbolに含まれるbareシンボル、symbolがすでにbareシンボルならsymbol自体をリターンする。それ以外のタイプのオブジェクトの場合にはエラーをシグナルする。

Function: symbol-with-pos-pos symbol ¶: この関数は位置つきシンボルの位置(数値)をリターンする。それ以外のタイプのオブジェクトの場合にはエラーをシグナルする。

Function: position-symbol sym pos ¶: 位置つきシンボルを新たに作成する。symはbareシンボルか位置つきシンボルで、これは新たなオブジェクトにたいしてシンボル部分を提供する。posは整数(新オブジェクトの数値部分となる)、あるいは位置つきシンボル(このシンボルの位置を使用)のいずれか。引数のいずれかが無効であればEmacsはエラーをシグナルする。

10 評価

Emacs Lispでの式の評価(evaluation)は、Lispインタープリター — 入力としてLispオブジェクトを受け取り、それの式としての値(value as an expression)を計算する — により処理されます。評価を行なう方法はそのオブジェクトのデータ型に依存していて、それはこのチャプターで説明するルールにより行なわれます。インタープリターはプログラムの一部を評価するために自動的に実行されますが、Lispプリミティブ関数のevalを通じて明示的に呼び出すこともできます。

10.1 評価の概要

Lispインタープリター(またはLispエバリュエーター)はEmacsの一部であり、与えられた式の値を計算します。Lispで記述された関数が呼び出されると、エバリュエーターはその関数のbody(本文)の中の式を評価してその関数の値を計算します。したがってLispプログラムを実行するとは、実際にはLispインタープリターを実行することを意味します。

評価を意図したLispオブジェクトはフォーム(form)、または式(expression)と呼ばれます⁷。フォームはデータオブジェクトであって単なるテキストではないという事実は、Lisp風の言語と通常のプログラミング言語との間にある基本的な相違点の1つです。任意のオブジェクトを評価できますが、実際に評価される事が非常に多いのは数字、シンボル、リスト、文字列です。

以降のセクションでは、各種フォームにたいしてそれを評価することが何を意味するかの詳細を説明します。

Lispフォームを読み取ってそのフォームを評価するのは、非常に一般的なアクティビティーですが、読み取りと評価は別のアクティビティーであって、どちらか一方を単独で処理することができます。読み取っただけでは何も評価されません。読み取りはLispオブジェクトのプリント表現をそのオブジェクト自体に変換します。そのオブジェクトが評価されるべきフォームなのか、それともまったく違う目的をもつかを指定するのは、readの呼び出し元の役目です。入力関数を参照してください。

評価とは再帰的な処理であり、�

2.4.6.1 ボックスダイアグラムによるリストの描写		リストの図解。
2.4.6.2 ドットペア表記		コンスセルの一般的な構文。
2.4.6.3 連想リスト型		特別に構築されるリスト。

7.1 レコード関数		レコード用の関数。
7.2 後方互換		cl-defstructにたいする後方互換について。

GNU Emacs Lisp Reference Manual

For Emacs Version 29.3

Emacs Lisp

1 イントロダクション

1.1 注意事項

1.2 Lispの歴史

1.3 Lispの歴史

1.3.1 Lispの歴史

1.3.2 nilとt

1.3.3 評価の表記

1.3.4 プリントの表記

1.3.5 エラーメッセージ

1.3.6 バッファーテキストの表記

1.3.7 説明のフォーマット

1.3.7.1 関数の説明例

1.3.7.2 変数の説明例

1.4 バージョンの情報

1.5 謝辞

2 Lispのデータ型

2.1 プリント表現と読み取り構文

2.2 特別な読み取り構文

2.3 コメント

2.4 プログラミングの型

2.4.1 整数型

2.4.2 浮動小数点数型

2.4.3 文字型

2.4.3.1 基本的な文字構文

2.4.3.2 一般的なエスケープ構文

2.4.3.3 コントロール文字構文

2.4.3.4 メタ文字構文

2.4.3.5 その他の文字修飾ビット

2.4.4 シンボル型

2.4.5 シーケンス型

2.4.6 コンスセルとリスト型

2.4.6.1 ボックスダイアグラムによるリストの描写

2.4.6.2 ドットペア表記

2.4.6.3 連想リスト型

2.4.7 配列型

2.4.8 文字列型

2.4.8.1 文字列の構文

2.4.8.2 文字列内の非ASCII文字

2.4.8.3 文字列内の非プリント文字

2.4.8.4 文字列内のテキストプロパティ

2.4.9 ベクター型

2.4.10 文字テーブル型

2.4.11 ブールベクター型

2.4.12 ハッシュテーブル型

2.4.13 関数型

2.4.14 マクロ型

2.4.15 プリミティブ関数型

2.4.16 バイトコード関数型

2.4.17 レコード型

2.4.18 型記述子

2.4.19 autoload型

2.4.20 ファイナライザー型

2.5 編集用の型

2.5.1 バッファー型

2.5.2 マーカー型

2.5.3 ウィンドウ型

2.5.4 フレーム型

2.5.5 端末型

2.5.6 ウィンドウ構成型

2.5.7 フレーム構成型

2.5.8 プロセス型

2.5.9 スレッド型

2.5.10 ミューテックス型

2.5.11 状態変数型

2.5.12 ストリーム型

2.5.13 キーマップ型

2.5.14 オーバーレイ型

2.5.15 フォント型

2.5.16 Xwidget型

2.6 循環オブジェクトの読み取り構文

2.7 型のための述語

2.8 同等性のための述語

2.9 可変性

3 数値

3.1 整数の基礎

3.2 浮動小数点数の基礎

3.3 数値のための述語

1.3.2 `nil`と`t`

5.6.1 `setcar`によるリスト要素の変更