• Copying: Conditions for copying and changing GNU Emacs.
• Introduction: Introduction and conventions used.
• Standards: Coding conventions for Emacs Lisp.

• Lisp Data Types: Data types of objects in Emacs Lisp.
• Numbers: Numbers and arithmetic functions.
• Strings and Characters: Strings, and functions that work on them.
• Lists: Lists, cons cells, and related functions.
• Sequences Arrays Vectors: Lists, strings and vectors are called sequences. Certain functions act on any kind of sequence. The description of vectors is here as well.
• Symbols: Symbols represent names, uniquely.

• Evaluation: How Lisp expressions are evaluated.
• Control Structures: Conditionals, loops, nonlocal exits.
• Variables: Using symbols in programs to stand for values.
• Functions: A function is a Lisp program that can be invoked from other functions.
• Macros: Macros are a way to extend the Lisp language.
• Customization: Writing customization declarations.

• Loading: Reading files of Lisp code into Lisp.
• Byte Compilation: Compilation makes programs run faster.
• Advising Functions: Adding to the definition of a function.
• Debugging: Tools and tips for debugging Lisp programs.

• Read and Print: Converting Lisp objects to text and back.
• Minibuffers: Using the minibuffer to read input.
• Command Loop: How the editor command loop works, and how you can call its subroutines.
• Keymaps: Defining the bindings from keys to commands.
• Modes: Defining major and minor modes.
• Documentation: Writing and using documentation strings.

• Files: Accessing files.
• Backups and Auto-Saving: Controlling how backups and auto-save files are made.
• Buffers: Creating and using buffer objects.
• Windows: Manipulating windows and displaying buffers.
• Frames: Making multiple X windows.
• Positions: Buffer positions and motion functions.
• Markers: Markers represent positions and update automatically when the text is changed.

• Text: Examining and changing text in buffers.
• Non-ASCII Characters: Non-ASCII text in buffers and strings.
• Searching and Matching: Searching buffers for strings or regexps.
• Syntax Tables: The syntax table controls word and list parsing.
• Abbrevs: How Abbrev mode works, and its data structures.

• Processes: Running and communicating with subprocesses.
• System Interface: Getting the user id, system type, environment variables, and other such things.
• Display: Parameters controlling screen usage. The bell. Waiting for input.
• Calendar: Customizing the calendar and diary.

  付録

• Tips: Advice and coding conventions for Emacs Lisp.
• GNU Emacs Internals: Building and dumping Emacs; internal data structures.
• Standard Errors: List of all error symbols.
• Standard Buffer-Local Variables: List of variables buffer-local in all buffers.
• Standard Keymaps: List of standard keymaps.
• Standard Hooks: List of standard hook variables.

• Index: Index including concepts, functions, variables, and other terms.

• New Symbols: New functions and variables in Emacs 20.

  −−− 詳細ノード一覧 −−−

  以下は、上にあげたノードの下位ノードです。 直接移動できるように掲載しておきます。

  導入

• Caveats: Flaws and a request for help.
• Lisp History: Emacs Lisp is descended from Maclisp.
• Conventions: How the manual is formatted.
• Acknowledgements: The authors, editors, and sponsors of this manual.

  慣習

• Some Terms: Explanation of terms we use in this manual.
• nil and t: How the symbols nil and t are used.
• Evaluation Notation: The format we use for examples of evaluation.
• Printing Notation: The format we use for examples that print output.
• Error Messages: The format we use for examples of errors.
• Buffer Text Notation: The format we use for buffer contents in examples.
• Format of Descriptions: Notation for describing functions, variables, etc.

  ヒントと慣習

• Coding Conventions: Conventions for clean and robust programs.
• Compilation Tips: Making compiled code run fast.
• Documentation Tips: Writing readable documentation strings.
• Comment Tips: Conventions for writing comments.
• Library Headers: Standard headers for library packages.

  記述形式

• A Sample Function Description:
• A Sample Variable Description:

  Lispデータ型

• Printed Representation: How Lisp objects are represented as text.
• Comments: Comments and their formatting conventions.
• Programming Types: Types found in all Lisp systems.
• Editing Types: Types specific to Emacs.
• Type Predicates: Tests related to types.
• Equality Predicates: Tests of equality between any two objects.

  プログラミング向けの型

• Integer Type: Numbers without fractional parts.
• Floating Point Type: Numbers with fractional parts and with a large range.
• Character Type: The representation of letters, numbers and control characters.
• Sequence Type: Both lists and arrays are classified as sequences.
• Cons Cell Type: Cons cells, and lists (which are made from cons cells).
• Array Type: Arrays include strings and vectors.
• String Type: An (efficient) array of characters.
• Vector Type: One-dimensional arrays.
• Symbol Type: A multi-use object that refers to a function, variable, property list, or itself.
• Function Type: A piece of executable code you can call from elsewhere.
• Macro Type: A method of expanding an expression into another expression, more fundamental but less pretty.
• Primitive Function Type: A function written in C, callable from Lisp.
• Byte-Code Type: A function written in Lisp, then compiled.
• Autoload Type: A type used for automatically loading seldom-used functions.

  リスト型

• Dotted Pair Notation: An alternative syntax for lists.
• Association List Type: A specially constructed list.

  編集向けの型

• Buffer Type: The basic object of editing.
• Window Type: What makes buffers visible.
• Window Configuration Type: Save what the screen looks like.
• Marker Type: A position in a buffer.
• Process Type: A process running on the underlying OS.
• Stream Type: Receive or send characters.
• Keymap Type: What function a keystroke invokes.
• Overlay Type: How an overlay is represented.

  数

• Integer Basics: Representation and range of integers.
• Float Basics: Representation and range of floating point.
• Predicates on Numbers: Testing for numbers.
• Comparison of Numbers: Equality and inequality predicates.
• Arithmetic Operations: How to add, subtract, multiply and divide.
• Bitwise Operations: Logical and, or, not, shifting.
• Numeric Conversions: Converting float to integer and vice versa.
• Math Functions: Trig, exponential and logarithmic functions.
• Random Numbers: Obtaining random integers, predictable or not.

  文字列と文字

• String Basics: Basic properties of strings and characters.
• Predicates for Strings: Testing whether an object is a string or char.
• Creating Strings: Functions to allocate new strings.
• Text Comparison: Comparing characters or strings.
• String Conversion: Converting characters or strings and vice versa.
• Formatting Strings: format: Emacs's analogue of printf.
• Case Conversion: Case conversion functions.

  リスト

• Cons Cells: How lists are made out of cons cells.
• Lists as Boxes: Graphical notation to explain lists.
• List-related Predicates: Is this object a list? Comparing two lists.
• List Elements: Extracting the pieces of a list.
• Building Lists: Creating list structure.
• Modifying Lists: Storing new pieces into an existing list.
• Sets And Lists: A list can represent a finite mathematical set.
• Association Lists: A list can represent a finite relation or mapping.

  既存リスト構造の変更

• Setcar: Replacing an element in a list.
• Setcdr: Replacing part of the list backbone. This can be used to remove or add elements.
• Rearrangement: Reordering the elements in a list; combining lists.

  シーケンス、配列、ベクトル

• Sequence Functions: Functions that accept any kind of sequence.
• Arrays: Characteristics of arrays in Emacs Lisp.
• Array Functions: Functions specifically for arrays.
• Vectors: Functions specifically for vectors.

  シンボル

• Symbol Components: Symbols have names, values, function definitions and property lists.
• Definitions: A definition says how a symbol will be used.
• Creating Symbols: How symbols are kept unique.
• Property Lists: Each symbol has a property list for recording miscellaneous information.

  評価

• Intro Eval: Evaluation in the scheme of things.
• Eval: How to invoke the Lisp interpreter explicitly.
• Forms: How various sorts of objects are evaluated.
• Quoting: Avoiding evaluation (to put constants in the program).

  フォームの種類

• Self-Evaluating Forms: Forms that evaluate to themselves.
• Symbol Forms: Symbols evaluate as variables.
• Classifying Lists: How to distinguish various sorts of list forms.
• Function Forms: Forms that call functions.
• Macro Forms: Forms that call macros.
• Special Forms: ``Special forms'' are idiosyncratic primitives, most of them extremely important.
• Autoloading: Functions set up to load files containing their real definitions.

  制御構造

• Sequencing: Evaluation in textual order.
• Conditionals: if, cond.
• Combining Conditions: and, or, not.
• Iteration: while loops.
• Nonlocal Exits: Jumping out of a sequence.

  非ローカル脱出

• Catch and Throw: Nonlocal exits for the program's own purposes.
• Examples of Catch: Showing how such nonlocal exits can be written.
• Errors: How errors are signaled and handled.
• Cleanups: Arranging to run a cleanup form if an error happens.

  エラー

• Signaling Errors: How to report an error.
• Processing of Errors: What Emacs does when you report an error.
• Handling Errors: How you can trap errors and continue execution.
• Error Symbols: How errors are classified for trapping them.

  変数

• Global Variables: Variable values that exist permanently, everywhere.
• Constant Variables: Certain "variables" have values that never change.
• Local Variables: Variable values that exist only temporarily.
• Void Variables: Symbols that lack values.
• Defining Variables: A definition says a symbol is used as a variable.
• Accessing Variables: Examining values of variables whose names are known only at run time.
• Setting Variables: Storing new values in variables.
• Variable Scoping: How Lisp chooses among local and global values.
• Buffer-Local Variables: Variable values in effect only in one buffer.

  スコープルールと変数束縛

• Scope: Scope means where in the program a value is visible. Comparison with other languages.
• Extent: Extent means how long in time a value exists.
• Impl of Scope: Two ways to implement dynamic scoping.
• Using Scoping: How to use dynamic scoping carefully and avoid problems.

  バッファローカルな変数

• Intro to Buffer-Local: Introduction and concepts.
• Creating Buffer-Local: Creating and destroying buffer-local bindings.
• Default Value: The default value is seen in buffers that don't have their own buffer-local values.

  関数

• What Is a Function: Lisp functions vs primitives; terminology.
• Lambda Expressions: How functions are expressed as Lisp objects.
• Function Names: A symbol can serve as the name of a function.
• Defining Functions: Lisp expressions for defining functions.
• Calling Functions: How to use an existing function.
• Mapping Functions: Applying a function to each element of a list, etc.
• Anonymous Functions: Lambda-expressions are functions with no names.
• Function Cells: Accessing or setting the function definition of a symbol.
• Related Topics: Cross-references to specific Lisp primitives that have a special bearing on how functions work.

  ラムダ式

• Lambda Components: The parts of a lambda expression.
• Simple Lambda: A simple example.
• Argument List: Details and special features of argument lists.
• Function Documentation: How to put documentation in a function.

  マクロ

• Simple Macro: A basic example.
• Expansion: How, when and why macros are expanded.
• Compiling Macros: How macros are expanded by the compiler.
• Defining Macros: How to write a macro definition.
• Backquote: Easier construction of list structure.
• Problems with Macros: Don't evaluate the macro arguments too many times. Don't hide the user's variables.

  ロード

• How Programs Do Loading: The load function and others.
• Autoload: Setting up a function to autoload.
• Named Features: Loading a library if it isn't already loaded.
• Repeated Loading: Precautions about loading a file twice.

  バイトコンパイル

• Compilation Functions: Byte compilation functions.
• Disassembly: Disassembling byte-code; how to read byte-code.

  関数のアドバイス

• Simple Advice: A simple example to explain the basics of advice.
• Defining Advice: Detailed description of defadvice.
• Computed Advice: ...is to defadvice as fset is to defun.
• Activation of Advice: Advice doesn't do anything until you activate it.
• Enabling Advice: You can enable or disable each piece of advice.
• Preactivation: Preactivation is a way of speeding up the loading of compiled advice.
• Argument Access in Advice: How advice can access the function's arguments.
• Subr Arguments: Accessing arguments when advising a primitive.
• Combined Definition: How advice is implemented.

  Lispプログラムのデバッグ

• Debugger: How the Emacs Lisp debugger is implemented.
• Syntax Errors: How to find syntax errors.
• Compilation Errors: How to find errors that show up in byte compilation.
• Edebug: A source-level Emacs Lisp debugger.

  Lispデバッガ

• Error Debugging: Entering the debugger when an error happens.
• Function Debugging: Entering it when a certain function is called.
• Explicit Debug: Entering it at a certain point in the program.
• Using Debugger: What the debugger does; what you see while in it.
• Debugger Commands: Commands used while in the debugger.
• Invoking the Debugger: How to call the function debug.
• Internals of Debugger: Subroutines of the debugger, and global variables.

  不正なLisp構文のデバッグ

• Excess Open: How to find a spurious open paren or missing close.
• Excess Close: How to find a spurious close paren or missing open.

  Lispオブジェクトの読み取りと表示

• Streams Intro: Overview of streams, reading and printing.
• Input Streams: Various data types that can be used as input streams.
• Input Functions: Functions to read Lisp objects from text.
• Output Streams: Various data types that can be used as output streams.
• Output Functions: Functions to print Lisp objects as text.

  ミニバッファ

• Intro to Minibuffers: Basic information about minibuffers.
• Text from Minibuffer: How to read a straight text string.
• Object from Minibuffer: How to read a Lisp object or expression.
• Completion: How to invoke and customize completion.
• Yes-or-No Queries: Asking a question with a simple answer.
• Minibuffer Misc: Various customization hooks and variables.

  補完

• Basic Completion: Low-level functions for completing strings. (These are too low level to use the minibuffer.)
• Minibuffer Completion: Invoking the minibuffer with completion.
• Completion Commands: Minibuffer commands that do completion.
• High-Level Completion: Convenient special cases of completion (reading buffer name, file name, etc.)
• Reading File Names: Using completion to read file names.
• Programmed Completion: Finding the completions for a given file name.

  コマンドループ

• Command Overview: How the command loop reads commands.
• Defining Commands: Specifying how a function should read arguments.
• Interactive Call: Calling a command, so that it will read arguments.
• Command Loop Info: Variables set by the command loop for you to examine.
• Input Events: What input looks like when you read it.
• Reading Input: How to read input events from the keyboard or mouse.
• Waiting: Waiting for user input or elapsed time.
• Quitting: How C-g works. How to catch or defer quitting.
• Prefix Command Arguments: How the commands to set prefix args work.
• Recursive Editing: Entering a recursive edit, and why you usually shouldn't.
• Disabling Commands: How the command loop handles disabled commands.
• Command History: How the command history is set up, and how accessed.
• Keyboard Macros: How keyboard macros are implemented.

  コマンドの定義

• Using Interactive: General rules for interactive.
• Interactive Codes: The standard letter-codes for reading arguments in various ways.
• Interactive Examples: Examples of how to read interactive arguments.

  キーマップ

• Keymap Terminology: Definitions of terms pertaining to keymaps.
• Format of Keymaps: What a keymap looks like as a Lisp object.
• Creating Keymaps: Functions to create and copy keymaps.
• Inheritance and Keymaps: How one keymap can inherit the bindings of another keymap.
• Prefix Keys: Defining a key with a keymap as its definition.
• Menu Keymaps: A keymap can define a menu for X windows or for use from the terminal.
• Active Keymaps: Each buffer has a local keymap to override the standard (global) bindings. Each minor mode can also override them.
• Key Lookup: How extracting elements from keymaps works.
• Functions for Key Lookup: How to request key lookup.
• Changing Key Bindings: Redefining a key in a keymap.
• Key Binding Commands: Interactive interfaces for redefining keys.
• Scanning Keymaps: Looking through all keymaps, for printing help.

  メジャーモードとマイナモード

• Major Modes: Defining major modes.
• Minor Modes: Defining minor modes.
• Mode Line Format: Customizing the text that appears in the mode line.
• Hooks: How to use hooks; how to write code that provides hooks.

  メジャーモード

• Major Mode Conventions: Coding conventions for keymaps, etc.
• Example Major Modes: Text mode and Lisp modes.
• Auto Major Mode: How Emacs chooses the major mode automatically.
• Mode Help: Finding out how to use a mode.

  マイナモード

• Minor Mode Conventions: Tips for writing a minor mode.
• Keymaps and Minor Modes: How a minor mode can have its own keymap.

  モード行の書式

• Mode Line Data: The data structure that controls the mode line.
• Mode Line Variables: Variables used in that data structure.
• %-Constructs: Putting information into a mode line.

  説明文

• Documentation Basics: Good style for doc strings. Where to put them. How Emacs stores them.
• Accessing Documentation: How Lisp programs can access doc strings.
• Keys in Documentation: Substituting current key bindings.
• Describing Characters: Making printable descriptions of non-printing characters and key sequences.
• Help Functions: Subroutines used by Emacs help facilities.

  ファイル

• Visiting Files: Reading files into Emacs buffers for editing.
• Saving Buffers: Writing changed buffers back into files.
• Reading from Files: Reading files into other buffers.
• Writing to Files: Writing new files from parts of buffers.
• File Locks: Locking and unlocking files, to prevent simultaneous editing by two people.
• Information about Files: Testing existence, accessibility, size of files.
• Contents of Directories: Getting a list of the files in a directory.
• Changing Files: Renaming files, changing protection, etc.
• File Names: Decomposing and expanding file names.

  ファイルを訪問する

• Visiting Functions: The usual interface functions for visiting.
• Subroutines of Visiting: Lower-level subroutines that they use.

  ファイルに関する情報

• Testing Accessibility: Is a given file readable? Writable?
• Kinds of Files: Is it a directory? A link?
• File Attributes: How large is it? Any other names? Etc.

  ファイル名

• File Name Components: The directory part of a file name, and the rest.
• Directory Names: A directory's name as a directory is different from its name as a file.
• Relative File Names: Some file names are relative to a current directory.
• File Name Expansion: Converting relative file names to absolute ones.
• Unique File Names: Generating names for temporary files.
• File Name Completion: Finding the completions for a given file name.

  バックアップと自動保存

• Backup Files: How backup files are made; how their names are chosen.
• Auto-Saving: How auto-save files are made; how their names are chosen.
• Reverting: revert-buffer, and how to customize what it does.

  バックアップファイル

• Making Backups: How Emacs makes backup files, and when.
• Rename or Copy: Two alternatives: renaming the old file or copying it.
• Numbered Backups: Keeping multiple backups for each source file.
• Backup Names: How backup file names are computed; customization.

  バッファ

• Buffer Basics: What is a buffer?
• Buffer Names: Accessing and changing buffer names.
• Buffer File Name: The buffer file name indicates which file is visited.
• Buffer Modification: A buffer is modified if it needs to be saved.
• Modification Time: Determining whether the visited file was changed ``behind Emacs's back''.
• Read Only Buffers: Modifying text is not allowed in a read-only buffer.
• The Buffer List: How to look at all the existing buffers.
• Creating Buffers: Functions that create buffers.
• Killing Buffers: Buffers exist until explicitly killed.
• Current Buffer: Designating a buffer as current so primitives will access its contents.

  ウィンドウ

• Basic Windows: Basic information on using windows.
• Splitting Windows: Splitting one window into two windows.
• Deleting Windows: Deleting a window gives its space to other windows.
• Selecting Windows: The selected window is the one that you edit in.
• Cyclic Window Ordering: Moving around the existing windows.
• Buffers and Windows: Each window displays the contents of a buffer.
• Displaying Buffers: Higher-lever functions for displaying a buffer and choosing a window for it.
• Window Point: Each window has its own location of point.
• Window Start: The display-start position controls which text is on-screen in the window.
• Vertical Scrolling: Moving text up and down in the window.
• Horizontal Scrolling: Moving text sideways on the window.
• Size of Window: Accessing the size of a window.
• Resizing Windows: Changing the size of a window.
• Window Configurations: Saving and restoring the state of the screen.

  フレーム

• Creating Frames: Creating additional frames.
• Multiple Displays: Creating frames on other X displays.
• Frame Parameters: Controlling frame size, position, font, etc.
• Frame Titles: Automatic updating of frame titles.
• Deleting Frames: Frames last until explicitly deleted.
• Finding All Frames: How to examine all existing frames.
• Frames and Windows: A frame contains windows; display of text always works through windows.
• Minibuffers and Frames: How a frame finds the minibuffer to use.
• Input Focus: Specifying the selected frame.
• Visibility of Frames: Frames may be visible or invisible, or icons.
• Raising and Lowering: Raising a frame makes it hide other X windows; lowering it puts it underneath the others.
• Frame Configurations: Saving the state of all frames.
• Mouse Tracking: Getting events that say when the mouse moves.
• Mouse Position: Asking where the mouse is, or moving it.
• Pop-Up Menus: Displaying a menu for the user to select from.
• Dialog Boxes: Displaying a box to ask yes or no.
• Pointer Shapes: Specifying the shape of the mouse pointer.
• Window System Selections: Transferring text to and from other windows.
• Color Names: Getting the definitions of color names.
• Resources: Getting resource values from the server.
• Server Data: Getting info about the X server.

  バッファ内の位置

• Point: The special position where editing takes place.
• Motion: Changing point.
• Excursions: Temporary motion and buffer changes.
• Narrowing: Restricting editing to a portion of the buffer.

  移動

• Character Motion: Moving in terms of characters.
• Word Motion: Moving in terms of words.
• Buffer End Motion: Moving to the beginning or end of the buffer.
• Text Lines: Moving in terms of lines of text.
• Screen Lines: Moving in terms of lines as displayed.
• List Motion: Moving by parsing lists and sexps.
• Skipping Characters: Skipping characters belonging to a certain set.

  マーカ

• Overview of Markers: The components of a marker, and how it relocates.
• Predicates on Markers: Testing whether an object is a marker.
• Creating Markers: Making empty markers or markers at certain places.
• Information from Markers: Finding the marker's buffer or character position.
• Moving Markers: Moving the marker to a new buffer or position.
• The Mark: How ``the mark'' is implemented with a marker.
• The Region: How to access ``the region''.

  テキスト

• Near Point: Examining text in the vicinity of point.
• Buffer Contents: Examining text in a general fashion.
• Insertion: Adding new text to a buffer.
• Commands for Insertion: User-level commands to insert text.
• Deletion: Removing text from a buffer.
• User-Level Deletion: User-level commands to delete text.
• The Kill Ring: Where removed text sometimes is saved for later use.
• Undo: Undoing changes to the text of a buffer.
• Auto Filling: How auto-fill mode is implemented to break lines.
• Filling: Functions for explicit filling.
• Margins: How to specify margins for filling commands.
• Sorting: Functions for sorting parts of the buffer.
• Indentation: Functions to insert or adjust indentation.
• Columns: Computing horizontal positions, and using them.
• Case Changes: Case conversion of parts of the buffer.
• Text Properties: Assigning Lisp property lists to text characters.
• Substitution: Replacing a given character wherever it appears.
• Transposition: Swapping two portions of a buffer.
• Registers: How registers are implemented. Accessing the text or position stored in a register.
• Change Hooks: Supplying functions to be run when text is changed.

  キルリング

• Kill Ring Concepts: What text looks like in the kill ring.
• Kill Functions: Functions that kill text.
• Yank Commands: Commands that access the kill ring.
• Low-Level Kill Ring: Functions and variables for kill ring access.
• Internals of Kill Ring: Variables that hold kill-ring data.

  字下げ

• Primitive Indent: Functions used to count and insert indentation.
• Mode-Specific Indent: Customize indentation for different modes.
• Region Indent: Indent all the lines in a region.
• Relative Indent: Indent the current line based on previous lines.
• Indent Tabs: Adjustable, typewriter-like tab stops.
• Motion by Indent: Move to first non-blank character.

  テキスト属性

• Examining Properties: Looking at the properties of one character.
• Changing Properties: Setting the properties of a range of text.
• Property Search: Searching for where a property changes value.
• Special Properties: Particular properties with special meanings.
• Format Properties: Properties for representing formatting of text.
• Sticky Properties: How inserted text gets properties from neighboring text.
• Saving Properties: Saving text properties in files, and reading them back.
• Lazy Properties: Computing text properties in a lazy fashion only when text is examined.
• Not Intervals: Why text properties do not use Lisp-visible text intervals.

  探索と一致

• String Search: Search for an exact match.
• Regular Expressions: Describing classes of strings.
• Regexp Search: Searching for a match for a regexp.
• Match Data: Finding out which part of the text matched various parts of a regexp, after regexp search.
• Saving Match Data: Saving and restoring this information.
• Standard Regexps: Useful regexps for finding sentences, pages,...
• Searching and Case: Case-independent or case-significant searching.

  正規表現

• Syntax of Regexps: Rules for writing regular expressions.
• Regexp Example: Illustrates regular expression syntax.

  構文テーブル

• Syntax Descriptors: How characters are classified.
• Syntax Table Functions: How to create, examine and alter syntax tables.
• Parsing Expressions: Parsing balanced expressions using the syntax table.
• Standard Syntax Tables: Syntax tables used by various major modes.
• Syntax Table Internals: How syntax table information is stored.

  構文記述子

• Syntax Class Table: Table of syntax classes.
• Syntax Flags: Additional flags each character can have.

  略語と略語の展開

• Abbrev Mode: Setting up Emacs for abbreviation.
• Tables: Creating and working with abbrev tables.
• Defining Abbrevs: Specifying abbreviations and their expansions.
• Files: Saving abbrevs in files.
• Expansion: Controlling expansion; expansion subroutines.
• Standard Abbrev Tables: Abbrev tables used by various major modes.

  プロセス

• Subprocess Creation: Functions that start subprocesses.
• Synchronous Processes: Details of using synchronous subprocesses.
• Asynchronous Processes: Starting up an asynchronous subprocess.
• Deleting Processes: Eliminating an asynchronous subprocess.
• Process Information: Accessing run-status and other attributes.
• Input to Processes: Sending input to an asynchronous subprocess.
• Signals to Processes: Stopping, continuing or interrupting an asynchronous subprocess.
• Output from Processes: Collecting output from an asynchronous subprocess.
• Sentinels: Sentinels run when process run-status changes.
• Network: Opening network connections.

  プロセスからの出力を受け取る

• Process Buffers: If no filter, output is put in a buffer.
• Filter Functions: Filter functions accept output from the process.
• Accepting Output: How to wait until process output arrives.

  オペレーティングシステムとのインターフェイス

• Starting Up: Customizing Emacs start-up processing.
• Getting Out: How exiting works (permanent or temporary).
• System Environment: Distinguish the name and kind of system.
• Terminal Input: Recording terminal input for debugging.
• Terminal Output: Recording terminal output for debugging.
• Flow Control: How to turn output flow control on or off.
• Batch Mode: Running Emacs without terminal interaction.

  Emacsの始動

• Start-up Summary: Sequence of actions Emacs performs at start-up.
• Init File: Details on reading the init file (.emacs).
• Terminal-Specific: How the terminal-specific Lisp file is read.
• Command Line Arguments: How command line arguments are processed, and how you can customize them.

  Emacsから抜ける

• Killing Emacs: Exiting Emacs irreversibly.
• Suspending Emacs: Exiting Emacs reversibly.

  Emacsの画面表示

• Refresh Screen: Clearing the screen and redrawing everything on it.
• Truncation: Folding or wrapping long text lines.
• The Echo Area: Where messages are displayed.
• Selective Display: Hiding part of the buffer text.
• Overlay Arrow: Display of an arrow to indicate position.
• Temporary Displays: Displays that go away automatically.
• Waiting: Forcing display update and waiting for user.
• Blinking: How Emacs shows the matching open parenthesis.
• Usual Display: How control characters are displayed.
• Beeping: Audible signal to the user.
• Window Systems: Which window system is being used.

  GNU Emacsの内部

• Building Emacs: How to preload Lisp libraries into Emacs.
• Pure Storage: A kludge to make preloaded Lisp functions sharable.
• Garbage Collection: Reclaiming space for Lisp objects no longer used.
• Object Internals: Data formats of buffers, windows, processes.
• Writing Emacs Primitives: Writing C code for Emacs.

  オブジェクトの内部

• Buffer Internals: Components of a buffer structure.
• Window Internals: Components of a window structure.
• Process Internals: Components of a process structure.

GNU一般公有使用許諾書

1991年6月 バージョン2.0

Copyright © 1989, 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA 1

何人も、以下の内容を変更しないでそのまま複写する場合に限り、
本使用許諾書を複製したり頒布することができます。

はじめに

ほとんどのソフトウェアの使用許諾は、ソフトウェアを共有し、 変更するユーザの自由を奪うことを意図しています。 それに対して、我々のGNU一般公有使用許諾は、 フリー・ソフトウェアを共有したり変更する自由をユーザに保証するためのもの、 即ちフリー・ソフトウェアがそのユーザ全てにとって フリーであることを保証するためのものです。 本使用許諾は、Free Software Foundationのほとんど全てのソフトウェアに 適用されるだけでなく、 プログラムの作成者が本使用許諾に依るとした場合のそのプログラムにも 適用することができます。 （その他の Free Software Foundation のソフトウェアのいくつかは、 本許諾書ではなく、GNUライブラリ一般公有使用許諾で保護されます。） あなたは自分のプログラムにもこれを適用できます。

我々がフリー・ソフトウェアについて言う場合は 自由のことに言及しているのであって、価格のことではありません。 我々の一般公有使用許諾の各条項は、次の事柄を確実に実現することを 目的として立案されています。

• フリー・ソフトウェアの複製物を自由に頒布できること （そして、望むならあなたのこのサービスに対して対価を請求できること）。
• ソース・コードを実際に受け取るか、あるいは、 希望しさえすればそれを入手することが可能であること。
• 入手したソフトウェアを変更したり、 新しいフリー・プログラムの一部として使用できること。
• 以上の各内容を行なうことができるということをユーザ自身が知っていること。

このようなユーザの権利を守るために、我々は、 何人もこれらの権利を否定したり、あるいは放棄するように ユーザに求めることはできないという制限条項を設ける必要があります。 これらの制限条項は、ユーザが、フリー・ソフトウェアの複製物を 頒布したり変更しようとする場合には、そのユーザ自身が守るべき義務ともなります。

例えば、あなたがフリー・ソフトウェアの複製物を頒布する場合、 有償か無償かにかかわらず、 あなたは自分の持っている権利を全て相手に与えなければなりません。 あなたは、相手もまたソース・コードを受け取ったり入手できるということを 認めなければなりません。 さらにあなたは、彼らが自分たちの権利を知るように、 これらの条項を知らしめなければなりません。

　我々は次の２つの方法でユーザの権利を守ります。 （１）ソフトウェアに著作権を主張し、 （２）本使用許諾の条項の下で ソフトウェアを複製・頒布・変更する権利をユーザに与えます。

また、各作成者や我々自身を守るために、 本フリー・ソフトウェアが無保証であることを 全ての人々が了解している必要があります。 さらに、他の誰かによって変更されたソフトウェアが頒布された場合、 受領者はそのソフトウェアがオリジナル・バージョンではないということを 知らされる必要があります。 それは、他人の関与によって原開発者に対する評価が 影響されないようにするためです。

最後に、どのフリー・プログラムもソフトウェア特許に絶えず脅かされています。 我々は、フリー・プログラムの再頒布者が個人的に特許権を取得し、 事実上そのプログラムを自分の財産にしてしまうという危険を 避けたいと願っています。 これを防ぐために我々は、いずれの特許も、 誰でも自由に使用できるように使用許諾されるべきか、 あるいは何人に対しても全く使用させないかの、 いずれかにすべきであることを明らかにしてきました。

複写・頒布・変更に対する正確な条項と条件を次に示します。

1. 本使用許諾は、本一般公有使用許諾の各条項に従って頒布されるという 著作権者からの告知文が表示されているプログラムやその他の作成物に適用されます。 以下において「プログラム」とは、そのようなプログラムや作成物を指すものとし、 また、「プログラム生成物」とは、上述した「プログラム」自身、または、 著作権法下における全ての派生物；すなわち、その「プログラム」の全部又は一部を、 そのまま又は変更して、且つ／又は他の言語に変換して、 内部に組み込んだ作成物を意味します。 （以下、言語変換は「変更」という用語の中に無条件に含まれるものとします。） 本使用許諾によって許諾を受ける者を「あなた」と呼びます。　

   複製、頒布、変更以外の行為は本使用許諾の対象としません。 それらは本使用許諾の範囲外です。 「プログラム」を実行させる行為に関して制約はありません。 「プログラム」の出力は、 （「プログラム」を実行させて作成させたかどうかとは無関係に） その内容が「プログラム生成物」である場合に限り本使用許諾の対象となります。 これが当てはまるかどうかは、「プログラム」が何をするものかに依ります。

2. あなたは、どのような媒体上へ複製しようとする場合であっても、 入手した「プログラム」のソース・コードを そのままの内容で複写した上で適正な著作権表示と保証の放棄を明確、 且つ適正に付記する場合に限り、複製又は頒布することができます。 その場合、本使用許諾及び無保証に関する記載部分は、 全て元のままの形で表示してください。 また、「プログラム」の頒布先に対しては、 「プログラム」と共に本使用許諾書の写しを渡してください。

   複製物の引き渡しに要する実費は請求することができます。 また、あなた独自の保証を行なう場合はそれを有償とすることができます。

3. 次の各条件を全て満たしている限り、あなたは、 「プログラム」又はその一部分を変更して「プログラム生成物」とすることができ、 さらに、変更版や右作成物を上記第２項に従って複製又は頒布することもできます。
   1. ファイルを変更した旨とその変更日とを、変更したファイル上に明確に表示すること。
   2. 変更したか否かを問わず、凡そ「プログラム」 又はその一部分を内部に組み込んでいるか 又はそれから派生した生成物を頒布する場合には、 その全体を本使用許諾の条項に従って第三者へ無償で使用許諾すること。
   3. 変更したプログラムが実行時に通常の対話的な方法で コマンドを読むようになっているとすれば、 最も普通の方法で対話的にそのプログラムを実行する時に、 次の内容を示す文言がプリンタへ印字されるか、或いは画面に表示されること。
      • 適切な著作権表示。
      • 無保証であること（あなたが独自に保証する場合は、その旨）。
      • 頒布を受ける者も、 本使用許諾と同一の条項に従って「プログラム」を再頒布できること。
      • 頒布を受ける者が本使用許諾書の写しを参照する方法。 （例外として、「プログラム」自体は対話的であっても起動時の文言を 通常は印字しないのならば、 あなたの「プログラム生成物」はこのような文言を印字する必要はありません。）

   これらの要件は変更された作成物にも全て適用されます。 その変更版の或る部分が「プログラム」の派生物ではなく、 しかもそれ自体独立で異なる作成物だと合理的に考えられる場合、 あなたがそれらを別の作成物として頒布した時は、 本使用許諾とその条項はそれらの部分には適用されません。 しかし、それらを「プログラム生成物」の一部として頒布する場合は、 全体が本使用許諾の条項に従って頒布されなければならず、 使用許諾を受ける他の全ての者に対する許諾も プログラム全体にわたって与えられなければならず、 結果として、誰が書いたかにかかわらず、 全ての部分に本使用許諾が適用されなければなりません。

   このように、本条項の意図するところは、 完全にあなたによって書かれた作成物について、権利を要求したり、 あなたと権利関係を争うことではありません。 むしろその目的は、作成物が「プログラム生成物」 である場合にその派生物や集合物の頒布を規制することにあります。

   さらに、「プログラム」（又は「プログラム生成物」）と 「プログラム生成物」とはならない他のプログラムとを、 単に保管や頒布のために同一の媒体上にまとめて記録したとしても、 本使用許諾は他のプログラムには適用されません。

4. あなたは、以下のうちいずれか１つを満たす限り、 上記第２項及び第３項に従って「プログラム」 （又は、上記第３項で言及している「プログラム生成物」）を オブジェクト・コード又は実行可能な形式で複製及び頒布することができます。
   1. 対応する機械読み取り可能なソース・コード一式を一緒に引き渡すこと。 その場合、そのソース・コードの引き渡しは上記第２項及び第３項に従って、 通常ソフトウェアの交換に用いられる媒体で行なわれること。
   2. 少なくとも３年間の有効期間を定め、 且つその期間内であれば対応する機械読み取り可能なソース・コード一式の複製を、 ソース頒布に関わる実費以上の対価を要求せずに提供する旨、 及びその場合には上記第２項及び第３項に従って、 通常ソフトウェアの交換に用いられる媒体で提供される旨を記載した書面を、 第三者に一緒に引き渡すこと。
   3. 対応するソース・コード頒布の申し出に際して、 あなたが得た情報を一緒に引き渡すこと。 （この選択肢は、営利を目的としない頒布であって、 且つあなたが上記の（ｂ）項に基づいて、 オブジェクト・コード或いは実行可能形式の プログラムしか入手していない場合に限り適用される選択項目です。）

   なお、ソース・コードとは、変更作業に適した記述形式を指します。 また、実行可能形式のファイルに対応するソース・コード一式とは、 それに含まれる全モジュールに対応する全てのソース・コード、 及びあらゆる関連のインタフェース定義ファイル、 及び実行を可能にするコンパイルとインストールの制御に関する記述を指します。 特別な例外として、実行可能なファイルが動作するオペレーティング・システムの 主要な構成要素（コンパイラ、カーネルなど）と共に （ソース・コード又はバイナリのどちらかで）頒布されているものについては、 その構成要素自体が実行形式に付随していない場合に限り、 頒布されるソース・コードに含める必要はありません。

   実行可能形式またはオブジェクト・コードの頒布が、 指示された場所からの複製のためのアクセス権の賦与である場合、 同じ場所からのソース・コードの複製のための同等なアクセス権を賦与すれば、 たとえ第三者にオブジェクト・コードと共にソースの複製を強いなくとも、 ソース・コードを頒布したものとみなします。

5. 本使用許諾が明示的に許諾している場合を除き、あなたは、 「プログラム」を複製、変更、サブライセンス、頒布することができません。 本使用許諾に従わずに「プログラム」を複製、変更、サブライセンス、 頒布しようとする行為は、それ自体が無効であり、且つ、 本使用許諾があなたに許諾している「プログラム」の権利を自動的に消滅させます。 その場合、本使用許諾に従ってあなたから複製物やその権利を得ている第三者は、 本使用許諾に完全に従っている場合に限り、 引続き有効な使用権限を持つものとします。
6. あなたはまだ同意の印として署名していないので、 本使用許諾を受け入れる必要はありません。 しかし、あなたに「プログラム」又はその派生物を変更又は再頒布する許可を 与えるものは本使用許諾以外にはありません。 これらの行為は、あなたがもし本使用許諾を受け入れないのであれば、 法律によって禁じられます。 従って、あなたが「プログラム」（又は「プログラム生成物」）の変更又は頒布を 行えば、それ自体であなたは本使用許諾を受け入れ、且つ、 「プログラム」又はその「プログラム生成物」の複製、頒布、変更に 関するこれらの条項と条件の全てを受け入れたことを示します。
7. あなたが「プログラム」（又はその「プログラム生成物」）を再頒布すると自動的に、 その受領者は、元の使用許諾者から、本使用許諾の条項に従って「プログラム」を 複製、頒布、変更することを内容とする使用許諾を受けたものとします。 あなたは、受領者に許諾された権利の行使について、 さらに制約を加えることはできません。 あなたには、第三者に本使用許諾の受け入れを強いる責任はありません。
8. 裁判所の判決、又は特許侵害の申し立て、又は（特許問題に限らない） 何らかの理由の結果として、あなたに課せられた条件が本使用許諾と 相入れないものであったとしても（裁判所の命令、契約、その他によるものであれ）、 本使用許諾の条件が免除されるものではありません。 本使用許諾による責務と、その他の何らかの関連責務を同時に満たす態様で 頒布することができないならば、 あなたは「プログラム」を全く頒布してはいけません。 例えば、特許権の内容が、あなたから直接又は間接に複製を受け取った全ての人に 使用料のないプログラムの再頒布を許さないものであれば、 あなたがかかる特許上の要請と本使用許諾の両方を満足させる方法は、 「プログラム」の頒布を完全に断念することだけです。

   本条項の或る部分が何らかの特別な状況下で無効または適用不可能になった場合、 本条項のその他の残りの部分が適用されるように意図されており、また、 本条項は全体としてその他の状況に当てはまるように意図されています。

   本条項の目的は、特許やその他の財産権を侵害したり、 そのような権利に基づく主張の妥当性を争うようにあなたに 勧めることではありません。 本条項の唯一の目的は、フリー・ソフトウェアの頒布システムの完全性を守ることで、 それは公有使用許諾の実践によって履行されます。 多くの人々が、このシステムの一貫した適用を信頼して、 このシステムを通じて頒布されている幅広い範囲のソフトウェアに惜しみない貢献を してくれました。 作成者や寄贈者が他の何らかのシステムを通じてソフトウェアを 頒布したいと決めることは彼らの自由意志であり、 使用許諾を受ける者はその選択を強いることはできません。

   本条項は、本使用許諾の他の条項の意味内容が何であるかを 完全に明らかにすることを意図しています。

9. 「プログラム」の頒布・使用が、ある国において特許又は著作権で 保護されたインタフェースのどちらかで制限される場合、 「プログラム」を本使用許諾下においた原著作権保持者は、 その国を除外する旨の明示的な頒布地域制限を加え、 それ以外の（除外されない）国に限定して頒布が 許されるようにすることができます。 そのような場合、その制限を本使用許諾の本文に あたかも書かれているかのように本使用許諾の中に組み入れられるものとします。
10. Free Software Foundation は随時、本一般公有使用許諾の改訂版、 又は新版を公表することがあります。 そのような新しいバージョンは、 現行のバージョンと基本的に変わるところはありませんが、 新しい問題や懸案事項に対応するために細部では異なるかもしれません。

    各バージョンは、バージョン番号によって区別します。 「プログラム」中に本使用許諾のバージョン番号の指定がある場合は、 その指定されたバージョンか、又はその後にFree Software Foundationから 公表されているいずれかのバージョンから１つを選択して、 その条項と条件に従ってください。 「プログラム」中に本使用許諾のバージョン番号の指定がない場合は、 Free Software Foundation が公表したどのバージョンでも選択することができます。

11. 「プログラム」の一部を頒布条件の異なる他のフリー・プログラムに 組み込みたい場合は、その開発者に書面で許可を求めてください。 Free Software Foundation が著作権を持っているソフトウェアについては、 Free Software Foundation へ書面を提出してください。 このような場合に対応するために我々は例外的処理をすることもありますが、 その判断基準となるのは、次の２つの目標の実現に合致するか否かという点です。 即ち、１つは我々のフリー・ソフトウェアの全ての派生物を フリーな状態に保つことであり、もう１つはソフトウェアの共有と再利用とを 広く促進させることです。
12. 「プログラム」は無償で使用許諾されますので、適用法令の範囲内で、 「プログラム」の保証は一切ありません。 著作権者やその他の第三者は全く無保証で「そのまま」の状態で、且つ、 明示か暗黙であるかを問わず一切の保証をつけないで提供するものとします。 ここでいう保証とは、市場性や特定目的適合性についての暗黙の保証も含まれますが、 それに限定されるものではありません。 「プログラム」の品質や性能に関する全てのリスクはあなたが負うものとします。 「プログラム」に欠陥があるとわかった場合、 それに伴う一切の派生費用や修理・訂正に要する費用は全てあなたの負担とします。
13. 適用法令の定め、又は書面による合意がある場合を除き、 著作権者や上記許諾を受けて「プログラム」の変更・再頒布を為し得る第三者は、 「プログラム」を使用したこと、 または使用できないことに起因する一切の損害について何らの責任も負いません。 著作権者や前記の第三者が、そのような損害の発生する可能性について 知らされていた場合でも同様です。 なお、ここでいう損害には通常損害、特別損害、偶発損害、間接損害が含まれます （データの消失、又はその正確さの喪失、あなたや第三者が被った損失、 他のプログラムとのインタフェースの不適合化、等も含まれますが、 これに限定されるものではありません）。

注意

英文文書（GNU General Public License）を正式文書とする。 この和文文書は弁護士の意見を採り入れて、 できるだけ正確に英文文書を翻訳したものであるが、 法律的に有効な契約書ではない。

和文文書自体の再配布に関して

いかなる媒体でも次の条件がすべて満たされている場合に限り、 本和文文書をそのまま複写し配布することを許可する。 また、あなたは第三者に対して本許可告知と同一の許可を与える場合に限り、 再配布することが許可されています。

• 受領、配布されたコピーに著作権表示および本許諾告知が 前もって載せられていること。　
• コピーの受領者がさらに再配布する場合、 その配布者が本告知と同じ許可を与えていること。
• 和文文書の本文を改変しないこと。

あなたの新しいプログラムにこれらの条項を適用する方法

あなたが新しくプログラムを作成し、それを公用に供したい場合は、 プログラムをフリー・ソフトウェアにして、 全ての人々が以上の各条項に従ってこれを再頒布や変更をすることが できるようにするのが最良の方法です。

そうするためには、プログラムに以下の表示をしてください。 その場合、無保証であるということを最も効果的に伝えるために、 ソース・ファイルの冒頭にその全文を表示すれば最も安全ですが、 その他の方法で表示する場合でも、「著作権表示」と全文を読み出す為の アドレスへのポインタだけはファイル上に表示しておいてください。

プログラム名とどんな動作をするものかについての簡単な説明の行
Ｃｏｐｙｒｉｇｈｔ（Ｃ）　１９○○年、著作権者名

本プログラムはフリー・ソフトウェアです。
あなたは、Free Software Foundationが公表したGNU 一般公有使用許諾の
「バージョン２」或いはそれ以降の各バージョンの中からいずれかを選択し、
そのバージョンが定める条項に従って本プログラムを
再頒布または変更することができます。

本プログラムは有用とは思いますが、頒布にあたっては、
市場性及び特定目的適合性についての暗黙の保証を含めて、
いかなる保証も行ないません。
詳細についてはGNU 一般公有使用許諾書をお読みください。

あなたは、本プログラムと一緒にGNU一般公有使用許諾の写しを
受け取っているはずです。
そうでない場合は、

　Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA
2
へ手紙を書いてください。

また、ユーザが電子メイルや書信であなたと連絡をとる方法についての情報も 書き添えてください。

プログラムが対話的に動作する場合は、 対話モードで起動した時に次のような短い告知文が表示されるようにしてください。

Ｇｎｏｍｏｖｉｓｉｏｎ　バージョン６９、Ｃｏｐｙｒｉｇｈｔ（Ｃ）１９○○年 著作権者名
Gnomovision は完全に無保証です。詳細は show w とタイプしてください。
これはフリー・ソフトウェアなので、特定の条件の下でこれを再頒布する
ことができます。詳細は show c とタイプしてください。

上記のshow wやshow cは各々、 本一般公有使用許諾の関連する部分を表示するコマンドを指します。 もちろん、あなたが使うこれらのコマンドはshow wやshow cといった 呼び名でなくても構いません。 さらに、それらのコマンドはあなたのプログラムに合わせる為に、 マウスでクリックしたりメニュー形式にすることもできます。

また、必要と認めた場合には、あなたの雇い主 （あなたがプログラマとして働いている場合）や在籍する学校から、 そのプログラムに対する「著作権放棄」を認めた署名入りの書面を入手してください。 ここにその文例を載せます。名前は変えてください。

Yoyodyne, Inc. は、James Hacker が開発したプログラム`Gnomovision'
（コンパイラにつなげるプログラム）についての著作権法上の全ての権利を放棄する。

Ｔｙ　Ｃｏｏｎ　の署名，　１　Ａｐｒｉｌ　１９８９
Ｔｙ　Ｃｏｏｎ，　副社長

本一般公有使用許諾は、あなたのプログラムを財産権の対象となっている 他のプログラムに組み込むことは認めていません。 あなたのプログラムがサブルーチン・ライブラリであって、 あなたがそのライブラリを財産権の対象となっている他のアプリケーションと リンクさせることによって、さらに有用なものにしようとする場合には、 本使用許諾書の代わりに、GNUライブラリ一般公有使用許諾書に従ってください。

はじめに

GNU Emacsテキストエディタの大部分は、 Emacs Lispと呼ばれるプログラム言語で記述してあります。 Emacs Lispで新たなコードを書いて、 それをエディタの拡張としてインストールできます。 しかし、Emacs Lispは、単なる『拡張言語』ではありません。 それ自身、れっきとしたプログラム言語です。 他のプログラム言語でできることは、Emacs Lispでできます。

Emacs Lispは、エディタで使うために設計してあるため、 ファイル、バッファ、ディスプレイ、サブプロセスなどを扱う機能に加えて、 テキストを走査し解析する特別な機能もあります。 Emacs Lispは編集機構に密に組み込まれています。 このため、編集コマンドはLispプログラムからも呼び出せる関数ですし、 カスタマイズのためのパラメータは普通のLisp変数です。

本書は、Emacs Lispを完全に記述することを目指しています。 初心者向けの入門には、Free Software Foundation刊、 Bob ChassellのAn Introduction to Emacs Lisp Programming ³ をご覧ください。 本書では、Emacsの操作を熟知しているものと仮定します。 操作に関する基本的な情報は、The GNU Emacs Manual ⁴ を参照してください。

おおまかにいえば、始めのほうの章では、 多くのプログラム言語に見られる機能に相当するEmacs Lispの機能を説明し、 あとのほうの章では、 Emacs Lispに特有の機能や編集に特化した機能を説明します。

本書は、2.5版です。

• Caveats: Flaws and a request for help.
• Lisp History: Emacs Lisp is descended from Maclisp.
• Conventions: How the manual is formatted.
• Version Info: Which Emacs version is running?
• Acknowledgements: The authors, editors, and sponsors of this manual.

警告

本書は、数多くの草稿を重ねてきました。 ほぼ完璧に近いはずですが、誤りは皆無ではありません。 ふれていない話題も少なからずあります。 （大部分の個別のモードのような）副次的と捉えている話題や、 まだ執筆していない話題もあります。 完全にはこれらに対処しきれませんので、 意図的に省いたことがらもあります。 たとえば、VMSにおける利用方法に関する情報です。

本書で取り上げたことがらに関しては、本書は完璧であるべきですから、 例題や記述内容から章や節の構成順序といったことまで、 広く意見を求めています。 混乱を招くような記述や、本書でふれていないことがらを 学ぶためにソースや実験で調べる必要があるときには、 本書を改訂すべきなのでしょう。 そのときは、ぜひ、教えてください。

意見や訂正は、下記へメイルしてください。

bug-lisp-manual@gnu.org

ここに蓄積されたメイルは、誰かが改訂作業を始めるまでは、読み出しません。 改訂までに、数か月、ときには、数年経過することもあります。 ですから、返事がないと憤慨しないでください。 あなたのメイルは、そのうち処理されます。 Emacs保守グループに迅速に連絡したい場合には、 bug-gnu-emacs@gnu.orgにメイルしてください。

Lispの歴史

Lisp（LISt Processing language、リスト処理言語）は、 人工知能の研究向けに1950年代末にMITで初めて開発されました。 Lisp言語はとても強力なので、 エディタコマンドを記述するなどの他の目的にも理想的なのです。

長年にわたって何ダースものLispが実装されており、 それぞれが独自の特徴を有しています。 その多くは、1960年代のMITのMACプロジェクトで開発されたMaclispの 影響を受けています。 最終的には、Maclispの系統の実装者達は共同して、 Common Lispと呼ばれるLispシステムの規格を開発しました。 そうこうするうちに、MITのGerry SussmanとGuy Steeleは、 単純化してあるが非常に強力なSchemeと呼ばれるLispの方言を開発しました。

GNU EmacsはMaclispの影響を強く受けていますが、 Common Lispからの影響は少ないです。 Common Lispを知っている読者は、 Common Lispとの多くの類似点に気づかれるでしょう。 しかしながら、Common Lispの多くの機能は、 省いてあるか、単純化してあります。 これは、GNU Emacsが必要とするメモリ量を削減するためです。 ときには、劇的に単純化してあるために、 Common Lispユーザーは混乱するかもしれません。 GNU Emacs LispとCommon Lispとの相違点は、 ことあるごとに指摘するつもりです。 Common Lispを知らない読者は、何も心配することはありません。 本書は自己完結しています。

clライブラリにより、Common Lispをかなりエミュレートできます。 See Top。

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

表記法

本節では、本書で用いる表記法を説明します。 本節を読み飛ばして、あとで参照してもかまいません。

• Some Terms: Explanation of terms we use in this manual.
• nil and t: How the symbols nil and t are used.
• Evaluation Notation: The format we use for examples of evaluation.
• Printing Notation: The format we use when examples print text.
• Error Messages: The format we use for examples of errors.
• Buffer Text Notation: The format we use for buffer contents in examples.
• Format of Descriptions: Notation for describing functions, variables, etc.

用語

本書では、『Lispリーダ』および『Lispプリンタ』という言葉で、 Lispオブジェクトのテキスト表現を実際のLispオブジェクトに変換する Lisp内部のルーティン群、および、逆の変換を行うルーティン群を指します。 詳しくは、See Printed Representation。 本書の読者を『プログラマ』と考えて『読者』と呼びます。 『ユーザー』とは作者自身を含めたLispプログラムを使う人のことです。

Lispコードの例は、(list 1 2 3)という形式で、 このフォントで記します。 メタな変数の名前や説明対象の関数に対する引数の名前は、 first-numberという形式で、このフォントで書きます。

nilとt

Lispでは、シンボルnilには3つの異なる意味があります。 まず、nilという名前のシンボルです。 2つめは、真理値の偽（false）です。 3つめは、空リスト、つまり、要素数が0個のリストです。 変数として使った場合、nilの値はつねにnilです。

Lispリーダにとっては、()とnilは同一です。 どちらも、同じオブジェクト、シンボルnilを表します。 シンボルを異なった書き方にするのは、完全に人間向けです。 ()やnilをLispリーダが読み取ったあとでは、 プログラマが実際にどちらの表記を用いたかわかりません。

本書では、空リストを強調するときには()を使い、 真理値の偽を強調するときにはnilを使います。 これは、Lispプログラムでも使うとよい慣習です。

(cons 'foo ())                ; 空リストであることを強調する
(not nil)                     ; 真理値の偽であることを強調する

真理値の真を必要とする場面では、 nil以外の値は、真（true）であるとみなします。 しかし、真を表す望ましい書き方はtです。 真を表す値が必要なとき、 適当な判断基準がない場合にはtを使います。 シンボルtの値はつねにtです。

Emacs Lispでは、nilとtは特別なシンボルであり、 評価するとそれ自身になります。 そのため、これらをプログラム内で定数として使うとき、 これらをクォートする必要はありません。 これらの値を変更しようとすると、エラーsetting-constantになります。 コロン（:）で始まる名前のシンボルも同様です。 See Constant Variables。

評価の表記法

評価可能なLisp式をフォーム（form、形式）と呼びます。 フォームを評価すると、Lispオブジェクトである結果を生じます。 本書の例題では、これを=>で表します。

(car '(1 2))
     => 1

これは、『(car '(1 2))を評価すると1になる』と読みます。

フォームがマクロ呼び出しの場合には、 Lispが評価すべき新たなフォームに展開します。 展開結果を==>で表します。 展開したフォームの評価結果を示す場合もあれば、 示さない場合もあります。

(third '(a b c))
     ==> (car (cdr (cdr '(a b c))))
     => c

あるフォームを説明するときに、 同一の結果を生じる別のフォームを示すことがあります。 2つのまったく等価なフォームを==で表します。

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

結果表示の表記法

本書の数多くの例題は、評価するとテキストを表示します。 （*scratch*バッファのような）Lisp対話バッファで例題のコードを 実行すると、表示テキストはバッファに挿入されます。 （関数eval-regionで評価するなどの） 別の手段で例題を実行すると、表示テキストはエコー領域に表示されます。 エコー領域に表示されるテキストは、1行に切り詰められていることに 注意してください。

本書の例題では、表示場所には無関係に、 表示テキストを-|で表します。 フォームを評価した結果返される値（ここではbar）は、 後続の行に分けて書きます。

(progn (print 'foo) (print 'bar))
     -| foo
     -| bar
     => bar

エラーメッセージ

エラーを通知する例題もあります。 これは、通常、エコー領域にエラーメッセージを表示します。 エラーメッセージは、error-->で始まる行に示します。 エコー領域には、error-->は表示されないことに注意してください。

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

バッファ内のテキストの表記法

バッファ内のテキストを修正する例題もあります。 このような場合、『実行前』と『実行後』のテキストを示します。 それらの例題では、バッファ名を含めたダッシュから成る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行目は、それぞれの名前と、引数があれば引数群です。 これに説明文が続き、場合によっては例題も示します。

• A Sample Function Description: A description of an imaginary function, foo.
• A Sample Variable Description: A description of an imaginary variable, electric-future-map.

関数の記述例

関数の記述では、まず始めに説明対象の関数名があります。 同じ行には、引数名の並びも続きます。 これらの名前は、説明文の中で引数の値を参照するために使います。

引数ならびにキーワード&optionalが現れていれば、 それ以降の引数を省略できることを示します（省略した引数の値はnil）。 関数を呼び出すときに&optionalを書いてはいけません。

キーワード&rest （このあとには1つの引数名だけが続く）は、 残りの引数が何個でもよいことを示します。 直後にある1つの引数名は、変数としての値を持ち、 その値は残りのすべての引数のリストです。 関数を呼び出すときに&restを書いてはいけません。

では、仮想的な関数fooの記述を以下に示します。

foo integer1 &optional integer2 &rest integers

Function

関数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オブジェクトの型の一覧については、see Lisp Data Types）。 （new-fileなどの）その他の名前の引数は、関数の説明文の中で言及します。 複数の関数の引数に共通する特徴について、 節の始めで説明する場合もあります。

&optionalと&restについての詳しい説明は、 See Lambda Expressions。

コマンド、マクロ、スペシャルフォームの記述も同じ形式ですが、 「関数」のかわりに 「コマンド」、「マクロ」、「スペシャルフォーム」のいずれかです。 コマンドは、対話的に呼び出せる単なる関数です。 マクロは関数とは違った方法で引数を処理します（引数を評価しない）が、 同じ方法で引数を記します。

スペシャルフォームの記述では、省略可能な引数や繰り返される引数を 示すために、より複雑な記法を使います。 というのは、引数並びを個々の引数に分離する方法が複雑だからです。 [optional-arg]は、 optional-argが省略可能であることを示します。 また、repeated-args...は、0個以上の引数を示します。 いくつかの引数をリスト構造の内側にまとめるときには、 括弧を使います。

count-loop (var [from to [inc]]) body...

Special Form

この仮想的なスペシャルフォームは、 フォーム群bodyを実行してから変数varを増やすことを 反復するループを実現する。 最初は、変数の値はfromである。 以降の反復では、変数を1（あるいは、指定があればincだけ）増やす。 varがtoに等しくなると、 bodyを実行せずにループから抜ける。 例を示す。 (count-loop (i 0 10) (prin1 i) (princ " ") (prin1 (aref vector i)) (terpri)) fromとtoを省略すると、 ループ開始前にvarにnilを束縛し、 各反復の開始時にvarがnil以外であるとループから抜け出る。 (count-loop (done) (if (pending) (fixit) (setq done t))) このスペシャルフォームでは、引数fromとtoは省略できるが、 両者を同時に指定するか、同時に省略すること。 これらを指定した場合、incを指定してもよい。 これらの引数は、引数varとともにリストにまとめる。 これはbodyと区別するためであり、 bodyは残りのフォームの要素すべてを含む。

変数の記述例

変数（variable）は、値を保持するための名前です。 ユーザーはどんな変数でも設定できますが、 ユーザーが変更可能な特定の変数群があり、 それらをユーザーオプション（user options）と呼びます。 普通の変数もユーザーオプションも関数の記述と同じ形式で示しますが、 それらに引数はありません。

仮想的な変数electric-future-mapの記述例を示します。

electric-future-map

Variable

この変数の値は、Electric Command Futureモードで使用する 完全なキーマップである。 このマップに含まれる関数は、まだ実行していないコマンドの編集を可能にする。

ユーザーオプションの記述も同じ形式ですが、 「変数」のかわりに「ユーザーオプション」です。

版情報

これらの機構は、使用中のEmacsの版に関する情報を提供します。

emacs-version

コマンド

この関数は、実行中のEmacsの版を記述した文字列を返す。 この文字列はバグの報告に含めると有益である。 (emacs-version) => "GNU Emacs 20.3.5 (i486-pc-linux-gnulibc1, X toolkit) of Sat Feb 14 1998 on psilocin.gnu.org" 対話的に呼び出すと、この関数は同じ情報をエコー領域に表示する。

emacs-build-time

Variable

この変数の値は、ローカルのサイトでEmacsを構築した日時を示す。 3つの整数から成るリストであり、 current-timeと同様のもの（see Time of Day）。 emacs-build-time => (13623 62065 344633)

emacs-version

Variable

この変数の値は、実行中のEmacsの版番号。 "20.3.1"のような文字列である。 この文字列の最後の数字は、Emacsのリリース版番号の一部ではなく、 特定のディレクトリでEmacsを構築するたびに増える。

つぎの2つの変数は、Emacs 19.23以降に存在します。

emacs-major-version

Variable

Emacsのメジャー版番号を表す整数。 Emacs 20.3では、値は20。

emacs-minor-version

Variable

Emacsのマイナ版番号を表す整数。 Emacs 20.3では、値は3。

謝辞

本書は、Robert Krawitz、Bil Lewis、Dan LaLiberte、 Richard M. Stallman、Chris Welty、GNUマニュアルプロジェクトのボランティア による何年にもわたる努力で執筆されました。 Computational Logic社のWarren A. Hunt, Jr.が手配した 国防省Advanced Research Projects Agency、ARPA Order 6082の援助のもと、 Robert J. Chassellは本書のレビューと編集に協力してくれました。

以下の方々が訂正を送ってくれました。 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、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、Skip Montanaro、John Gardiner Myers、Thomas A. Peterson、 Francesco Potorti、Friedrich Pukelsheim、Arnold D. Robbins、Raul Rockwell、Per Starback、Shinichirou Sugou、Kimmo Suominen、Edward Tharp、 Bill Trost、Rickard Westman、Jean White、Matthew Wilding、Carl Witty、 Dale Worley、Rusty Wright、David D. Zuhn。

Lispのデータ型

Lispオブジェクト（object）とは、 Lispプログラムが使用し操作するデータのことです。 型（type）やデータ型（data type）とは、ここでは、 可能なオブジェクトの集合を意味します。

各オブジェクトは、少なくとも、1つの型に属します。 同じ型のオブジェクトは、構造に類似性があり、普通、同じ文脈で使われます。 型は互いに重複していてもよく、オブジェクトは複数の型に属することができます。 そのため、オブジェクトが特定の型に属するかどうかは判断できますが、 オブジェクトの型を『1つ』に限定することはできません。

Emacsには少数の基本オブジェクト型を組み込んであります。 これらの型は他のすべてのオブジェクト型を構成するもとであり、 基本型（primitive types）と呼びます。 各オブジェクトはたった1つの基本型に属します。 基本型には、 整数（integer）、浮動小数点数（float）、 コンス（cons）、シンボル（symbol）、 文字列（string）、ベクトル（vector）、subr、 バイトコード関数（byte-code function）、 ならびに、編集に関連するバッファ（buffer）などの 特別な型があります。 （see Editing Types。）

各基本型には、その型に属するオブジェクトであるかどうかを検査する 対応するLisp関数があります。

Lispオブジェクトは型を自己記述（self-typing）するという点で、 Lispは他の多くの言語とは異なります。 つまり、オブジェクトの基本型は、オブジェクト自体に暗に含まれています。 たとえば、オブジェクトがベクトルであれば、それを数と扱うことはありません。 Lispには、ベクトルは数ではないとわかっているのです。

多くの言語では、プログラマは各変数のデータ型を宣言する必要があります。 型はコンパイラが知っているのであって、データの中には入っていません。 このような型宣言はEmacs Lispには存在しません。 Lisp変数はどんな型の値でも保持でき、 変数に入れた値と型を記録しています。

本章では、GNU Emacs Lispの各標準型の表示表現と入力構文を説明します。 これらの型の使用方法の詳細は、あとの章に譲ります。

• Printed Representation: How Lisp objects are represented as text.
• Comments: Comments and their formatting conventions.
• Programming Types: Types found in all Lisp systems.
• Editing Types: Types specific to Emacs.
• Type Predicates: Tests related to types.
• Equality Predicates: Tests of equality between any two objects.

表示表現と入力構文

オブジェクトの表示表現（printed representation）とは、 Lispプリンタ（関数prin1）がそのオブジェクトを出力表示するときの 書式です。 オブジェクトの入力構文（read syntax）とは、 Lispリーダ（関数read）がそのオブジェクトを入力として受理する書式です。 See Read and Print。

ほとんどのオブジェクトには1つ以上の可能な入力構文があります。 ある種の型のオブジェクトには入力構文はありませんが、 そのような型のオブジェクトをLispプログラムに直接入力する意味がないからです。 このような場合を除くと、 オブジェクトの表示表現はそのオブジェクトの入力構文でもあります。

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

各型には表示表現があります。 入力構文のない型もあります。 たとえば、バッファ型には入力構文はありません。 このような型のオブジェクトはハッシュ記法（hash notation）で表示します。 つまり、文字列#<のあとに説明用の文字列 （典型的には型名にオブジェクトの名前を続けたもの）を続け、 対応する>で閉じます。 ハッシュ記法を読み取ることはできませんから、 Lispリーダが#<に出会うとエラーinvalid-read-syntaxを 通知します。

(current-buffer)
     => #<buffer objects.texi>

読者が対話的に式を評価するとき、 Lispインタープリタは、まず、 式のテキスト表現を読み取ってLispオブジェクトを生成し、 そのオブジェクトを評価します（see Evaluation）。 しかしながら、評価と読み取りは別々の動作です。 読み取りでは、読み取ったテキストが表すLispオブジェクトを返します。 このオブジェクトを、のちに評価する場合もありますが、 評価しない場合もあります。 オブジェクトを読み取る基本関数readについては、 See Input Functions。

コメント

コメント（comment）は、プログラム内に書かれたテキストであり、 プログラムを読む人間のためだけにあり、 プログラムの意味にはまったく影響しません。 Lispでは、文字列や文字定数の外にあるセミコロン（;）で コメントを始めます。 コメントは行末までです。 Lispリーダは、コメントを破棄します。 コメントは、 Lispシステム内部でプログラムを表すLispオブジェクトの一部にはなりません。

#@countという書き方は、 後続のcount個の文字を飛び越します。 これは、プログラムで生成したバイナリデータを含むコメントに便利です。 Emacs Lispのバイトコンパイラは、出力ファイルにこのようなコメントを使います （see Byte Compilation）。 しかしながら、ソースファイル向きではありません。

コメントの体裁に関する慣習については、See Comment Tips。

プログラミング向けの型

Emacs Lispには、大きく2種類の型があります。 Lispのプログラミングに関わるものと、編集に関わるものです。 前者は、さまざまな形でLispの多くの実装に見られます。 後者は、Emacs Lispに固有です。

• Integer Type: Numbers without fractional parts.
• Floating Point Type: Numbers with fractional parts and with a large range.
• Character Type: The representation of letters, numbers and control characters.
• Symbol Type: A multi-use object that refers to a function, variable, or property list, and has a unique identity.
• Sequence Type: Both lists and arrays are classified as sequences.
• Cons Cell Type: Cons cells, and lists (which are made from cons cells).
• Array Type: Arrays include strings and vectors.
• String Type: An (efficient) array of characters.
• Vector Type: One-dimensional arrays.
• Char-Table Type: One-dimensional sparse arrays indexed by characters.
• Bool-Vector Type: One-dimensional arrays of t or nil.
• Function Type: A piece of executable code you can call from elsewhere.
• Macro Type: A method of expanding an expression into another expression, more fundamental but less pretty.
• Primitive Function Type: A function written in C, callable from Lisp.
• Byte-Code Type: A function written in Lisp, then compiled.
• Autoload Type: A type used for automatically loading seldom-used functions.

整数型

Emacs Lispにおける整数の値の範囲は、ほとんどの計算機では、 -134217728から134217727（28ビット長。つまり から です。 （計算機によっては、より広い範囲になる。） Emacs Lispの算術演算関数は、桁溢れ（オーバフロー）を 検査しないことを覚えておいてください。 したがって、ほとんどの計算機では、 (1+ 134217727)は-134217728となります。

整数の入力構文は、（10を基数とした）数字の並びであり、 先頭に符号があってもよく、また、最後にピリオドがあってもかまいません。 Lispインタープリタが生成する表示表現では、 先頭の+や最後の.はありません。

-1               ; 整数 -1
1                ; 整数 1
1.               ; これも整数 1
+1               ; これも整数 1
268435457        ; 28ビット長整数では、これも整数 1

より詳しくは、See Numbers。

浮動小数点数

Emacsは浮動小数点数を扱えます （ただし、コンパイル時のオプションで使用不可にできる）。 浮動小数点数の範囲は、計算機に依存します。

浮動小数点数の表示表現には、 小数点（に続けて1桁以上の小数部分）または指数、 あるいは、その両方が必要です。 たとえば、1500.0、15e2、15.0e2、 1.5e3、.15e4は、同じ1500という値の 浮動小数点数を書く5つの方法です。 どれも、まったく等価です。

詳しくは、See Numbers。

文字型

Emacs Lispにおける文字（character）は、 整数以外の何物でもありません。 いいかえれば、文字はその文字コードで表現されます。 たとえば、文字Aは整数 65と表現されます。

プログラムで個々の文字を独立に使うことはあまりありません。 文字を並べた文字列（strings）として扱うことが断然多いのです。 See String Type。

文字列内、バッファ内、ファイル内の文字は、 現時点では、0から524287までの範囲、19ビット長に制限されます。 しかし、この範囲の値すべてが正しい文字コードではありません。 0から127までのコードはASCIIコードです。 それ以外は、非ASCIIです（see Non-ASCII Characters）。 キーボード入力を表す文字は、コントロール、メタ、シフトなどの 修飾キーを符号化するために、範囲がより広くなります。

文字は、実際には整数ですから、文字の表示表現は10進数です。 また、文字の入力構文として10進数も可能ですが、 Lispプログラムでこのように文字を書くのは最悪です。 Emacs Lispに用意してある文字向けの特別な入力構文を つねに使うべきです。 これらの構文は疑問符で始まります。

英数字向けの普通の入力構文は、疑問符に続けて1つの英数字を書きます。 したがって、文字Aは?A、文字Bは?B、 文字aは?aと書きます。

たとえば、つぎのとおりです。

?Q => 81     ?q => 113

同じ入力構文を句読点文字にも使えますが、 \を追加して、Lispコードを編集するEmacsコマンドが混乱しないように することがよいでしょう。 たとえば、空白文字は?\ と書きます。 文字\は、クォートするために2つめの\を使う必要があり ?\\です。

コントロールg、バックスペース、タブ、改行、 垂直タブ、ページ送り、復帰、エスケープは、 それぞれ、?\a、?\b、?\t、?\n、?\v、 ?\f、?\r、?\eと書きます。 つまり、つぎのとおりです。

?\a => 7                 ; 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-[
?\\ => 92                ; バックスラッシュ文字、\

バックスラッシュで始まる系列は エスケープシーケンス（escape sequences）とも呼びます。 バックスラッシュが、エスケープ文字の役割を果たすからです。 この使い方は、文字<ESC>とは関係ありません。

コントロール文字は別の入力構文でも表現できます。 疑問符に続けてバックスラッシュ、カレット（^）、そして、 対応するコントロールでない文字を大文字か小文字で書きます。 たとえば、?\^Iも?\^iも、 値が9である文字C-iの正しい入力構文です。

カレットのかわりに、C-を使ってもかまいません。 ですから、?\C-iは、?\^Iや?\^iと等価です。

?\^I => 9     ?\C-I => 9

文字列やバッファ内ではASCIIのコントロール文字だけが許されますが、 キーボード入力においてはC-で任意の文字をコントロール文字にできます。 これらの非ASCIIコントロール文字の文字コードは、 対応する非コントロール文字の文字コードと のビットを含みます。 普通の端末では、非ASCIIコントロール文字を生成する手立てはありませんが、 Xウィンドウシステムや他のウィンドウシステムでは、 簡単に生成できます。

歴史的な理由で、 Emacsは<DEL>文字を?に対応したコントロール文字として扱います。

?\^? => 127     ?\C-? => 127

その結果、今のところ、 Xウィンドウシステムのもとでは意味のある文字Control-?を \C-では表現できません。

ファイルや文字列に現れるコントロール文字を表現するには、 ^構文を勧めます。 キーボード入力のコントロール文字には、C-構文が好ましいです。 どちらを使ってもプログラムの意味には影響しませんが、 それを読む人には理解の手助けになるかもしれません。

メタ文字（meta character）は、 <META>修飾キーを使って打った文字です。 そのような文字を表す整数は、（ほとんどの計算機では負の数になる） のビットがセットされています。 上位のビットをメタや他の修飾子に用いることで、 基本となる文字コードの範囲をできるだけ大きくします。

文字列では、メタ文字を表すASCII文字には のビットを付加します。 つまり、文字列に収められるメタ文字のコードは128から255の範囲であり、 任意のASCII文字のメタ変種を使えます。 （Emacs 18やそれ以前では、この方式を文字列の外にある文字にも使っていた。）

メタ文字の入力構文には\M-を使います。 たとえば、?\M-AはM-Aです。 \M-と一緒に8進文字コードも使えますし（下記参照）、 \C-や文字向けの他の構文も使えます。 したがって、M-Aは?\M-Aと書いたり?\M-\101と書けます。 同様に、C-M-bは?\M-\C-b、 ?\C-\M-b、?\M-\002と書けます。

図形文字の大文字小文字は、その文字コードで示されます。 たとえば、ASCIIではaとAの文字を区別します。 しかし、ASCIIではコントロール文字の大文字小文字を表現できません。 Emacsでは、コントロール文字を打つときに使ったシフトキーを表すために のビットを付加します。 このような区別はX端末や他の特別な端末を使っている場合に限り可能です。 普通の端末ではこのような区別を計算機に送れません。

Xウィンドウシステムでは、 文字に設定可能な修飾ビットが他に3つあります。 ハイパー（hyper）、スーパー（super）、アルト（alt）です。 これらの修飾ビットの構文は、 \H-、\s-、\A-です。 （これらのプレフィックスでは、大文字小文字を区別する。） したがって、?\H-\M-\A-xはAlt-Hyper-Meta-xを表します。

文字向けのもっとも汎用の入力構文では、 文字コードを8進数や16進数で表現します。 8進数を使うには、順に、 疑問符、バックスラッシュ、（3桁までの）8進数字文字コードを書きます。 たとえば、?\101は文字Aを表し、 ?\001は文字C-aを表し、?\002は文字C-bを表します。 この構文で任意のASCII文字を表現できますが、 ASCIIでの表現よりも8進数値で表現することが重要な場合に限るべきです。

?\012 => 10         ?\n => 10         ?\C-j => 10
?\101 => 65         ?A => 65

16進数を使うには、順に、疑問符、バックスラッシュ、 x、16進数字文字コードを書きます。 16進数の桁数はいくつでもよいので、任意の文字コードを表現できます。 したがって、?\x41は文字Aを表し、 ?\x1は文字C-aを表し、 ?\x8e0は

特別なエスケープの意味を持たないどんな文字のまえにもバックスラッシュを 付けることができ、しかも、無害です。 したがって、?\+は?+に等価です。 ほとんどの文字のまえにバックスラッシュを付ける理由はありません。 しかしながら、Lispコードを編集するEmacsコマンドが混乱しないように、 ()\|;'`"#.,のいずれかの文字のまえにはバックスラッシュを付けるべきです。 空白、タブ、改行、ページ送りのような白文字のまえにも バックスラッシュを付けるべきです。 しかしながら、タブなどの実際の白文字のかわりに、 \tなどの読みやすいエスケープシーケンスを使ったほうが明確です。

シンボル型

GNU Emacs Lispにおけるシンボル（symbol）は、 名前を持ったオブジェクトです。 シンボル名は、シンボルの表示表現としての役割があります。 普通の使い方では、名前は一意です。 つまり、2つのシンボルが同じ名前を持つことはありません。

シンボルは、変数としての役割、関数名としての役割、 あるいは、属性リストを保持する役割を果たします。 また、他のすべてのLispオブジェクトと区別するためだけの役割を 果たすこともあり、データ構造の内部にそのようなシンボルが存在することを 正確に認識できます。 ある場面においては、普通、これらのうちの1つの使い方をします。 しかし、ある1つのシンボルに対してすべての使い方をしてもかまいません。

シンボル名には、どんな文字でも含められます。 ほとんどのシンボル名は、英文字、数字、-+=*/の句読点文字で書かれます。 そのような名前では、特別な書き方は必要ありません。 名前が数に見えなければ、名前を構成する文字はなんでもよいのです。 （名前が数に見えるときには、 名前の先頭に\を書いてシンボルであると強制する。） _~!@$%^&:<>{}の文字はあまり使われませんが、 これらにも特別な書き方は必要ありません。 これら以外の文字は、バックスラッシュでエスケープすれば、 シンボル名に含められます。 文字列におけるバックスラッシュの用法とは対照的に、 シンボル名におけるバックスラッシュは、直後の1文字をクォートするだけです。 たとえば、文字列では\tはタブ文字を表しますが、 シンボル名では英文字tをクォートするだけです。 名前にタブ文字を含むシンボルを書くには、 実際に（バックスラッシュの直後に）タブを使う必要があります。 しかし、そのようなことをするのは皆無でしょう。

Common Lispに関した注意： Common Lispでは、小文字を明示的にエスケープしない限り、 小文字をつねに大文字に『変換』する。 Emacs Lispでは、大文字と小文字を区別する。

シンボル名の例をいくつかあげましょう。 5番目の例の+は、数として読まれるのを防ぐために エスケープしてあることに注意してください。 6番目の例では、これは必要ありません。 なぜなら、名前の残りの部分が数としては不正だからです。

foo                 ; fooという名前のシンボル
FOO                 ; FOOという名前のシンボル、fooとは別
char-to-string      ; char-to-stringという名前のシンボル
1+                  ; 1+という名前のシンボル
                    ;   （整数の+1ではない）
\+1                 ; +1という名前のシンボル
                    ;   （読みにくい名前）
\(*\ 1\ 2\)         ; (* 1 2)という名前のシンボル（悪い名前）
+-*/_~!@$%^&=:<>{}  ; +-*/_~!@$%^&=:<>{}という名前のシンボル
                    ;   これらの文字をエスケープする必要はない

シーケンス型

シーケンス（sequence）とは、 要素の順序集合を表現するLispオブジェクトです。 Emacs Lispには2種類のシーケンス、つまり、リストと配列があります。 したがって、リスト型や配列型のオブジェクトは、 シーケンス型でもあると考えられます。

配列はさらに、文字列、ベクトル、文字テーブル、ブールベクトルに細分されます。 ベクトルは任意の型の要素を保持できますが、 文字列の要素は文字である必要があり、 ブールベクトルの要素はtかnilのいずれかである必要があります。 バッファ内の文字のように、 文字列内の文字はテキスト属性を持てます（see Text Properties）。 ベクトルとブールベクトル ⁵ では、それらの要素が文字であったとしても、 テキスト属性を扱えません。 文字テーブルは、ベクトルに似ていますが、正しい文字コードで添字付けします。

リスト、文字列、および、その他の配列型は別のものですが、 それらには重要な類似性があります。 たとえば、それらすべてに長さlがあり、 それらのすべての要素は0からl-1で添字付けできます。 シーケンス関数と呼ばれるいくつかの関数は、 任意のシーケンス型を扱います。 たとえば、シーケンスから指定した添字の要素を取り出すには、 関数eltを使います。 See Sequences Arrays Vectors。

一般には、同一のシーケンスを二度読み取ることは不可能です。 というのは、読むたびにつねに新たにシーケンスを作成するからです。 シーケンスの入力構文を二度読むと、 同じ内容の2つのシーケンスを得ることになります。 1つ例外があります。 空リスト()は、つねに同じオブジェクトnilを表します。

コンスセルとリスト型

コンスセル（cons cell）とは、 CARスロットおよびCDRスロットと呼ばれる 2つのポインタから成るオブジェクトです。 各スロットは、任意のLispオブジェクトを指すことができます。 また、現在CARスロットが指しているオブジェクトがなんであれ、 『コンスセルのCARは』といったいい方をします。 CDRについても同様です。

リスト（list）はコンスセルが連なったものであり、 各コンスセルのCDRスロットは、 後続のコンスセルを指すか空リストを指します。 リストに作用する関数については、See Lists。 ほとんどのコンスセルは、リストの一部分として使われるので、 リスト構造（list structure）という用語は、 コンスセルから成る任意の構造のことを意味します。

CARやCDRという名称は、Lispの歴史に由来します。 最初のLispはIBM 704で動作していました。 この計算機では、ワードを2つの部分、『番地』（address）部分、 『減数』（decrement）部分と呼ばれるものに分けていました。 CARはレジスタの番地部分の内容（Contents of Address Register）を 取り出す命令であり、 CDRはレジスタの減数部分の内容（Contents of Decrement Register）を 取り出す命令でした。 一方、『コンスセル』という名称は、 これらを作成する関数consからきています。 この関数名は、その目的、セルを作る（construction of cells）からきています。

コンスセルはLispの核心なので、 『コンスセルではないオブジェクト』に対する名称もあります。 これらのオブジェクトをアトム（atoms）と呼びます。

リストの入力構文と表示表現は同一です。 開き括弧で始まり、任意個の要素、閉じ括弧で終えます。

読み取り時には、括弧の内側の各オブジェクトが、 リストの各要素になります。 つまり、これらの要素からなるコンスセルを作ります。 コンスセルのCARスロットで要素を指します。 同じコンスセルのCDRスロットで、 リスト上のつぎの要素を保持している、 リストのつぎのコンスセルを指します。 最後のコンスセルのCDRスロットはnilを指します。

リストは、コンスセルを1対の箱で表して図示できます。 （Lispリーダがこのような図表示を読むことはない。 人間や計算機が理解できるテキスト表記と違い、 箱を用いた図表示は人間だけが理解できる。） つぎの図は、3つの要素から成るリスト(rose violet buttercup)を表します。

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

この図で、各箱は、任意のLispオブジェクトを指すことができるスロットを表します。 箱の対でコンスセルを表します。 各矢印は、アトムや他のコンスセルであるLispオブジェクトを指すポインタです。

この例では、最初のコンスセルのCARを表す最初の箱は、 rose（シンボル）を指しています。 あるいは、rose（シンボル）を『含んでいる』ともいいます。 最初のコンスセルのCDRを表す2番目の箱は、 つぎの1対の箱、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はシンボルでもありリストでもあります。

Lispの構文で書き表したリストの例を示します。

(A 2 "A")            ; 3要素のリスト
()                   ; 要素を持たないリスト（空リスト）
nil                  ; 要素を持たないリスト（空リスト）
("A ()")             ; 文字列"A ()"だけの1要素のリスト
(A ())               ; Aと空リストから成る2要素のリスト
(A nil)              ; 上と同じ
((A B C))            ; 1要素のリスト
                     ;   （その要素は3要素のリスト）

リスト(A ())や、これと同じ(A nil)を 箱と矢印で書くとつぎのようになります。

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

• Dotted Pair Notation: An alternative syntax for lists.
• Association List Type: A specially constructed list.

ドット対記法

ドット対記法（dotted pair notation）とは、 CARとCDRを明示したコンスセルを表すもう1つの構文です。 この構文では、(a . b)で、 CARがオブジェクトaであり CDRがオブジェクトbであるコンスセルを表します。 したがって、ドット対記法は、リストの構文よりさらに汎用性があります。 ドット対記法では、リスト(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)という構文は不正です。 これが意味することはなにもありません。 たとえあったとしても、CDRをviolet用にすでに使っているコンスセルの CDRにbuttercupを置けということになります。

リスト(rose violet)は、(rose . (violet))に等価であり、 つぎのように図示できます。

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

同様に、3要素のリスト(rose violet buttercup)は、 (rose . (violet . (buttercup)))に等価です。

連想リスト型

連想リスト（association list）、すなわち、alistは、 各要素がコンスセルであるように特別に構成したリストのことです。 各要素では、CARをキー（key）と考え、 CDRを連想値（associated value）と考えます。 （場合によっては、連想値を、CDRのCARに保持することもある。） 連想リストはスタックとして使われることがままあります。 というのは、リストの先頭に対応関係を追加／削除するのが簡単だからです。

たとえば、

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

は、変数alist-of-colorsに、3要素の連想リストを設定します。 最初の要素では、roseがキーであり、redが値です。

連想リストとそれらを操作する関数について詳しい説明は、 See Association Lists。

配列型

配列（array）は、任意のLispオブジェクトを指すための 任意個のスロットから成り、メモリの連続した場所に取ります。 配列のどの要素を参照しても、ほぼ同じ時間かかります。 一方、リストの要素を参照するときには、 リスト内の要素の位置に比例した時間が必要です。 （リストの末尾の要素を参照するには、 リストの先頭の要素を参照するより時間がかかる。）

Emacsには、4つの配列型、つまり、 文字列、ベクトル、ブールベクトル、文字テーブルがあります。

文字列は文字の配列であり、 ベクトルは任意のオブジェクトの配列です。 ブールベクトルは、tやnilだけを保持できます。 これらの種類の配列は、最大の整数値までなら、任意の長さにできます。 文字テーブルは、正しい文字コードで添字付けする疎な配列であり、 任意のオブジェクトを保持できます。

配列の最初の要素は0で添字付けする、 2番目の要素は1で添字付けする、というようになります。 これをゼロ原点（zero-origin）の添字付けと呼びます。 たとえば、4つの要素からなる配列の添字は、0、1、2、そして、3です。 最大の添字は、配列の長さより1だけ小さくなります。 いったん配列を作成すると、その長さは固定されます。

Emacs Lispのすべての配列は1次元です。 （多くの他のプログラム言語では多次元配列を扱えるが、 それは本質的ではない。 配列の配列を作れば同じ効果を得られる。） 配列のそれぞれの型に応じて、専用の入力構文があります。 詳しくは、以下を参照してください。

配列型はシーケンス型に含まれ、 配列型は、文字型、ベクトル型、ブールベクトル型、文字テーブル型を含みます。

文字列型

文字列（string）とは文字の配列です。 テキストエディタということから予想されるように、 Emacsではさまざまな目的に文字列を使います。 たとえば、Lispシンボルの名前として、 ユーザーへのメッセージとして、 バッファから取り出したテキストを表現するためなどです。 Lispの文字列は定数です。 つまり、文字列を評価すると同じ文字列になります。

文字列を操作する関数については、See Strings and Characters。

• Syntax for Strings:
• Non-ASCII in Strings:
• Nonprinting Characters:
• Text Props and Strings:

文字列の構文

文字列の入力構文は、"like this"のように、 ダブルクォートで始めて、任意個の文字を書き、ダブルクォートで終えます。 文字列の中にダブルクォートを含めるには、 バックスラッシュを直前に置きます。 つまり、"\""は、ダブルクォート1個だけから成る文字列です。 同様に、バックスラッシュを含めるには、 "this \\ is a single embedded backslash"のように、 バックスラッシュを直前に置きます。

文字列の入力構文において、改行文字は特別ではありません。 ダブルクォートのあいだに改行を書けば、 改行は文字列の文字になります。 一方、エスケープした改行、つまり、\を直前に書くと、 文字列の一部にはなりません。 すなわち、Lispリーダは、文字列を読む際にエスケープした改行を無視します。 エスケープした空白\ も、同様に無視します。

"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."

文字列内の非ASCII文字

非ASCIIである国際化文字を文字列に含めるには、 その文字をそのまま書きます。 Emacsの文字列（および、バッファ）では、 非ASCIIの表現方法が2つあります。 ユニバイトとマルチバイトです。 マルチバイトバッファやマルチバイト文字列、あるいは、 マルチバイトとして訪問しているファイルなどの マルチバイトのソースから文字列定数を読み取るときには、 文字をマルチバイト文字として読み取り、 マルチバイト文字列にします。 ユニバイトのソースから文字列定数を読み取るときには、 文字をユニバイト文字として読み取り、 文字列はユニバイトになります。

マルチバイトの非ASCII文字は、 必要な桁数の16進エスケープ\xnnnnnnnを用いて 書くこともできます。 （マルチバイトの非ASCII文字のコードは、256より大きい。） 16進数字として正しくない文字で16進エスケープを終端します。 16進数字の文字があとに続く場合には、\ （バックスラッシュと空白）と 書いて16進エスケープを終端します。 たとえば、\x8e0\ は、グレーブアクセント付きのaを表します。 文字列定数内の\ は、バックスラッシュ＋改行と同じです。 文字列内の文字には含まれませんが、先行する16進エスケープを終えます。

マルチバイトの16進エスケープを使うと、 文字列はマルチバイトになります。 ユニバイトの非ASCIIを文字コードで表現することもできますが、 文字コードは128（8進0200）から255（8進0377）の範囲である必要があります。 こうすると、文字列はユニバイトになります。

2種類のテキストの表現方法について詳しくは、See Text Representations。

文字列内の非印字文字

文字定数と同じバックスラッシュのエスケープシーケンスを文字列定数でも 使えます（ただし、文字定数を開始する疑問符は書かない）。 たとえば、コンマと空白で区切った非印字文字のタブとC-aを 含む文字列を書くには、"\t, \C-a"のようにします。 文字の入力構文については、See Character Type。

しかしながら、バックスラッシュのエスケープシーケンスすべてが、 文字列において正しいとは限りません。 文字列に含めることが可能なコントロール文字は、 ASCIIコントロール文字に限ります。 文字列では、ASCIIコントロール文字の大文字小文字を区別しません。

正確にいえば、文字列はメタ文字を保持できません。 しかし、文字列をキー列として使う場合には、 文字列内のASCII文字のメタ変種を表現するための 特別な慣習があります。 文字列定数内でメタ文字を表すために\M-の構文を使うと、 文字列内のその文字に のビットを設定します。 define-keyやlookup-keyに文字列を使うと、 このコードは、等価なメタ文字に変換されます。 See Character Type。

文字列では、ハイパー、スーパー、アルトの修飾子を保持できません。

文字列内のテキスト属性

文字列は、文字そのものに加えて、文字の属性も保持できます。 このため、特別なことをしなくても、 文字列とバッファのあいだでテキストをコピーするプログラムは、 テキスト属性をコピーできます。 テキスト属性の意味については、See Text Properties。 テキスト属性付きの文字列には、特別な入力構文があります。

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

ここで、property-dataは0個以上のつぎのような3つ組みです。

beg end plist

3つ組みの要素、begとendは整数であり、 文字列内の添字の範囲を表します。 plistはその範囲の属性リストです。 たとえば、

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

は、最初の3文字がface属性としてboldを持ち、 最後の3文字がface属性としてitalicを持つ、 foo barという文字列を表します。 （4番目の文字にはテキスト属性はなく、その属性リストはnil。 デフォルトでは、範囲に含まれない文字には属性はないので、 属性リストがnilであるような範囲を言及する必要はない。）

ベクトル型

ベクトル（vector）は、任意の型の要素から成る1次元配列です。 ベクトルの任意の要素を参照しても、それに必要な時間は一定です。 （リストでは、ある要素を参照するために必要な時間は、 リストの先頭からの距離に比例する。）

ベクトルの表示表現は、開き角括弧、要素、閉じ角括弧です。 これは、入力構文でもあります。 数や文字列と同様に、ベクトルは評価時には定数です。

[1 "two" (three)]      ; 3要素のベクトル
     => [1 "two" (three)]

ベクトルに作用する関数については、See Vectors。

文字テーブル型

文字テーブル（char-table）は、 任意の型の要素から成る1次元配列であり、 文字コードで添字付けします。 文字テーブルには、文字コードに情報を与えるための多くの操作を簡単にする 付加的な機能があります。 たとえば、文字テーブルは、情報を継承するための親、 デフォルト値、特定目的向けの少数の追加スロットを持てます。 文字テーブルでは、文字集合全体に対して1つの値を指定することもできます。

文字テーブルの表示表現はベクトルに似ていますが、 先頭に#^が余分に付きます。

文字テーブルを操作する特別の関数については、See Char-Tables。 文字テーブルはつぎのように使います。

• 大文字小文字テーブル（see Case Tables）。
• 文字カテゴリテーブル（see Categories）。
• 表示テーブル（see Display Tables）。
• 構文テーブル（see Syntax Tables）。

ブールベクトル型

ブールベクトル（bool-vector）は、 tかnilだけの要素から成る1次元配列です。

ブールベクトルの表示表現は文字列に似ていますが、 #&と長さで始まります。 これに続く文字列定数が、ブールベクトルの実際の内容を ビットマップで表します。 つまり、文字列の『各文字』は8ビット長のデータであり、 ブールベクトルのつぎの8個の要素を表します （1はtを表し、0はnilを表す）。 文字の最下位ビットが、ブールベクトルの小さい添字に対応します。 長さが8の倍数でない場合には、 表示表現には余計な要素が含まれますが、余計な部分に意味はありません。

(make-bool-vector 3 t)
     => #&3"\007"
(make-bool-vector 3 nil)
     => #&3"\0"
;; 最初の3ビットだけを使っているので、以下はすべて同じ
(equal #&3"\377" #&3"\007")
     => t

関数型

他のプログラム言語の関数が実行可能であるように、 Lisp関数（Lisp function）は実行可能なコードです。 しかしながら、Lispにおいては、関数は基本Lispオブジェクトであり、 そのテキスト表現は副次的なものです。 これらのLispオブジェクトはラムダ式です。 つまり、先頭要素がシンボルlambdaであるリストです （see Lambda Expressions）。

ほとんどのプログラム言語では、名前のない関数を書くことは不可能です。 Lispでは、本質的には、関数に名前はありません。 ラムダ式のことを無名関数（anonymous function）とも呼びます （see Anonymous Functions）。 Lispにおける名前付き関数は、実際には、 関数セルに正しい関数を収めたシンボルです （see Defining Functions）。

多くの場合、LispプログラムのLisp式中に関数名を書くと関数が呼ばれます。 しかし、実行時に関数オブジェクトを構成したり取得して、 基本関数funcallやapplyで、それを呼び出すことができます。 See Calling Functions。

マクロ型

Lispマクロ（Lisp macro）は、 Lisp言語を拡張するユーザー定義の構造です。 関数に似たオブジェクトで表現しますが、引数渡しの意味は異なります。 Lispマクロは、リストの最初の要素がシンボルmacroであり、 リストのCDRがlambdaシンボルを 含むLisp関数オブジェクトであるフォームです。

Lispマクロオブジェクトは、通常、組み込み関数defmacroで 定義しますが、 Emacsにとっては、macroで始まるリストはマクロです。 マクロの書き方の説明は、See Macros。

警告： Lispマクロとキーボードマクロ （see Keyboard Macros）は、まったく別のものです。 単に『マクロ』といった場合には、Lispマクロを意味するのであって、 キーボードマクロのことではありません。

基本関数型

基本関数型（primitive function）は、 Lispから呼び出し可能な関数ですが、C言語で書いてあります。 基本関数のことをsubrとか 組み込み関数（built-in functions）とも呼びます。 （『subr』は『subroutine』からきている。） ほとんどの基本関数は、呼び出すときにすべての引数を評価します。 引数すべてを評価しない基本関数をスペシャルフォーム（special form）と 呼びます（see Special Forms）。

関数を呼び出す側からすれば、関数が基本関数かどうかは関係ありません。 しかし、Lispで書いた関数で基本関数を再定義しようとすると、 問題があります。 というのは、基本関数はCのコードから直接呼ばれるからです。 再定義した関数をLispから呼び出す場合には新しい定義を使いますが、 Cのコードは組み込みの定義を使い続けるでしょう。 したがって、基本関数を再定義しないでください。

関数（function）という用語で、 LispやCで書かれたEmacsのすべての関数を指します。 Lispで書いた関数に関しては、See Function Type。

基本関数には入力構文はなく、 サブルーティン名を含むハッシュ記法で表示します。

(symbol-function 'car)          ; シンボルの関数セルを参照する
     => #<subr car>
(subrp (symbol-function 'car))  ; 基本関数か？
     => t                       ; そのとおり

バイトコード関数型

バイトコンパイラは、バイトコード関数オブジェクト （byte-code function objects）を作り出します。 内部的には、バイトコード関数オブジェクトはベクトルによく似ています。 しかしながら、評価過程においては、関数呼び出しのように見えるときには、 このデータ型を特別に扱います。 バイトコンパイラについては、See Byte Compilation。

バイトコード関数オブジェクトの表示表現と入力構文は、 ベクトルに似ていますが、開き角括弧[のまえに#が付きます。

自動ロード型

自動ロードオブジェクト（autoload object）は、 先頭要素がシンボルautoloadであるリストです。 実際の定義のかわりにシンボルの関数定義として使われ、 必要なときにロードすべき実際の定義を収めたLispコードファイルを示します。 自動ロードオブジェクトには、ファイル名に加えて、 実際の関数定義に関する他の情報も入っています。

ファイルをロードし終えると、 シンボルには、自動ロードオブジェクトではない新たな関数定義が入ります。 この新たな定義を始めからあったかのように呼び出します。 ユーザーの視点からは、ロードしたファイル内の関数定義を使って、 予想どおりに関数呼び出しが行われます。

自動ロードオブジェクトは、普通、関数autoloadで作ります。 この関数は、シンボルの関数セルにオブジェクトを格納します。 より詳しくは、See Autoload。

編集向けの型

前節の型は一般のプログラム向けに使うもので、 そのほとんどは、ほんどのLisp方言に共通しています。 Emacs Lispには、編集に関連した目的向けにいくつかのデータ型があります。

• Buffer Type: The basic object of editing.
• Marker Type: A position in a buffer.
• Window Type: Buffers are displayed in windows.
• Frame Type: Windows subdivide frames.
• Window Configuration Type: Recording the way a frame is subdivided.
• Frame Configuration Type: Recording the status of all frames.
• Process Type: A process running on the underlying OS.
• Stream Type: Receive or send characters.
• Keymap Type: What function a keystroke invokes.
• Overlay Type: How an overlay is represented.

バッファ型

バッファ（buffer）は、編集可能なテキストを保持するオブジェクトです （see Buffers）。 ほとんどのバッファは、ディスクファイル（see Files）の内容を保持して 編集できるようにしますが、他の目的に使われるものもあります。 ほとんどのバッファは、ユーザーが見るためのものであり、 ある期間、ウィンドウ（see Windows）に表示されます。 しかし、バッファがいずれかのウィンドウに必ずしも表示される必要はありません。

バッファの内容は文字列によく似ていますが、 Emacs Lispにおいては、バッファは文字列のようには使われず、 適用可能な操作も異なります。 たとえば、既存のバッファにテキストを効率よく挿入できますが、 文字列にテキストを『挿入』するには、 部分文字列を連結する必要があり、まったく新しい文字列オブジェクトになります。

各バッファには、ポイント（point）と呼ばれる特別な箇所があります （see Positions）。 どんなときにも、1つのバッファがカレントバッファ（current buffer）です。 ほとんどの編集コマンドは、カレントバッファのポイント付近の内容に作用します。 多くのEmacsの標準関数は、カレントバッファ内にある文字を操作したり検査します。 本書には、これらの関数の説明にあてた章が1つあります（see Text）。

各バッファに関連付けられたデータ構造には、つぎのものがあります。

• ローカル構文テーブル（see Syntax Tables）
• ローカルキーマップ（see Keymaps）。 および
• バッファにローカルな変数束縛リスト（see Buffer-Local Variables）。
• オーバレイ（see Overlays）。
• バッファ内のテキストのテキスト属性（see Text Properties）。

ローカルキーマップと変数リストには、 それぞれ、グローバルな束縛や値に優先するものが入っています。 これらは、プログラムを変更せずに、各バッファごとに、 プログラムのふるまいをカスタマイズするために使われます。

バッファは間接（indirect）でもよく、その場合、 別のバッファとテキストを共有しつつ異なった表示を行えます。 See Indirect Buffers。

バッファには入力構文はありません。 バッファ名を含んだハッシュ記法で表示します。

(current-buffer)
     => #<buffer objects.texi>

マーカ型

マーカ（marker）は、特定のバッファ内の位置を表します。 したがって、マーカには2つの構成要素、つまり、 バッファを示すものと位置を示すものがあります。 バッファ内のテキストを変更すると、 マーカがバッファ内の同じ2つの文字のあいだをつねに指すことを保証するように、 位置の値を更新します。

マーカには入力構文はありません。 バッファ内の文字位置とバッファ名を含んだハッシュ記法で表示します。

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

マーカの検査、作成、コピー、移動の方法については、See Markers。

ウィンドウ型

ウィンドウ（window）は、 Emacsがバッファを表示するために使用する端末画面の部分のことです。 各ウィンドウには、対応付けられたバッファが1つあり、 そのバッファの内容をウィンドウに表示しています。 一方、あるバッファが、1つのウィンドウや複数のウィンドウに表示されることもあり、 どのウィンドウにも表示されないこともあります。

同時に複数のウィンドウが存在できますが、 どんなときにも1つのウィンドウだけが選択されたウィンドウ （selected window）です。 これは、Emacsがコマンドを受け付け可能なときにカーソルを（通常）表示する ウィンドウです。 選択されたウィンドウは、通常、カレントバッファを表示しますが、 これは必須ではありません。

画面上のウィンドウはフレームにまとめられています。 各ウィンドウは、たった1つのフレームに属します。 See Frame Type。

ウィンドウには入力構文はありません。 ウィンドウ番号と表示中のバッファ名を含んだハッシュ記法で表示します。 ウィンドウ番号は、ウィンドウを一意に識別するためにあります。 これは、ウィンドウが表示しているバッファは頻繁に変わるからです。

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

ウィンドウを操作する関数の説明は、See Windows。

フレーム型

フレーム（frame）は、画面上の矩形領域であって、 1つ以上のEmacsウィンドウを含みます。 フレームには最初は1つのウィンドウ （とミニバッファウィンドウ）が含まれますが、 これを左右や上下に小さなウィンドウに分割できます。

フレームには入力構文はありません。 フレームのタイトルとメモリ内のアドレス （フレームを一意に識別するのに有用）を含んだハッシュ記法で表示します。

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

フレームを操作する関数の説明は、See Frames。

ウィンドウ構成型

ウィンドウ構成（window configuration）は、 フレーム内のウィンドウの位置／サイズ／内容に関する情報を記録し、 同じ配置のウィンドウをあとで再度作成できるようにします。

ウィンドウ構成には入力構文はありません。 表示表現は、#<window-configuration>のようになります。 ウィンドウ構成に関連した関数の説明は、See Window Configurations。

フレーム構成型

フレーム構成（frame configuration）は、 すべてのフレームのウィンドウの位置／サイズ／内容に関する情報の記録です。 これは、実際には、リストのCARがframe-configurationであり、 リストのCDRが連想リストであるリストです。 連想リストの各要素で、そのCARに現れるフレーム1個を記述します。

フレーム構成に関連した関数の説明は、See Frame Configurations。

プロセス型

単語プロセス（process）は、通常、実行中のプログラムを意味します。 Emacs自身、この種のプロセスとして実行されています。 しかし、Emacs Lispでは、プロセスとは、 Emacsプロセスが作成したサブプロセスを表すLispオブジェクトのことです。 Emacsのサブプロセスで実行される、シェル、GDB、ftp、コンパイラなどの プログラムは、Emacsの能力を拡張します。

Emacsサブプロセスは、Emacsからテキスト入力を受け取り、 さらに処理できるようにEmacsにテキスト出力を返します。 Emacsはサブプロセスにシグナルを送ることもできます。

プロセスオブジェクトに入力構文はありません。 プロセス名を含んだハッシュ記法で表示します。

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

プロセスを作成したり削除したり、プロセスに関する情報を返したり、 プロセスへ入力やシグナルを送ったり、プロセスから出力を受け取る 関数に関する情報は、See Processes。

ストリーム型

ストリーム（stream）は、文字を出し入れする対象、 つまり、入力用に文字を供給したり、出力として文字を受け取ったりといった ことに使えるオブジェクトです。 多くの異なる型をこのように使えます。 マーカ、バッファ、文字列、関数です。 ほとんどの場合、入力ストリーム（文字の供給源）は、 キーボード、バッファ、ファイルから文字を取得します。 出力ストリーム（文字の消費先）は、*Help*バッファなどのバッファや エコー領域に文字を送ります。

オブジェクトnilは、他の意味に加えて、 ストリームとしても使えます。 変数standard-inputやstandard-outputの値になります。 また、オブジェクトtも、 ミニバッファ（see Minibuffers）を使う入力ストリームや エコー領域への出力（see The Echo Area）を意味します。

ストリームには表示形式も入力構文もなく、その基本型で表示します。

構文解析関数や表示関数を含むストリームに関連した関数の説明は、 See Read and Print。

キーマップ型

キーマップ（keymap）は、ユーザーが打ったキーをコマンドに対応付けます。 この対応付けは、ユーザーのコマンド入力をどのように実行するかを制御します。 キーマップは、実際には、リストであり、 そのCARはシンボルkeymapです。

キーマップの作成、プレフィックスキーの扱い方、 グローバルやローカルなキーマップ、キーバインディングの変更に関する情報は、 See Keymaps。

オーバレイ型

オーバレイ（overlay）は、バッファのある部分に作用する属性を指定します。 各オーバレイは、バッファの指定した範囲に作用し、 属性リスト（属性名と値の要素を交互に繰り返すリスト）を含んでいます。 オーバレイ属性は、 バッファの一部を一時的に異なった方式で表示するために使われます。 オーバレイ属性に入力構文はなく、 バッファ名と位置範囲を含んだハッシュ記法で表示します。

オーバレイの作成と使用法については、See Overlays。

型述語

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に加える
         (setq list (cons x list)))
        ((listp x)
         ;; Xがリストならば、その要素をLISTに追加する
         (setq list (append x list)))
        (t
         ;; シンボルとリストだけを扱う
         (error "Invalid argument %s in add-on" x))))

定義済みの型述語を、アルファベット順に、参照先を併記してあげておきます。

atom

see atom。

arrayp

see arrayp。

bool-vector-p

see bool-vector-p。

bufferp

see bufferp。

byte-code-function-p

see byte-code-function-p。

case-table-p

see case-table-p。

char-or-string-p

see char-or-string-p。

char-table-p

see char-table-p。

commandp

see commandp。

consp

see consp。

display-table-p

see display-table-p。

floatp

see floatp。

frame-configuration-p

see frame-configuration-p。

frame-live-p

see frame-live-p。

framep

see framep。

functionp

see functionp。

integer-or-marker-p

see integer-or-marker-p。

integerp

see integerp。

keymapp

see keymapp。

listp

see listp。

markerp

see markerp。

wholenump

see wholenump。

nlistp

see nlistp。

numberp

see numberp。

number-or-marker-p

see number-or-marker-p。

overlayp

see overlayp。

processp

see processp。

sequencep

see sequencep。

stringp

see stringp。

subrp

see subrp。

symbolp

see symbolp。

syntax-table-p

see syntax-table-p。

user-variable-p

see user-variable-p。

vectorp

see vectorp。

window-configuration-p

see window-configuration-p。

window-live-p

see window-live-p。

windowp

see windowp。

オブジェクトの型を調べるもっとも一般的な方法は、 関数type-ofを呼び出すことです。 各オブジェクトはたった1つの基本型に属することを思い出してください。 type-ofはどの1つかを教えてくれます（see Lisp Data Types）。 しかし、type-ofは、基本型以外についてはなにも知りません。 多くの場合、type-ofより型述語を使うほうが便利でしょう。

type-of object

Function

この関数は、objectの基本型を示すシンボルを返す。 その値は、 symbol、 integer、float、string、cons、vector、 char-table、bool-vector、subr、 compiled-function、marker、overlay、window、 buffer、frame、process、window-configurationの シンボルのうちの1つ。 (type-of 1) => integer (type-of 'nil) => symbol (type-of '()) ; ()はnil => symbol (type-of '(x)) => cons

同値述語

2つのオブジェクトの同値関係を調べる2つの関数を説明します。 文字列などの特定のオブジェクトが同値であるかを調べる関数群もあります。 これらの述語については、データ型を述べている適切な章を参照してください。

eq object1 object2

Function

この関数は、object1とobject2が 同一オブジェクトであればtを返し、さもなければnilを返す。 『同一オブジェクト』とは、 一方を変更すると、他方にも同じ変更が反映されることを意味する。 eqは、object1とobject2が同じ値の整数であると tを返す。 また、シンボル名は、普通、一意であるので、 引数が同じ名前のシンボルであれば、それらはeqである。 （リスト、ベクトル、文字列などの）それ以外の型の場合、 2つの引数が同じ内容や要素であっても、 互いにeqであるとは限らない。 それらが同一オブジェクトである場合に限りeqである。 (eq 'foo 'foo) => t (eq 456 456) => t (eq "asdf" "asdf") => nil (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は、インターンしたシンボルを返す。 このシンボルは、Lisp式に書いた同じ名前のシンボルと区別される。 名前が同じでも区別されるシンボルはeqではない。 see Creating Symbols。 (eq (make-symbol "foo") 'foo) => nil

equal object1 object2

Function

この関数は、 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 文字列の比較では大文字小文字を区別するが、テキスト属性は考慮しない。 つまり、文字列内の文字だけを比較する。 文字列の内容がすべてASCIIでなければ、 ユニバイト文字列とマルチバイト文字列が等しいことはない （see Text Representations）。 (equal "asdf" "ASDF") => nil たとえ内容が同じであっても、 異なる2つのバッファがequalであることはない。

equalの検査は再帰で実装されているので、 リストに循環があると無限再帰を引き起こし（エラーになり）ます。

数

GNU Emacsでは2種類の数値データを扱えます。 整数（integers）と浮動小数点数（floating point numbers）です。 整数は、-3、0、7、13、511のようなちょうどの数です。 これらの値は正確です。 浮動小数点数は、-4.5、0.0、2.71828のように小数部がある数です。 これらは指数表記で表します。 たとえば、1.5e2は150に等しいのです。 この例のe2は10の2乗を表し、それを1.5倍します。 浮動小数点数の値は厳密ではありません。 これらの精度には定まった限界があります。

• Integer Basics: Representation and range of integers.
• Float Basics: Representation and range of floating point.
• Predicates on Numbers: Testing for numbers.
• Comparison of Numbers: Equality and inequality predicates.
• Numeric Conversions: Converting float to integer and vice versa.
• Arithmetic Operations: How to add, subtract, multiply and divide.
• Rounding Operations: Explicitly rounding floating point numbers.
• Bitwise Operations: Logical and, or, not, shifting.
• Math Functions: Trig, exponential and logarithmic functions.
• Random Numbers: Obtaining random integers, predictable or not.

整数の基本

整数の値の範囲は計算機に依存します。 最小の範囲は、-134217728から134217727まで（28ビット長、つまり から これより広い範囲を扱える計算機もあります。 本章の多くの例題では、整数は28長ビットであると仮定します。

Lispリーダは、 先頭に符号があってもよく、最後にピリオドがあってもよい、 数字の列として整数を読み取ります。

 1               ; 整数1
 1.              ; 整数1
+1               ; これも整数1
-1               ; 整数-1
 268435457       ; 桁溢れのため、これも整数1
 0               ; 整数0
-0               ; 整数0

整数を扱うさまざまな関数を理解するには、 特にビット演算（see Bitwise Operations）を理解するには、 数を2進表現で考えるとよいです。

28ビット長の2進表現では、10進整数5はつぎのようになります。

0000  0000 0000  0000 0000  0000 0101

（4ビットのまとまりごとに空白を1個、 8ビットのまとまりごとに空白を2個挿入して、読みやすくする。）

整数-1はつぎのようになります。

1111  1111 1111  1111 1111  1111 1111

-1は、28個の1で表現されます。 （これを2の補数（two's complement）表記と呼ぶ。）

負の数-5は、-1から4を引いて作れます。 10進数4は、2進表記では100です。 したがって、-5は、つぎのようになります。

1111  1111 1111  1111 1111  1111 1011

この実装では、28ビット長の2進整数の最大値は、 10進で134,217,727になります。 2進表記では、つぎのようになります。

0111  1111 1111  1111 1111  1111 1111

算術関数は、整数がその範囲外に出たかどうか検査しないので、 134,217,727に1を足すと、値は負の数-134,217,728になります。

(+ 1 134217727)
     => -134217728
     => 1000  0000 0000  0000 0000  0000 0000

本章で述べる多くの関数は、数の引数としてマーカを受け付けます。 （see Markers）。 そのような関数の実際の引数は数かマーカであるので、 それらの引数をしばしばnumber-or-markerという名前で書きます。 引数の値がマーカであるときには、その位置の値を使いバッファは無視します。

浮動小数点数の基本

浮動小数点数は、整数ではない数を表現するのに便利です。 浮動小数点数の正確な範囲は計算機に依存します。 使用している計算機のC言語のデータ型doubleの範囲と同じです。

浮動小数点数の入力構文は、小数点（に続けて1桁以上の小数部）または指数、 あるいは、その両方が必要です。 たとえば、1500.0、15e2、15.0e2、 1.5e3、.15e4は、同じ1500という値の 浮動小数点数を書き表す5つの方法です。 どれも、まったく等価です。 負の浮動小数点数を書くには、-1.0のようにマイナス符号を使います。

現代の計算機はIEEEの浮動小数点数規格に基づいています。 この規格では、浮動小数点数の値には正の無限大と負の無限大があります。 また、NaNすなわち『非数値』（not-a-number）と呼ばれる値の種類もあります。 算術関数は、正しい答えがないときには、このような値を返します。 たとえば、(sqrt -1.0)はNaNを返します。 実用的には、Emacs Lispでは異なるNaNの値に重要な違いはなく、 特定の場面で正確にはどのNaNの値を使うかの規則もないので、 Emacs Lispではそれらを区別しようとはしません。 浮動小数点数の入力構文はつぎのとおりです。

正の無限大

1.0e+INF

負の無限大

-1.0e+INF

非数値

0.0e+NaN。

さらに、IEEEの浮動小数点数では値-0.0を普通のゼロと区別します （しかし、equalと=は、これらを等しい値と扱う）。

浮動小数点数の2進指数を取り出すには（あるいは、整数の対数を予測するには）、 logbを使います。

logb number

Function

この関数はnumberの2進指数を返す。 より正確には、その値はnumberの2を底とする対数を整数に切り下げたもの。 (logb 10) => 3 (logb 10.0e20) => 69

数向けの型述語

本節の関数は、引数が数であるか、とか、特定の種類の数であるか検査します。 関数integerpとfloatpは 引数として任意の型のLispオブジェクトを取ります （さもないと、述語の利用価値がない）。 しかし、述語zeropの引数には数が必要です。 Predicates on Markersの integer-or-marker-pとnumber-or-marker-pも 参照してください。

floatp object

Function

この述語は、引数が浮動小数点数かどうか調べ、 そうならばtを返し、さもなければnilを返す。 Emacs 18以前の版にはfloatpはない。

integerp object

Function

この述語は、引数が整数かどうか調べ、 そうならばtを返し、さもなければnilを返す。

numberp object

Function

この述語は、引数が数（整数か浮動小数点数）かどうか調べ、 そうならばtを返し、さもなければnilを返す。

wholenump object

Function

（『whole-number-p』からきている名前の）述語wholenumpは、 引数が非負整数かどうか調べ、 そうならばtを返し、さもなければnilを返す。 0は非負整数として扱う。 natnumpは、wholenumpの廃れた同義語。

zerop number

Function

この述語は、引数が0かどうか調べ、 そうならばtを返し、さもなければnilを返す。 引数は数であること。 つぎの2つのフォームは等価。 (zerop x) == (= x 0)。

数の比較

2つの数が数値的に等しいかどうか調べるには、普通、 eqではなく=を使うべきです。 数値的には等しい多くの異なる浮動小数点数が存在しえます。 それらの比較にeqを使うと、 2つの値が同一オブジェクトかどうか調べることになります。 対照的に、=はオブジェクトの数値だけを比較します。

現時点では、Emacs Lispにおいて、各整数値は一意なLispオブジェクトです。 したがって、整数に限ればeqは=と等価です。 未知の値と整数を比較するためにeqを使うと便利な場面があります。 というのは、eqは任意の型の引数を受け付けるので、 eqは未知の値が数でなくてもエラーを報告しないからです。 対照的に、=は、引数が数やマーカでないと、エラーを通知します。 しかしながら、Emacsの将来の版で整数の表現方法を変更する場合に備えて、 整数を比較するときであっても、可能ならば、=を使うほうがよいでしょう。

equalで数を比較したほうが便利なこともあります。 equalは、2つの数が同じデータ型 （どちらも整数であるか、どちらも浮動小数点数である）で、 同じ値であれば、2つの数を等しいと扱います。 一方、=は、整数と浮動小数点数が等しいことを扱えます。

別のことがらもあります。 浮動小数点数演算は厳密ではないので、 2つの浮動小数点数が等しいかどうか調べるのは正しくありません。 普通、近似的に等しいことを調べるほうがよいのです。 つぎの関数はそのようにします。

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

Common Lispに関した注意： Common Lispでは、数の比較にはつねに=を使う必要がある。 というのは、Common Lispでは複数ワードの整数を実装しているため、 2つの異なる整数オブジェクトが同じ数値を表すことがありえる。 Emacs Lispでは、整数値の範囲が制限されているため、 任意の値の整数オブジェクトはそれぞれ1つしかない。

= number-or-marker1 number-or-marker2

Function

この関数は、引数が数値的に等しいか調べ、 そうならばtを返し、さもなければnilを返す。

/= number-or-marker1 number-or-marker2

Function

この関数は、引数が数値的に等しいか調べ、 等しくなければtを返し、等しければnilを返す。

< number-or-marker1 number-or-marker2

Function

この関数は、第1引数が第2引数より小さいか調べ、 そうならばtを返し、さもなければnilを返す。

<= number-or-marker1 number-or-marker2

Function

この関数は、第1引数が第2引数より小さいか、あるいは、等しいか調べ、 そうならばtを返し、さもなければnilを返す。

> number-or-marker1 number-or-marker2

Function

この関数は、第1引数が第2引数より大きいか調べ、 そうならばtを返し、さもなければnilを返す。

>= number-or-marker1 number-or-marker2

Function

この関数は、第1引数が第2引数より大きいか、あるいは、等しいか調べ、 そうならばtを返し、さもなければnilを返す。

max number-or-marker &rest numbers-or-markers

Function

この関数は、引数の中で最大のものを返す。 (max 20) => 20 (max 1 2.5) => 2.5 (max 1 3 2.5) => 3

min number-or-marker &rest numbers-or-markers

Function

この関数は、引数の中で最小のものを返す。 (min -4 1) => -4

abs number

Function

この関数は、numberの絶対値を返す。

数の変換

整数を浮動小数点数に変換するには、 関数floatを使います。

float number

Function

この関数は、浮動小数点数に変換したnumberを返す。 numberがすでに浮動小数点数ならば、 floatはnumberを変更せずに返す。

浮動小数点数を整数に変換する関数は4つあります。 これらの関数は、整数も引数に取りますが、整数引数は変更せずに返します。

truncate number

Function

これは、0に向けて切り捨てて整数に変換したnumberを返す。

floor number &optional divisor

Function

これは、（負の無限大に向けて）切り下げて整数に変換したnumberを返す。 divisorを指定すると、切り下げるまえに numberをdivisorで除算する。 これには、modに対応した除算を使い切り下げる。 divisorが0であると、結果はarith-errorになる。

ceiling number

Function

これは、（正の無限大に向けて）切り上げて整数に変換したnumberを返す。

round number

Function

これは、もっとも近い整数に丸めて整数に変換したnumberを返す。 2つの整数に等距離にある値を丸める場合には、 使用している計算機に依存して、ゼロに近いほうの整数を選ぶか偶数を選ぶ。

算術演算

Emacs Lispには、伝統的な四則演算、加算、減算、乗算、除算があります。 除算関数を補う、余りと剰余の関数もあります。 Lispの伝統でもあり、また、多用するので、1を加算したり減算する関数もあります。

これらの関数は、%を除いて、引数が1つでも浮動小数点数であると、 浮動小数点数を返します。

Emacs Lispでは、算術関数は桁溢れ（オーバフロー）を検査しないことに 注意してください。 つまり、読者の計算機に依存しますが、 (1+ 134217727)を評価すると-134217728になる場合もあります。

1+ number-or-marker

Function

この関数は、number-or-marker足す1を返す。 (setq foo 4) => 4 (1+ foo) => 5 この関数はC言語の演算子++の類似ではない。 つまり、変数を増加しない。 したがって、つぎのようになる。 foo => 4 変数を増加するには、つぎのようにsetqを使う必要がある。 (setq foo (1+ foo)) => 5

1- number-or-marker

Function

この関数は、number-or-marker引く1を返す。

+ &rest numbers-or-markers

Function

この関数は、引数をすべて加算する。 引数を指定しないと+は0を返す。 (+) => 0 (+ 1) => 1 (+ 1 2 3 4) => 10

- &optional number-or-marker &rest more-numbers-or-markers

Function

関数-は、2つの役割、つまり、符号反転と減算を果たす。 -に1つの引数を指定すると、 その値は、引数の符号を反転したものである。 複数個の引数を指定すると、-は、 number-or-markerからmore-numbers-or-markersの1つ1つを減算する。 引数を指定しないと結果は0である。 (- 10 1 2 3 4) => 0 (- 10) => -10 (-) => 0

* &rest numbers-or-markers

Function

この関数は、引数をすべて掛け合わせた乗算結果を返す。 引数を指定しないと*は1を返す。 (*) => 1 (* 1) => 1 (* 1 2 3 4) => 24

/ dividend divisor &rest divisors

Function

この関数は、dividendをdivisorで除し商を返す。 追加の引数divisorsを指定してあると、 dividendをdivisorsの1つ1つで除す。 各引数は数かマーカである。 すべての引数が整数である場合、結果も整数となる。 つまり、結果は切り捨てになる。 ほとんどの計算機では各除算の結果は0に向けて切り捨てになるが、 負の引数を別の方法で丸める計算機もある。 これは、Lisp関数/をC言語の除算演算子で実装しているからであり、 C言語の除算演算子では計算機依存に丸めることを許しているからである。 実用上、すべての既知の計算機は標準的な方法で丸める。 整数を0で除算すると、エラーarith-errorを通知する。 （see Errors。） 浮動小数点数を0で除算すると、IEEE浮動小数点数を使う計算機では、 無限大かNaNを返す。 さもなければエラーarith-errorを通知する。 (/ 6 2) => 3 (/ 5 2) => 2 (/ 5.0 2) => 2.5 (/ 5 2.0) => 2.5 (/ 5.0 2.0) => 2.5 (/ 25 3 2) => 4 (/ -17 6) => -2 原理的には、(/ -17 6)が-3になる計算機もある。

% dividend divisor

Function

この関数は、dividendをdivisorで除したあとの整数の余りを返す。 引数は整数かマーカである必要がある。 負の引数では、余りは原理的に計算機依存である。 実用上、すべての既知の計算機は同じようにふるまう。 divisorが0であるとarith-errorになる。 (% 9 4) => 1 (% -9 4) => -1 (% 9 -4) => 1 (% -9 -4) => -1 2つの任意の整数dividendとdivisorにおいて、 (+ (% dividend divisor) (* (/ dividend divisor) divisor)) は、つねにdividendに等しい。

mod dividend divisor

Function

この関数は、dividendのdivisorによる剰余を返す。 いいかえれば、dividendをdivisorで除した余りを返す。 ただし、その符号はdivisorと同じ。 引数は数かマーカである必要がある。 %と違い、 modは負の引数に対しても厳密に定義された結果を返す。 浮動小数点の引数も許す。 商を（負の無限大に向けて）切り下げて整数にし、 その商を用いて余りを計算する。 divisorが0であるとarith-errorになる。 (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に等しい。 ただし、どちらかの引数が浮動小数点数の場合には、 丸め誤差の範囲内で等しい。 floorについては、Numeric Conversionsを参照。

丸め演算

関数、ffloor、fceiling、fround、ftruncateは、 浮動小数点数引数を受け取り、その値に近い整数を値とする浮動小数点数を返します。 ffloorは、もっとも近いより小さな整数を返します。 fceilingは、もっとも近いより大きな整数を返します。 ftruncateは、0に向けて切り捨てたもっとも近い整数を返します。 froundは、もっとも近い整数を返します。

ffloor float

Function

この関数は、floatをこれより小さな整数値に切り下げ、 その値を浮動小数点数として返す。

fceiling float

Function

この関数は、floatをこれより大きな整数値に切り上げ、 その値を浮動小数点数として返す。

ftruncate float

Function

この関数は、floatを0に向けて整数値に切り捨て、 その値を浮動小数点数として返す。

fround float

Function

この関数は、floatをもっとも近い整数値に丸め、 その値を浮動小数点数として返す。

整数のビット演算

計算機内部では、整数は2進数、つまり、 ビット（bit、各桁は0か1）列で表現されます。 ビット演算は、そのようなビット列の各ビットごとに作用します。 たとえば、シフト（shifting）は、ビット列を全体として左や右に 1桁以上移動して、その『移動後の』パターンを結果とします。

Emacs Lispにおけるビット演算は整数に限ります。

lsh integer1 count

Function

論理シフト（logical shift）の略からきているlshは、 integer1のビット列をcount桁左へ、 あるいは、countが負ならば右へずらし、空いたビットには0を詰める。 countが負であれば、lshは最左（最上位）ビットに0を詰め、 integer1が負であっても結果は正になる。 これと対照的なのが下のash。 lshの例を2つ示す。 ビットパターンを1桁左へずらす。 ビットパターンの上位ビットはすべて0なので下位8ビットだけを示す。 (lsh 5 1) => 10 ;; 10進数5は、 10進数10になる 00000101 => 00001010 (lsh 7 1) => 14 ;; 10進数7は、10進数14になる 00000111 => 00001110 例からわかるように、ビットパターンを1桁左へずらすと、 もとの数値の2倍の数になる。 ビットパターンを2桁左へずらすと、（8ビット長の2進数では）つぎのようになる。 (lsh 3 2) => 12 ;; 10進数3は、10進数12になる 00000011 => 00001100 一方、右へずらすとつぎのようになる。 (lsh 6 -1) => 3 ;; 10進数6は、10進数3になる 00000110 => 00000011 (lsh 5 -1) => 2 ;; 10進数5は、10進数2になる 00000101 => 00000010 例からわかるように、ビットパターンを1桁右へずらすと、 正の整数の数を2で除して切り下げる。 Emacs Lispのすべての算術関数と同様に、 関数lshは桁溢れ（オーバフロー）を検査しないので、 左へずらすと上位ビットを捨てさり数の符号を変えてしまうことがある。 たとえば、28ビット長の計算機では、 134,217,727を左へずらすと-2になる。 (lsh 134217727 1) ; 左シフト => -2 28ビット長の実装の2進数では、引数はつぎのようになっている。 ;; 10進数134,217,727 0111 1111 1111 1111 1111 1111 1111 これを左へずらすと、つぎのようになる ;; 10進数-2 1111 1111 1111 1111 1111 1111 1110

ash integer1 count

Function

ash（算術シフト（arithmetic shift））は、 integer1のビットをcount桁左へ、あるいは、 countが負ならば右へずらす。 ashはlshと同じ結果になるが、 integer1とcountの両者が負の場合を除く。 この場合、ashは左の空いたビットには1を入れるが、 lshはそのようなビットには0を入れる。 したがって、ashでビットパターンを1桁右へずらすとつぎのようになる。 (ash -6 -1) => -3 ;; 10進数-6は、10進数-3になる 1111 1111 1111 1111 1111 1111 1010 => 1111 1111 1111 1111 1111 1111 1101 対照的に、lshでビットパターンを1桁右へずらすとつぎのようになる。 (lsh -6 -1) => 134217725 ;; 10進数-6は、10進数134,217,725になる 1111 1111 1111 1111 1111 1111 1010 => 0111 1111 1111 1111 1111 1111 1101 他の例を以下にしめす。 ; 28ビット2進値 (lsh 5 2) ; 5 = 0000 0000 0000 0000 0000 0000 0101 => 20 ; = 0000 0000 0000 0000 0000 0001 0100 (ash 5 2) => 20 (lsh -5 2) ; -5 = 1111 1111 1111 1111 1111 1111 1011 => -20 ; = 1111 1111 1111 1111 1111 1110 1100 (ash -5 2) => -20 (lsh 5 -2) ; 5 = 0000 0000 0000 0000 0000 0000 0101 => 1 ; = 0000 0000 0000 0000 0000 0000 0001 (ash 5 -2) => 1 (lsh -5 -2) ; -5 = 1111 1111 1111 1111 1111 1111 1011 => 4194302 ; = 0011 1111 1111 1111 1111 1111 1110 (ash -5 -2) ; -5 = 1111 1111 1111 1111 1111 1111 1011 => -2 ; = 1111 1111 1111 1111 1111 1111 1110

logand &rest ints-or-markers

Function

この関数は引数の『論理積』を返す。 つまり、すべての引数のn番目のビットが1である場合に限り、 結果のn番目のビットも1になる。 たとえば、4ビットの2進数で考えると、 13と12の『論理積』は12になる。 つまり、1101に1100を組み合わせると1100になる。 どちらの2進数も最左の2ビットは1なので、戻り値の最左の2ビットも1になる。 しかし、最右の2ビットは、一方の引数ではそれぞれが0なので、 戻り値の最右の2ビットも0になる。 したがって、つぎのとおり。 (logand 13 12) => 12 logandにまったく引数を指定しないと値-1を返す。 この数は2進表現ではすべて1だけなので、 logandの恒等元である。 logandに引数を1つだけ指定するとその引数を返す。 ; 28ビット2進値 (logand 14 13) ; 14 = 0000 0000 0000 0000 0000 0000 1110 ; 13 = 0000 0000 0000 0000 0000 0000 1101 => 12 ; 12 = 0000 0000 0000 0000 0000 0000 1100 (logand 14 13 4) ; 14 = 0000 0000 0000 0000 0000 0000 1110 ; 13 = 0000 0000 0000 0000 0000 0000 1101 ; 4 = 0000 0000 0000 0000 0000 0000 0100 => 4 ; 4 = 0000 0000 0000 0000 0000 0000 0100 (logand) => -1 ; -1 = 1111 1111 1111 1111 1111 1111 1111

logior &rest ints-or-markers

Function

この関数は引数の『論理和』を返す。 つまり、少なくともどれか1つの引数のn番目のビットが1である場合に限り、 結果のn番目のビットも1になる。 引数を指定しないと0を返すが、これはこの演算の恒等元である。 logiorに引数を1つだけ指定するとその引数を返す。 ; 28ビット2進値 (logior 12 5) ; 12 = 0000 0000 0000 0000 0000 0000 1100 ; 5 = 0000 0000 0000 0000 0000 0000 0101 => 13 ; 13 = 0000 0000 0000 0000 0000 0000 1101 (logior 12 5 7) ; 12 = 0000 0000 0000 0000 0000 0000 1100 ; 5 = 0000 0000 0000 0000 0000 0000 0101 ; 7 = 0000 0000 0000 0000 0000 0000 0111 => 15 ; 15 = 0000 0000 0000 0000 0000 0000 1111

logxor &rest ints-or-markers

Function

この関数は引数の『排他的論理和』を返す。 つまり、引数のn番目のビットが1であるものが奇数個の場合に限り、 結果のn番目のビットも1になる。 引数を指定しないと0を返すが、これはこの演算の恒等元である。 logxorに引数を1つだけ指定するとその引数を返す。 ; 28ビット2進値 (logxor 12 5) ; 12 = 0000 0000 0000 0000 0000 0000 1100 ; 5 = 0000 0000 0000 0000 0000 0000 0101 => 9 ; 9 = 0000 0000 0000 0000 0000 0000 1001 (logxor 12 5 7) ; 12 = 0000 0000 0000 0000 0000 0000 1100 ; 5 = 0000 0000 0000 0000 0000 0000 0101 ; 7 = 0000 0000 0000 0000 0000 0000 0111 => 14 ; 14 = 0000 0000 0000 0000 0000 0000 1110

lognot integer

Function

この関数は引数の論理的な補数を返す。 つまり、integerのn番目のビットが0である場合に限り、 結果のn番目のビットは1になる。 (lognot 5) => -6 ;; 5 = 0000 0000 0000 0000 0000 0000 0101 ;; becomes ;; -6 = 1111 1111 1111 1111 1111 1111 1010

標準数学関数

これらの数学関数は浮動小数点数に加えて整数も引数として受け付けます。

sin arg	Function
cos arg	Function
tan arg	Function

これらは普通の三角関数であり、引数は弧度法で表す。

asin arg

Function

(asin arg)の値は-pi/2からpi/2までの数であり、 その正弦（sin）はargに等しい。 しかし、argが（[-1, 1]の）範囲を越えていると結果はNaN。

acos arg

Function

(acos arg)の値は0からpiまでの数であり、 その余弦（cos）はargに等しい。 しかし、argが（[-1, 1]の）範囲を越えていると結果はNaN。

atan arg

Function

(atan arg)の値は-pi/2からpi/2までの数であり、 その正接（tan）はargに等しい。

exp arg

Function

これは指数関数であり、 のarg乗を返す。 は数学の基本定数であり、自然対数の底とも呼ぶ。

log arg &optional base

Function

この関数はargのbaseを底とする対数を返す。 baseを指定しなければ、底として を使う。 argが負であると結果はNaN。

log10 arg

Function

この関数はargの10を底とする対数を返す。 argが負であると結果はNaN。 少なくとも誤差を考慮すれば、 (log10 x) == (log x 10)。

expt x y

Function

この関数はxのy乗を返す。 どちらの引数も整数でありyが正ならば、結果は整数。 この場合、結果は整数値の可能な範囲に切り詰められる。

sqrt arg

Function

この関数はargの平方根を返す。 argが負であると値はNaN。

乱数

決定論的な計算機プログラムは真の乱数を発生できません。 しかし、ほとんどの目的には疑似乱数（pseudo-random numbers）で十分です。 一連の疑似乱数を決定論的な方法で生成します。 それらの数は真の乱数ではありませんが、 乱数列のある種の性質に似た性質があります。 たとえば、疑似乱数列でもすべての可能な数がしばしば等しく生起します。

Emacsでは、疑似乱数は『種』となる数から生成します。 指定した任意の種から始めても、関数randomは同じ数の列を生成します。 Emacsはつねに同じ種の値で計算し始めるため、 それぞれのEmacsの実行でもrandomは実際には同じ数の列を生成します。 たとえば、あるオペレーティングシステムで、 Emacs開始直後にrandomを呼ぶとつねに-1457731を返し、 つぎに呼ぶとつねに-7692030を返します。 このような再現性はデバッグには有利です。

予測不可能な乱数が必要ならば(random t)を実行します。 これは、現在時刻とEmacsプロセスのID番号に基づいて、 新たな種の値を選びます。

random &optional limit

Function

この関数は疑似乱数の整数を返す。 繰り返し呼び出すと一連の疑似乱数の整数を返す。 limitが正整数ならば、非負でlimit未満になるように値を選ぶ。 limitがtならば、 現在時刻とEmacsプロセスのID番号に基づいて、 新たな種の値を選ぶことを意味する。 randomの結果は、Lispにおいて表現可能な任意の整数になる計算機もある。 他の計算機では、結果はある最大値と（負数）最小値のあいだにある。

文字列と文字

Emacs Lispの文字列は文字の順序列を保持している配列です。 文字列は、シンボル、バッファ、ファイルのそれぞれの名前として、 ユーザーへメッセージを送るため、 バッファ間でコピーするテキストを保持するため、 その他さまざまな目的に使われます。 文字列はとても重要なので、 Emacs Lispには文字列を操作する関数が数多くあります。 Emacs Lispのプログラムでは、個々の文字よりも文字列を多用します。

キーボード文字イベントを表す文字列に関する特別な配慮については、 See Strings of Events。

• Basics: Basic properties of strings and characters.
• Predicates for Strings: Testing whether an object is a string or char.
• Creating Strings: Functions to allocate new strings.
• Modifying Strings: Altering the contents of an existing string.
• Text Comparison: Comparing characters or strings.
• String Conversion: Converting characters or strings and vice versa.
• Formatting Strings: format: Emacs's analogue of printf.
• Case Conversion: Case conversion functions.
• Case Tables: Customizing case conversion.

文字列と文字の基本

Emacs Lispの文字列は文字の順序列を保持している配列です。 Emacs Lispでは文字を整数で表現します。 整数が文字であるかどうかは、その使われ方からしか判断できません。 したがって、文字列は、実際には、整数群を保持しているのです。

（任意の配列と同様に）文字列の長さは固定されていて、 文字列をいったん作成すると変更できません。 Lispの文字列は特別な文字コードで終端されるのではありません。 （対照的に、C言語の文字列はASCIIコード0で終端される。）

文字列は配列ですからシーケンスでもあり、 一般の配列関数やシーケンス関数で文字列を操作できます。 （see Sequences Arrays Vectors。） たとえば、関数arefとaset（see Array Functions）を 用いて、文字列内の個々の文字を参照したり変更できます。

Emacs文字列（およびバッファ）内の非ASCII文字のテキスト表現は 2種類あります。 ユニバイトとマルチバイトです（see Text Representations）。 ASCII文字は、文字列内ではつねに1バイトを占めます。 実際、すべてがASCII文字である文字列では、2つの表現に違いはありません。 ほとんどのLispプログラムでは、 読者はこれらの2つの表現を考慮する必要はないでしょう。

キー列を文字列として表現することがあります。 文字列がキー列を表す場合、128から255の範囲にある文字列の要素は、 その範囲の文字コードとしてではなく、 （非常に大きな整数になる）メタ文字を表現します。

文字列は、ハイパー、スーパー、アルトの修飾子を持つ文字を保持できません。 文字列はASCIIコントロール文字を保持できますが、 それ以外のコントロール文字を保持できません。 文字列では、ASCIIコントロール文字の大文字小文字を区別できません。 キー列などのそのような文字をシーケンスに収めるには、 文字列のかわりにベクトルを使う必要があります。 キーボード入力文字に対するメタなどの修飾子の表現については、 See Character Type。

文字列は正規表現を保持するのにも便利です。 文字列に対して正規表現の一致を取ることもできます（see Regexp Search）。 関数match-string（see Simple Match Data）と replace-match（see Replacing Match）は、 正規表現の一致に基づいて文字列を分解したり変更するのに便利です。

バッファと同様に、文字列は、 文字そのものに加えて文字列内の文字に対するテキスト属性を保持できます。 See Text Properties。 文字列からバッファや他の文字列へテキストをコピーするすべてのLisp基本関数は、 コピーする文字の属性もコピーします。

文字列を表示したりバッファへコピーする関数については、See Text。 文字と文字列の構文については、Character TypeとSee String Type。 テキスト表現を変換したり、文字コードを符号化／復号化する関数については、 See Non-ASCII Characters。

文字列向けの述語

一般のシーケンスや配列に対する述語について詳しくは、 Sequences Arrays VectorsとSee Arrays。

stringp object

Function

この関数は、objectが文字列ならばtを返し、 さもなければnilを返す。

char-or-string-p object

Function

この関数は、objectが文字列か文字（つまり、整数）ならば tを返し、さもなければnilを返す。

文字列の作成

以下の関数は、新たに文字列を作成したり、 文字列を連結したり分解して文字列を作成します。

make-string count character

Function

この関数は、文字characterをcount回繰り返して作成した文字列を返す。 countが負であるとエラーを通知する。 (make-string 5 ?x) => "xxxxx" (make-string 0 ?x) => "" この関数に対比するものに、 char-to-string（see String Conversion）、 make-vector（see Vectors）、 make-list（see Building Lists）などがある。

string &rest characters

Function

これは、複数個の文字群charactersが入った文字列を返す。 (string ?a ?b ?c) => "abc"

substring string start &optional end

Function

この関数は、stringのstartから end（の直前）までの範囲にある文字から成る新たな文字列を返す。 先頭の文字を0で添字付けする。 (substring "abcdefg" 0 3) => "abc" ここで、aの添字は0、bの添字は1、cの添字は2である。 したがって、文字列"abcdefg"から3文字abcをコピーする。 添字3はコピーする部分文字列の境界の文字位置を表す。 添字が3である文字は、実際には文字列内の4番目の文字である。 負の数は文字列の末尾から数える。 したがって、-1は文字列の最後の文字の添字である。 たとえば、 (substring "abcdefg" -3 -1) => "ef" この例では、eの添字は-3、fの添字は-2、 gの添字は-1である。 したがって、eとfを含むがgは含まない。 添字にnilを使うと、文字列の長さを意味する。 したがって、つぎのようになる。 (substring "abcdefg" -3 nil) => "efg" 引数endを省略することは、nilを指定することと等価である。 そのため、(substring string 0)は、 string全体をコピーしたものを返す。 (substring "abcdefg" 0) => "abcdefg" しかし、このような目的にはcopy-sequenceを勧める （see Sequence Functions）。 stringからコピーした文字にテキスト属性があれば、 新たな文字列にもそのテキスト属性をコピーする。 see Text Properties。 substringは第1引数としてベクトルも受け付ける。 たとえば、つぎのとおり。 (substring [a b (c) "d"] 1 3) => [b (c)] startやendが整数でもnilでもないと、 エラーwrong-type-argumentを通知する。 startがendよりうしろの文字を指していたり、 いずれかの整数がstringの範囲外であると エラーargs-out-of-rangeを通知する。 この関数と対照的なのがbuffer-substring （see Buffer Contents）であり、 カレントバッファ内のテキストの一部を収めた文字列を返す。 文字列の先頭は0で添字付けするが、バッファの先頭は1で添字付けする。

concat &rest sequences

Function

この関数は、渡した引数の文字から成る （テキスト属性があればそれも含めて）新たな文字列を返す。 引数は、文字列、数のリスト、数のベクトルである。 引数自身は変更しない。 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) => "" 関数concatは、 既存の文字列とeqではない新たな文字列をつねに作り出す。 引数が（整数のシーケンスではなく）整数であると、 その整数の表示表現を構成する文字列に変換する。 この機能を使わないでほしい。 削除する予定である。 読者がこの機能を使っていたら、今すぐプログラムを直すこと！ 整数をこのような10進数に変換する正しい方法は、 format（see Formatting Strings）や number-to-string（see String Conversion）を使うことである。 (concat 137) => "137" (concat 54 321) => "54321" 他の連結関数については、 Mapping Functionsのmapconcat、 Vectorsのvconcat、 Building Listsのappendを参照。

split-string string separators

Function

stringを正規表現separatorsの一致箇所で区切って 部分文字列に分解する。 separatorsに一致するそれぞれの部分が分割箇所を定義する。 分割箇所のあいだにある部分文字列をリストにまとめ、これを値とする。 separatorsがnilである（つまり、省略する）と、 デフォルトは"[ \f\t\n\r\v]+"である。 たとえば、つぎのようになる。 (split-string "Soup is good food" "o") => ("S" "up is g" "" "d f" "" "d") (split-string "Soup is good food" "o+") => ("S" "up is g" "d f" "d") 文字列の先頭や末尾で一致した場合には、 リストの先頭や末尾に空文字列は現れない。 (split-string "out to moo" "o+") => ("ut t" " m") 空の一致箇所は、それらが連続していない限り分割点になる。 (split-string "Soup is good food" "o*") =>("S" "u" "p" " " "i" "s" " " "g" "d" " " "f" "d") (split-string "Nice doggy!" "") =>("N" "i" "c" "e" " " "d" "o" "g" "g" "y" "!")

文字列の変更

既存の文字列の内容を変更するもっとも基本的な方法は、 aset（see Array Functions）を使うことです。 (aset string idx char)は、 stringの添字idx位置にcharを格納します。 各文字は1バイト以上を占めます。 charが必要とするバイト数が指定した添字位置の文字が占めるバイト数と 異なる場合には、asetはエラーを通知します。

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

store-substring string idx obj

Function

この関数は、文字列stringの添字idx位置から始まる部分にobjを 格納することで、文字列stringの内容の一部分を変更する。 引数objは文字であるか（より小さな）文字列。 既存の文字列の長さを変更することは不可能なので、 新たな文字に必要なバイト数がstringの当該箇所の文字のバイト数と 異なるなどして、 objがstringの実際の長さに収まらないときにはエラーである。

文字と文字列の比較

char-equal character1 character2

Function

この関数は、引数が同じ文字を表していればtを返し、 さもなければnilを返す。 case-fold-searchがnil以外であると、 この関数は大文字小文字の違いを区別しない。 (char-equal ?x ?x) => t (let ((case-fold-search nil)) (char-equal ?x ?X)) => nil

string= string1 string2

Function

この関数は、2つの文字列の各文字が正確に一致すればtを返す。 大文字小文字を区別する。 (string= "abc" "abc") => t (string= "abc" "ABC") => nil (string= "ab" "ABC") => nil 関数string=は2つの文字列のテキスト属性を無視する。 equal（see Equality Predicates）が2つの文字列を比較する際には、 string=を使う。 文字列に非ASCII文字が含まれ、 一方がユニバイトであり他方がマルチバイトである場合、 それらが等しいことはない。 see Text Representations。

string-equal string1 string2

Function

string-equalはstring=の別名。

string< string1 string2

Function

この関数は2つの文字列を1文字ずつ比較する。 まず、文字列を走査し、対応する文字同士の対で一致しないものを探す。 そのような対の文字の小さいほうがstring1の文字であるならば、 string1が小さく、この関数はtを返す。 文字の小さいほうがstring2の文字であるならば、 string1が大きく、この関数はnilを返す。 2つの文字列が完全に一致する場合、値はnilである。 文字の対は、それらの文字コードで比較する。 ASCII文字集合では、小文字は大文字より大きな数値であり、 数字文字や多くの句読点文字は大文字より小さな数値であることに注意。 ASCII文字はどんな非ASCII文字よりも小さい。 ユニバイト非ASCII文字はマルチバイト非ASCII文字よりもつねに小さい。 （see Text Representations）。 (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

string-lessp string1 string2

Function

string-lesspはstring<の別名。

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

Function

この関数は、string1の指定部分とstring2の指定部分を比較する。 string1の指定部分は、 添字start1位置から始まり添字end1位置までである （デフォルトは文字列の末尾）。 string2の指定部分は、 添字start2位置から始まり添字end2位置までである （デフォルトは文字列の末尾）。 どちらの文字列も比較のためにマルチバイトに変換するので （see Text Representations）、 ユニバイト文字列とマルチバイトが等しくなる場合もある。 ignore-caseがnilでなければ、大文字小文字を区別しないので、 大文字は小文字に等しくなる 2つの文字列の指定部分が一致すれば、値はt。 さもなければ、値は何文字目までが一致してどちらの文字列が小さいかを示す。 その絶対値は、2つの文字列の始めから一致した文字の個数に1を加えたもの。 string1（の指定部分）が小さいならば符号は負になる。

assoc-ignore-case key alist

Function

この関数は、assocと同様に動作するが、 keyは文字列である必要があり、 compare-stringsを用いて比較する点が異なる。 大文字小文字を区別しないで比較する。

assoc-ignore-representation key alist

Function

この関数は、assocと同様に動作するが、 keyは文字列である必要があり、 compare-stringsを用いて比較する点が異なる。 大文字小文字を区別して比較する。

バッファ内のテキストを比較する Comparing Textのcompare-buffer-substringsも参照してください。 文字列に対して正規表現の一致を取る関数string-matchは、 ある種の文字列比較に使えます。 See Regexp Search。

文字と文字列の変換

本節では、文字や文字列と整数のあいだの変換関数について説明します。 formatとprin1-to-string（see Output Functions）は、 Lispオブジェクトを文字列に変換するために使えます。 read-from-string（see Input Functions）は、 Lispオブジェクトの文字列表現をオブジェクトに『変換』できます。 関数string-make-multibyteとstring-make-unibyteは、 文字列のテキスト表現を変換します（see Converting Representations）。

テキスト文字と一般の入力イベントのテキスト表現を生成する関数 （single-key-descriptionとtext-char-description）については、 See Documentation。 これらの関数は、主に、ヘルプメッセージの作成に使います。

char-to-string character

Function

この関数は、1つの文字characterだけを含む新たな文字列を返す。 関数stringのほうがより汎用であるので、 この関数はほぼ廃れている。 see Creating Strings。

string-to-char string

Function

この関数は、stringの先頭文字を返す。 文字列が空であると関数は0を返す。 文字列stringの先頭文字が、ASCIIコードが0のナル文字であるときも、 値は0である。 (string-to-char "ABC") => 65 (string-to-char "xyz") => 120 (string-to-char "") => 0 (string-to-char "\000") => 0 この関数は、存続させるほど有用でなければ、将来、取り除くかもしれない。

number-to-string number

Function

この関数は、numberの表示表現である文字列を返す。 numberは整数か浮動小数点数。 引数が負であれば値の文字列は符号で始まる。 (number-to-string 256) => "256" (number-to-string -23) => "-23" (number-to-string -23.5) => "-23.5" int-to-stringは、この関数のほぼ廃れている別名。 Formatting Stringsのformatも参照。

string-to-number string &optional base

Function

この関数は、string内の文字群が表す数値を返す。 baseがnil以外ならば、これを基数として整数に変換する。 baseがnilならば10を基数とする。 浮動小数点数の変換はつねに10を基数とする。 浮動小数点数に対しては別の基数を実装していない。 作業量も多くそのわりには有用とも思えないからである。 解析するとき、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-intはこの関数の廃れた別名。

文字列へ／から変換するその他の関数を以下にあげておきます。

concat

concatは、ベクトルやリストを文字列へ変換する。 see Creating Strings。

vconcat

vconcatは、文字列をベクトルへ変換する。 see Vector Functions。

append

appendは、文字列をリストへ変換する。 see Building Lists。

文字列の書式付け

書式付け（formatting）とは、 定数文字列内のさまざま部分を計算値で置き換えた文字列を作ることです。 この文字列は、文字列自体に加えて、 他の値をどのように表示するかも制御します。 この文字列を書式付け文字列（format string）と呼びます。

書式付けは、表示するメッセージを計算する場合に便利です。 実際、関数messageと関数errorには、 ここで説明するのと同じ書式付け機能があります。 それらとformatとの違いは、 書式付けした結果をどのように利用するかです。

format string &rest objects

Function

この関数は、stringをコピーし、 コピー内の書式付け指定を対応するobjectsの表現で置き換えた 新たな文字列を返す。 引数objectsは書式付けすべき計算値である。

書式付け指定は%で始まる文字の列です。 したがって、string内に%dがあると、 関数formatはそれを書式付けすべき値の1つ （引数objectsの1つ）の表示表現で置き換えます。 たとえば、つぎのとおりです。

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

stringに2個以上の書式付け指定がある場合、 書式付け指定はobjectsの後続の値に対応します。 つまり、stringの最初の書式付け指定は最初の値を使い、 2番目の書式付け指定は2番目の値を使い、といった具合です。 （値が対応しない）余計な書式付け指定は、 予測不可能なふるまいを引き起こします。 余計な値は無視します。

特定の書式付け指定は、特定の型の値を必要とします。 要求に適合しない値を読者が指定するとエラーを通知します。

有効な書式付け指定をつぎに示します。

%s

書式付け指定をオブジェクトのクォートしない （つまり、prin1ではなくprincを用いる。see Output Functions） 表示表現で置き換える。 したがって、文字列は"文字なしでその内容を表示し、 シンボルは\文字なしで表示する。

対応するオブジェクトがなければ空文字列を使う。

%S

書式付け指定をオブジェクトのクォートした （つまり、prin1を用いる。see Output Functions） 表示表現で置き換える。 したがって、文字列は"文字で囲んで表示し、 シンボルは特別な文字のまえには\文字を付けて表示する。

対応するオブジェクトがなければ空文字列を使う。

%o

書式付け指定を整数の基数8の表示表現で置き換える。

%d

書式付け指定を整数の基数10の表示表現で置き換える。

%x

書式付け指定を整数の基数16の表示表現で置き換える。

%c

書式付け指定を指定値の文字で置き換える。

%e

書式付け指定を浮動小数点数の指数表記で置き換える。

%f

書式付け指定を浮動小数点数の小数点表記で置き換える。

%g

書式付け指定を浮動小数点数の指数表記か小数点表記のどちらか短いほうで 置き換える。

%%

文字列に1個の%を入れる。 この書式付け指定は、値を使わない点で特別である。 たとえば、(format "%% %d" 30)は"% 30"を返す。

上記以外の書式付け文字は、エラーInvalid format operationになります。

例をいくつか示します。

(format "The name of this buffer is %s." (buffer-name))
     => "The name of this buffer is strings.texi."

(format "The buffer object prints as %s." (current-buffer))
     => "The buffer object prints as strings.texi."

(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 "%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は、どんな幅を指定しても、 オブジェクトの表示表現を切り詰めることはありません。 つまり、情報を失うことなく、数前置子を使って最小の桁幅を指定できます。

つぎの3つの例において、%7sは最小幅7を指定します。 最初の例では、%7sに置き換わる文字列は3文字ですから、 パディングとして空白4個を挿入します。 2番目の例では、文字列"specification"は13文字幅ですが切り詰めません。 3番目の例では、右側にパディングします。

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

(format "The word `%7s' actually has %d letters in it."
        "specification" (length "specification"))
     => "The word `specification' actually has 13 letters in it."

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

Lispの大文字小文字変換

大文字小文字変換関数は、1文字や文字列内の大文字小文字を変更します。 関数は、通常、アルファベット文字 （非ASCII文字のアルファベットに加えて、 AからZとaからz）だけを変換します。 それ以外の文字は変わりません。 （大文字小文字テーブルを指定して異なる大文字小文字変換を指定できる。 see Case Tables）

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

以下の例では、文字Xとxを使います。 ASCIIコードは、それぞれ、88と120です。

downcase string-or-char

Function

この関数は、文字や文字列を小文字に変換する。 downcaseの引数が文字列であると、 この関数は、引数の各文字の大文字を小文字に変換した新たな文字列を作成する。 downcaseの引数が文字であると、 downcaseは対応する小文字を返す。 この値は整数である。 もとの文字が小文字であったりアルファベット文字でなければ、 値はもとの文字に等しい。 (downcase "The cat in the hat") => "the cat in the hat" (downcase ?X) => 120

upcase string-or-char

Function

この関数は、文字や文字列を大文字に変換する。 upcaseの引数が文字列であると、 この関数は、引数の各文字の小文字を大文字に変換した新たな文字列を作成する。 upcaseの引数が文字であると、 upcaseは対応する大文字を返す。 この値は整数である。 もとの文字が大文字であったりアルファベット文字でなければ、 値はもとの文字に等しい。 (upcase "The cat in the hat") => "THE CAT IN THE HAT" (upcase ?x) => 88

capitalize string-or-char

Function

この関数は、文字列や文字をキャピタライズ（先頭文字だけを大文字に）する。 string-or-charが文字列ならば、 この関数は、string-or-charのコピーの各単語をキャピタライズしたものを 内容とする新たな文字列を作成して返す。 つまり、各単語の先頭文字だけを大文字にして残りを小文字にする。 単語の定義は、現在の構文テーブル（See Syntax Class Table）において 単語構成文字に分類された文字が連続した列である。 capitalizeの引数が文字の場合には、 capitalizeはupcaseの結果と同じである。 (capitalize "The cat in the hat") => "The Cat In The Hat" (capitalize "THE 77TH-HATTED CAT") => "The 77th-Hatted Cat" (capitalize ?x) => 88

upcase-initials string

Function

この関数は、string内の単語の先頭文字だけを大文字にし、 先頭文字以外の文字は変更しない。 この関数は、stringのコピーの各単語の先頭文字を大文字に変換したものを 内容とする新たな文字列を返す。 単語の定義は、現在の構文テーブル（See Syntax Class Table）において 単語構成文字に分類された文字が連続した列である。 (upcase-initials "The CAT in the hAt") => "The CAT In The HAt"

文字列を比較する関数については、See Text Comparison。 これらは、大文字小文字を区別しないものもあれば、 場合によって大文字小文字を区別しないものもある。

大文字小文字テーブル

特別な大文字小文字テーブル（case table）をインストールすれば、 大文字小文字変換をカスタマイズできます。 大文字小文字テーブルは、大文字と小文字の対応関係を指定します。 このテーブルは、Lispオブジェクトの大文字小文字変換関数（前節参照）と バッファ内のテキストに作用する大文字小文字変換関数（see Case Changes）の 両方に影響します。 各バッファごとに大文字小文字テーブルがあります。 新たなバッファの大文字小文字テーブルを初期化するために使う 標準の大文字小文字テーブルもあります。

大文字小文字テーブルは、サブタイプがcase-tableである 文字テーブル（see Char-Tables）です。 この文字テーブルは、各文字を対応する小文字に対応付けます。 これには3つの追加スロットがあり、関連するテーブルを保持します。

upcase

upcase（大文字）テーブルは、各文字を対応する大文字に対応付ける。

canonicalize

canonicalize（正則）テーブルは大文字小文字に関連する1組の文字群を その文字群の特定のメンバに対応付ける。

equivalences

equivalences（同値）テーブルは、大文字小文字に関連する1組の文字群の各要素を その文字群内のつぎの文字に対応付ける。

単純な場合、必要なことは、小文字への対応付けを指定するだけです。 関連する3つのテーブルはこの対応付けから自動的に計算されます。

言語によっては、大文字と小文字の対応関係が1対1でないことがあります。 2つの異なる小文字が同じ大文字に対応することがあります。 このような場合、大文字から小文字への対応付けと、 小文字から大文字への対応付けの両方を指定する必要があります。

追加のテーブルcanonicalize（正則）は、各文字を正則文字に対応付けます。 2つの任意の文字が大文字小文字変換で関連付けられている場合、 その2つの文字は同一の正則文字を持ちます。 たとえば、aとAは、大文字小文字変換で関連付けられているので、 これらは同一の正則文字を持つはずです （両方の文字に対してaであるか、両方の文字に対してAである）。

追加のテーブルequivalences（同値）は、 同じ正則クラス（同一の正則文字を持つ文字群）の文字を巡回して対応付けます。 （普通のASCIIでは、aをAに対応付け、 Aをaに対応付ける。 各正則クラスについても同様。）

大文字小文字テーブルを作成するときには、 canonicalize（正則）にはnilを指定できます。 そうすると、Emacsはこのスロットを小文字と大文字の対応付けから埋めます。 equivalences（同値）にもnilを指定できます。 そうすると、Emacsはこのスロットをcanonicalize（正則）から埋めます。 実際に使用している大文字小文字テーブルでは、 これらの要素はnil以外です。 canonicalize（正則）を指定せずに equivalences（同値）を指定しないでください、

つぎに、大文字小文字テーブルを操作する関数を示します。

case-table-p object

Function

この述語は、objectが正しい 大文字小文字テーブルならばnil以外を返す。

set-standard-case-table table

Function

この関数は、tableを標準の大文字小文字テーブルとし、 これ以降に作成する任意のバッファに使用できるようにする。

standard-case-table

Function

これは、標準の大文字小文字テーブルを返す。

current-case-table

Function

この関数は、カレントバッファの大文字小文字テーブルを返す。

set-case-table table

Function

これは、カレントバッファの大文字小文字テーブルをtableとする。

以下の3つ関数は、非ASCII文字集合を定義するパッケージ向けの 便利なサブルーティンです。 これらは、指定した大文字小文字テーブルcase-tableを変更します。 さらに、標準の構文テーブルも変更します。 See Syntax Tables。 普通、標準の大文字小文字テーブルを変更するためにこれらの関数を使います。

set-case-syntax-pair uc lc case-table

Function

この関数は対応する大文字と小文字を指定する。

set-case-syntax-delims l r case-table

Function

この関数は、文字lとrを 大文字小文字不変区切りの対応する対にする。

set-case-syntax char syntax case-table

Function

この関数は、charを構文syntaxの大文字小文字不変にする。

describe-buffer-case-table

コマンド

このコマンドは、カレントバッファの大文字小文字テーブルの内容を記述する。

リスト

リスト（list）は、0個以上の（任意のLispオブジェクトの）要素の列を 表現します。 リストとベクトルの重要な相違点は、 複数のリストがそれらの構造の一部を共有できることです。 さらに、リスト全体をコピーすることなく、 リストに要素を追加したり削除できることです。

• Cons Cells: How lists are made out of cons cells.
• Lists as Boxes: Graphical notation to explain lists.
• List-related Predicates: Is this object a list? Comparing two lists.
• List Elements: Extracting the pieces of a list.
• Building Lists: Creating list structure.
• Modifying Lists: Storing new pieces into an existing list.
• Sets And Lists: A list can represent a finite mathematical set.
• Association Lists: A list can represent a finite relation or mapping.

リストとコンスセル

Lispのリストは基本データ型ではありません。 リストはコンスセル（cons cells）で構成されます。 コンスセルはドット対を表現するデータオブジェクトです。 ドット対は2つのLispオブジェクトを保持、つまり、『指し』ます。 その2つのLispオブジェクトの一方をCAR、他方をCDRといいます。 これらの名前は歴史的なものです。 See Cons Cell Type。 CDRは『クダー』と読みます。

リストはコンスセルを連ねたものであり、 リストの各要素ごとにコンスセルが1つあります。 慣習として、コンスセルのCARはリストの要素であり、 CDRはリストを繋ぐために使います。 つまり、各コンスセルのCDRは後続のコンスセルです。 最後のコンスセルのCDRはnilです。 CARとCDRの非対称性は単なる慣習によるものです。 コンスセルのレベルでは、CARとCDRには同じ性質があります。

ほとんどのコンスセルはリストの一部として使われるので、 リスト構造（list structure）という用語は、 コンスセルで構成した任意の構造を意味するようになりました。

シンボルnilは、シンボルであるとともにリストでもあるとみなします。 これは要素を持たないリストです。 慣習として、シンボルnilのCDR（およびCAR）は nilであるとみなします。

空でない任意のリストlのCDRは、 lの先頭要素を除くすべての要素を含んだリストです。

箱の対を連ねたリスト

コンスセルは1対の箱で図示できます。 最初の箱はCARを表し、2番目の箱はCDRを表します。 つぎは、2つのコンスセルから成る 2要素のリスト(tulip lily)を図示したものです。

 ---------------         ---------------
| car   | cdr   |       | car   | cdr   |
| tulip |   o---------->| lily  |  nil  |
|       |       |       |       |       |
 ---------------         ---------------

各1対の箱がコンスセルを表します。 各箱は、Lispオブジェクトを『参照する』、『指す』、『含む』のです。 （これらの用語は同義語。） 最初のコンスセルのCARを表す最初の箱は、 シンボルtulipを含みます。 最初のコンスセルのCDR箱から2番目のコンスセルへ向かう矢印は、 最初のコンスセルのCDRが2番目のコンスセルであることを表します。

同じリストは、つぎのような別の箱記法でも図示できます。

    --- ---      --- ---
   |   |   |--> |   |   |--> nil
    --- ---      --- ---
     |            |
     |            |
      --> tulip    --> lily

つぎは、より複雑で、最初の要素が2要素リストであるような 3要素リストを図示したものです。

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

同じリストを最初の箱記法で表現するとつぎのようになります。

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

コンスセルとリストの入力構文と表示表現、および、 『箱と矢印』によるリストの図示については、See Cons Cell Type

リスト向け述語

以下の述語は、Lispオブジェクトが、アトムであるか、 コンスセル、つまり、リストであるか、 特別なオブジェクトnilであるか調べます。 （これらの多く述語は、それぞれ残りの述語で定義可能である。 しかし、多用するため、これらすべてを用意しておく価値がある。）

consp object

Function

この関数は、objectがコンスセルならばtを返し、 さもなければnilを返す。 nilはコンスセルではないが、空リストである。

atom object

Function

この関数は、objectがアトムならばtを返し、 さもなければnilを返す。 コンスセルを除くすべてのオブジェクトはアトムである。 シンボルnilはアトムでもありリストでもある。 このようなLispオブジェクトはnilだけである。 (atom object) == (not (consp object))

listp object

Function

この関数は、objectがコンスセルかnilならばtを返す。 さもなければnilを返す。 (listp '(1)) => t (listp '()) => t

nlistp object

Function

この関数は、listpの反対である。 objectがリストでなければtを返す。 さもなければnilを返す。 (listp object) == (not (nlistp object))

null object

Function

この関数は、objectがnilならばtを返し、 さもなければnilを返す。 この関数は、notと同一であるが、意図を明確にするために、 objectをリストと考えるときにはnullを使い、 objectを真理値と考えるときにはnotを使う （Combining Conditionsのnotを参照） (null '(1)) => nil (null '()) => t

リストの要素の参照

car cons-cell

Function

この関数は、コンスセルcons-cellの最初のポインタが指す値を返す。 別のいい方をすれば、cons-cellのCARを返す。 特別な場合として、cons-cellがnilのときには、 carはnilを返すと定義する。 したがって、任意のリストはcarの正しい引数である。 引数がコンスセルでもnilでもなければエラーを通知する。 (car '(a b c)) => a (car '()) => nil

cdr cons-cell

Function

この関数は、コンスセルcons-cellの2番目のポインタが指す値を返す。 別のいい方をすれば、cons-cellのCDRを返す。 特別な場合として、cons-cellがnilのときには、 cdrはnilを返すと定義する。 したがって、任意のリストはcdrの正しい引数である。 引数がコンスセルでもnilでもなければエラーを通知する。 (cdr '(a b c)) => (b c) (cdr '()) => nil

car-safe object

Function

この関数は、コンスセルのCARを取り出すが、 他のデータ型に対するエラーを回避する。 objectがコンスセルならばobjectのCARを返すが、 さもなければnilを返す。 これはcarと対照的であり、 carはobjectがリストでないとエラーを通知する。 (car-safe object) == (let ((x object)) (if (consp x) (car x) nil))

cdr-safe object

Function

この関数は、コンスセルのCDRを取り出すが、 他のデータ型に対するエラーを回避する。 objectがコンスセルならばobjectのCDRを返すが、 さもなければnilを返す。 これはcdrと対照的であり、 cdrはobjectがリストでないとエラーを通知する。 (cdr-safe object) == (let ((x object)) (if (consp x) (cdr x) nil))

nth n list

Function

この関数は、listのn番目の要素を返す。 要素は0から数えるので、listのCARは要素番号0。 listの長さがnかそれ未満であると、値はnilになる。 nが負であると、nthはlistの最初の要素を返す。 (nth 2 '(1 2 3 4)) => 3 (nth 10 '(1 2 3 4)) => nil (nth -3 '(1 2 3 4)) => 1 (nth n x) == (car (nthcdr n x)) 関数eltも同様であるが、任意のシーケンスに適用できる。 歴史的な理由で引数の順序は逆である。 see Sequence Functions。

nthcdr n list

Function

この関数は、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 -3 '(1 2 3 4)) => (1 2 3 4)

safe-length list

Function

この関数は、エラーや無限ループを回避して、listの長さを返す。 listが実際にはリストでない場合には、safe-lengthは0を返す。 listに循環があると、少なくとも異なる要素の個数を表す有限値を返す。

循環はないと思われるリストの長さを計算するもっとも一般的な方法は、 lengthです。 See Sequence Functions。

caar cons-cell

Function

これは(car (car cons-cell))と同じ。

cadr cons-cell

Function

これは(car (cdr cons-cell))や (nth 1 cons-cell)と同じ。

cdar cons-cell

Function

これは(cdr (car cons-cell))と同じ。

cddr cons-cell

Function

これは(cdr (cdr cons-cell))や (nthcdr 2 cons-cell)と同じ。

コンスセルとリストの構築

リストはLispの中核なので、多くの関数はリストを構築します。 consは基本的なリスト構築関数です。 しかし、Emacsのソースコードでは、consよりlistを 多用していることは興味深いことです。

cons object1 object2

Function

この関数は、新たなリスト構造を構築するために使う基本関数。 object1をCAR、object2をCDRとする 新たなコンスセルを作成し、このコンスセルを返す。 引数object1とobject2はどんなLispオブジェクトでもよいが、 ほとんどの場合、object2はリストである。 (cons 1 '(2)) => (1 2) (cons 1 '()) => (1) (cons 1 2) => (1 . 2) consは、リストの先頭に要素を1つ追加するために しばしば使われる。 これを要素をリストにコンスするという。 たとえば、つぎのとおり。 (setq list (cons newelt list)) この例におけるlistという名前の変数と 以下に述べるlistという名前の関数とは衝突しない。 任意のシンボルはどちらの目的にも使える。

list &rest objects

Function

この関数は、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

make-list length object

Function

この関数は、すべての要素が同一の値objectであり 長さがlengthのリストを作成する。 make-stringと比較してほしい（see Creating Strings）。 (make-list 3 'pigs) => (pigs pigs pigs) (make-list 0 'pigs) => nil

append &rest sequences

Function

この関数はsequencesのすべての要素から成るリストを返す。 sequencesは、リスト、ベクトル、ブールベクトル、文字列のいずれかであるが、 普通、最後の要素はリストである。 最後の引数を除いてすべての引数をコピーするので、どの引数も変更しない （コピーせずにリストを繋ぐ方法については、 Rearrangementのnconcを参照。） 一般には、appendの最後の引数はどんなLispオブジェクトでもよい。 最後の引数をコピーしたり変換したりしない。 それは、新たなリストの最後のコンスセルのCDRになる。 最後の引数がそれ自体リストであれば、それらの要素は、実質的には、 結果のリストの要素になる。 最後の要素がリストでなければ、結果は『ドット対』になる。 なぜなら、結果の最後のCDRは、 真のリストに必要とされるnilではないからである。 関数appendは、引数として整数も受け付ける。 整数を10進の表示表現の文字列に変換してから、 その文字列を整数のかわりに使う。 この機能を使わないでほしい。 削除する予定である。 読者がこの機能を使っていたら、今すぐプログラムを直すこと！ 整数をこのような10進数に変換する正しい方法は、 format（see Formatting Strings）や number-to-string（see String Conversion）を使うことである。

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を導入するまでは、 リストをコピーする普通の方法でした。 See Sequences Arrays Vectors。

appendの引数にベクトルと文字列を使った例をつぎに示します。

(append [a b] "cd" nil)
     => (a b 99 100)

apply（see Calling Functions）の助けを借りれば、 リストのリストの中にあるすべてのリストを連結できます。

(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になります。

reverse list

Function

この関数は、listの要素を逆順にした新たなリストを作成する。 もとの引数listは変更しない。 (setq x '(1 2 3 4)) => (1 2 3 4) (reverse x) => (4 3 2 1) x => (1 2 3 4)

既存のリスト構造の修正

基本関数setcarやsetcdrを使って、 コンスセルのCARやCDRの内容を変更できます。 これらは、既存のリスト構造を変更するので、 『破壊的』な操作と呼びます。

Common Lispに関した注意： Common Lispでは、 リスト構造を変更するにはrplacaやrplacdを使う。 これらはsetcarやsetcdrと同様に構造を変更する。 しかし、Common Lispの関数はコンスセルを返すが、 setcarやsetcdrは新たなCARやCDRを返す。

• Setcar: Replacing an element in a list.
• Setcdr: Replacing part of the list backbone. This can be used to remove or add elements.
• Rearrangement: Reordering the elements in a list; combining lists.

setcarによるリスト要素の変更

コンスセルのCARを変更するには、setcarを使います。 リストに対して使用すると、 setcarはリストの1つの要素を別の要素に置き換えます。

setcar cons object

Function

この関数は、consの新たなCARとしてobjectを格納し、 以前のCARを置き換える。 いいかえれば、consのCARスロットがobjectを指すように変更する。 この関数は値objectを返す。 たとえば、つぎのようになる。 (setq x '(1 2)) => (1 2) (setcar x 4) => 4 x => (4 2)

コンスセルが複数のリストの共有構造の一部であるときには、 コンスセルに新たなCARを格納すると、 そのような各リストの1つの要素を変更することになります。

;; 共有部分がある2つのリストを作る
(setq x1 '(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)

変数x1とx2に入っている共有部分を持つ2つのリストを図示すると つぎのようになります。 bを置き換えるとなぜ両者が変更されるのかわかるでしょう。

        --- ---        --- ---      --- ---
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----
|       |      |
 --------------

リストのCDRの変更

CDRを修正するもっとも低レベルの基本関数はsetcdrです。

setcdr cons object

Function

この関数は、consの新たなCDRとしてobjectを格納し、 以前のCDRを置き換える。 いいかえれば、consのCDRスロットがobjectを指すように変更する。 この関数は値objectを返す。

リストのCDRを別のリストで置き換える例を示します。 リストの最初の要素以外は取り除かれ、 要素の別のシーケンスになります。 最初の要素は変更されません。 というのは、それはリストのCARの中にあり、 CDRからは辿れないからです。

(setq x '(1 2 3))
     => (1 2 3)
(setcdr x '(4))
     => (4)
x
     => (1 4)

リスト内のコンスセル群のCDRを変更することで、 リストの中ほどの要素を削除できます。 つぎの例は、リスト(a b c)の最初のコンスセルのCDRを変更することで、 このリストの第2要素bを削除します。

(setq x1 '(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 '(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------
        |       |       |
         ---------------

リストの順序を変更する関数

以下は、リストを構成するコンスセルのCDRを変更することで、 『破壊的に』リストの順序を変更する関数です。 これらの関数を『破壊的』と呼ぶのは、 渡された引数であるもとのリストのコンスセルを繋ぎ換えて新たなリストに 変えるからです。

nconc &rest lists

Function

この関数は、listsのすべての要素を入れたリストを返す。 append（see Building Lists）と異なり、 listsをコピーしない。 そのかわりに、各listsの最後のCDRを後続のリストを指すように変更する。 listsの最後は変更しない。 たとえば、つぎのようになる。 (setq x '(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 '(1 2 3)) => (1 2 3) (nconc x 'z) => (1 2 3 . z) x => (1 2 3 . z) しかしながら、すべての引数は（最後のものを除いて）リストである必要がある。 よくある落し穴は、nconcの最後以外の引数に、 クォートした定数リストを使うことである。 こうすると、読者のプログラムは実行するたびに定数を変えてしまう。 たとえば、つぎのようになる。 (defun add-foo (x) ; この関数は引数の先頭に (nconc '(foo) x)) ; fooを追加する、としたい (symbol-function 'add-foo) => (lambda (x) (nconc (quote (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 (quote (foo 1 2 3 4) x)))

nreverse list

Function

この関数は、listの要素の順番を逆順にする。 reverseと異なり、nreverseは リストを構成するコンスセルのCDRを逆向きにして引数を変えてしまう。 listの最後にあったコンスセルは戻り値の最初のコンスセルになる。 たとえば、つぎのようになる。 (setq x '(1 2 3 4)) => (1 2 3 4) x => (1 2 3 4) (nreverse x) => (4 3 2 1) ;; 先頭にあったコンスセルは、今、最後になっている x => (1) 混乱を避けるために、nreverseの結果は、 もとのリストを収めていたものと同じ変数に格納する。 (setq x (nreverse x)) nreverseを(a b c)に適用した結果を図示すると つぎのようになる。 もとのリストの先頭 逆順にしたリスト ------------- ------------- ------------ | car | cdr | | car | cdr | | car | cdr | | a | nil |<-- | b | o |<-- | c | o | | | | | | | | | | | | | | ------------- | --------- | - | -------- | - | | | | ------------- ------------

sort list predicate

Function

この関数は、破壊的にではあるが、 listを順序を保ってソートしたリストを返す。 要素の比較にはpredicateを使う。 順序を保ったソートとは、同じソートキーを持つ要素の相対順序を、 ソート実行前後で変更しないソートである。 異なる基準でつぎつぎにソートするときには、 順序を保つことは重要である。 引数predicateは、2つの引数を取る関数である必要がある。 この関数は、listの2つの要素で呼び出される。 昇順のソートでは、predicateは、 第1引数が第2引数より『小さい』ときにtを返し、 さもなければnilを返す必要がある。 比較関数predicateは、少なくとも単一のsortの呼び出し中は、 引数の任意の対に対して信頼できる結果を返す必要がある。 まず、反対称であること。 つまり、aがbより小さいときには、 bがaより小さくてはいけない。 また、遷移則が成り立つこと。 つまり、aがbより小さく、かつ、bがcより小さいときには、 aはcより小さくなければならない。 これらの要請を満たさない比較関数を用いると、 sortの結果は予測できない。 sortが破壊的であるというのは、 listを構成するコンスセルのCDRを変更して、 コンスセルの順序を変更するからである。 非破壊的なソート関数では、ソートした要素を格納するために新たなコンスセルを 作成するであろう。 もとのリストを破壊せずにソートしたければ、 まずcopy-sequenceでコピーを作り、それをソートする。 ソートする際、listのコンスセルのCARは変更しない。 list内の要素aを入れていたコンスセルは、 ソート後にもそのCARにはaが入っている。 しかし、CDRを変更してあるので、リスト内では異なる場所に現れる。 たとえば、つぎのようになる。 (setq nums '(1 3 2 6 5 4 0)) => (1 3 2 6 5 4 0) (sort nums '<) => (0 1 2 3 4 5 6) nums => (1 2 3 4 5 6) 警告： numsのリストには 0が入っていないことに注意。 （numsが指す）コンスセルはソート前と同じコンスセルだが、 それはもはやリストの先頭にはない。 引数を保持していた変数が、 ソートしたリスト全体を保持していると仮定しないこと！ かわりに、sortの結果を保存して、それを使う。 多くの場合、つぎのように、もとのリストを保持していた変数に結果を保存し直す。 (setq nums (sort nums '<)) ソートを行う他の関数については、see Sorting。 sortの有用な例については、 Accessing Documentationのdocumentationを参照。

集合としてのリストの利用

リストで、数学の順序のない集合を表現できます。 つまり、リストに現れる要素を集合の要素と考え、 リスト内での順序は無視します。 2つの集合の和集合を作るには、 （要素が重複することを気にしなければ）appendを使います。 集合向けの他の有用な関数には、memqやdelq、および、 これらのequal版であるmemberやdeleteがあります。

Common Lispに関した注意： Common Lispには、集合演算向けに （要素の重複を避ける）関数unionとintersectionがあるが、 GNU Emacs Lispにはない。 必要ならば、読者みずからLispでこれらを書ける。

memq object list

Function

この関数は、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

delq object list

Function

この関数は、listからobjectにeqであるすべての要素を 破壊的に削除する。 delqの文字qは、memqと同様に、 リストの要素に対するobjectの比較にeqを使うことを意味する。

delqがリストの先頭から要素を削除する場合には、 単にリストを辿って削除した要素のつぎから始まる部分リストを返します。

(delq 'a '(a b c)) == (cdr '(a b c))

リストの中ほどの要素を削除する場合には、 削除にはCDRの変更を伴います（see Setcdr）。

(setq sample-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 'c sample-list)は、 3番目の要素を切り取ってsample-listを変更しますが、 (delq 'a sample-list)では、 なにも切り取らずに単に短いリストを返すことに注意してください。 引数listを保持していた変数が、実行後には少ない要素を持つと仮定したり、 もとのリストを保持し続けていると仮定したりしないでください！ そのかわりに、delqの結果を保存して、それを使ってください。 多くの場合、つぎのように、 もとのリストを保持していた変数に結果を保存し直します。

(setq flowers (delq 'rose flowers))

つぎの例では、delqが一致を取ろうとしている(4)と sample-listの(4)とはeqではありません。

(delq '(4) sample-list)
     => (a c (4))

つぎの2つの関数は、memqやdelqに似ていますが、 比較にはeqのかわりにequalを使います。 See Equality Predicates。

member object list

Function

関数memberは、equalを使ってobjectと要素を比較して、 objectがlistの要素かどうか調べる。 objectが要素であれば、 memberはlist内でそれが最初に現れるところから始まるリストを返す。 さもなければnilを返す。 memqと比較してほしい。 (member '(2) '((1) (2))) ; (2)と(2)はequalである => ((2)) (memq '(2) '((1) (2))) ; (2)と(2)はeqではない => nil ;; 同じ内容の2つの文字列はequalである (member "foo" '("foo" "bar")) => ("foo" "bar")

delete object list

Function

この関数は、listからobjectにequalであるすべての要素を 破壊的に削除する。 memberがmemeqに対応するように、delqに対応する。 memberと同様に、 要素とobjectとの比較にはequalを使う。 一致する要素をみつけると、delqと同様に要素を削除する。 たとえば、つぎのとおり。 (delete '(2) '((2) (1) (2))) => ((1))

Common Lispに関した注意： GNU Emacs Lispの関数memberと関数deleteは Maclispから受け継いだものであり、Common Lispからではない。 Common Lisp版では要素の比較にはequalを使わない。

変数に格納したリストに要素を追加する別の方法については、 Setting Variablesの関数add-to-listを参照してください。

連想リスト

連想リスト（association list）、略してalistは、 キーから値への対応付けを記録しています。 これは連想（associations）と呼ばれるコンスセルのリストです。 各コンスセルのCARはkeyであり、 CDRは連想値（associated value）です。 ⁶

連想リストの例を示します。 キーpineを値conesに、キーoakを値acornsに、 キーmapleを値seedsに対応付けています。

'((pine . cones)
  (oak . acorns)
  (maple . seeds))

連想リスト内の連想値は任意のLispオブジェクトでよく、キーもそうです。 たとえば、つぎの連想リストでは、シンボルaに数1を、 文字列"b"にリスト(2 3)を対応付けています。 リスト(2 3)は連想リストの要素のCDRです。

((a . 1) ("b" 2 3))

要素のCDRのCARに連想値を格納するように 連想リストを設計したほうがよい場合もあります。 つぎのようにします。

'((rose red) (lily white) (buttercup yellow))

ここで、redはroseに対応付けた値と考えます。 この種の連想リストの利点の1つは、関連する別の情報を、 他の項目から成るリストでさえも、CDRのCDRに格納できることです。 1つの欠点は、rassq（下記参照）を使って 指定した値を含む要素を探せないことです。 これらの条件が重要でない場合には、1つの連想リストに関する限り、 一貫性があればどちらを選ぶかは好みの問題です。

上に示した連想リストは、要素のCDRに連想値が収めてあると 考えることもできます。 roseの連想値はリスト(red)になります。

連想リストはスタックなどに置くような情報の記録に使います。 というには、リストの先頭に新たな連想を追加するのが簡単だからです。 指定したキーに対する連想を連想リストから探すとき、 それらが複数個存在する場合には、最初にみつかったものを返します。

Emacs Listでは、連想リストの要素がコンスセルでなくても エラーではありません。 連想リスト探索関数はそのような要素を単に無視します。 他の多くのLispでは、そのような場面ではエラーを通知します。

属性リストもいろいろな意味で連想リストに類似しています。 属性リストは、キーが一度しか現れない連想リストのようにふるまいます。 属性リストと連想リストの比較については、See Property Lists。

assoc key alist

Function

この関数は、alist内のkeyに対する最初の連想を返す。 keyと連想リストの各要素との比較には、 equal（see Equality Predicates）を用いる。 alistの中にCARがkeyにequalである連想が 存在しなければ、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-ignore-representationとassoc-ignore-caseは assocに似ていますが、 それらは比較にcompare-stringsを使う点が異なります。 See Text Comparison。

rassoc value alist

Function

この関数は、alistの中でvalueを値とする最初の連想を返す。 alistの中にCDRがvalueにequalである連想が 存在しなければ、nilを返す。 rassocはassocに似ているが、 alistの各連想のCARのかわりにCDRを比較する点が異なる。 指定した値に対するキーを探す『assocの逆演算』と考えることができる。

assq key alist

Function

この関数は、alist内のkeyに対する最初の連想を返すという意味で assocに似ているが、equalのかわりにeqで比較する。 alist内の連想のCARがkeyにeqであるものが存在しないと、 assqはnilを返す。 この関数はassocより多用される。 というのは、eqはequalより高速であり、 ほとんどの連想リストではキーとしてシンボルを使うからである。 (setq trees '((pine . cones) (oak . acorns) (maple . seeds))) => ((pine . cones) (oak . acorns) (maple . seeds)) (assq 'pine trees) => (pine . cones) 一方で、キーがシンボルではない連想リストでは、 assqは、通常、有用ではない。 (setq leaves '(("simple leaves" . oak) ("compound leaves" . horsechestnut))) (assq "simple leaves" leaves) => nil (assoc "simple leaves" leaves) => ("simple leaves" . oak)

rassq value alist

Function

この関数は、alistの中でvalueを値とする最初の連想を返す。 alistの中にCDRがvalueにeqである連想が 存在しなければ、nilを返す。 rassqはassqに似ているが、 alistの各連想のCARのかわりに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))

assoc-default key alist test default

Function

この関数は、keyに一致するものをalistから探す。 alistの各要素について、（アトムならば）要素とkeyを、 あるいは、（コンスならば）要素のCARとkeyを比較する。 比較にはこれらを2つの引数としてtestを呼び出す。 引数を渡す順序はこの順なので、 正規表現（see Regexp Search）を収めた連想リストに対して string-matchを使うと有益な結果を得られる。 testを省略したりnilであると、比較にはequalを用いる。 上の条件で連想リストの要素がkeyに一致するならば、 assoc-defaultはその要素に基づく値を返す。 要素がコンスならば値は要素のCDR。 さもなければ、戻り値はdefault。 keyに一致する連想リストの要素が存在しなければ、 assoc-defaultはnilを返す。

copy-alist alist

Function

この関数は、alistを2レベルの深さまでコピーしたものを返す。 各連想ごとに新たなコピーを作るので、 新たな連想リストの連想を変更しても、もとの連想リストは変更しない。 (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")

シーケンス、配列、ベクトル

シーケンス（sequence）型とは、Lispの2つの異なる型の和であることを 思い出してください。 いいかえれば、任意のリストはシーケンスであり、 任意の配列もシーケンスです。 すべてのシーケンスに共通する性質は、 それぞれ、要素の順序付けた集まりであるということです。

配列（array）は、各要素ごとに1つ1つスロットを用意してある 単一の基本オブジェクトです。 すべての要素は一定時間内に参照できますが、既存の配列の長さは変更できません。 文字列、ベクトル、文字テーブル、ブールベクトルは、配列型の4つの型です。

リストは、要素を並べたものですが、 単一の基本オブジェクトではありません。 コンスセルから作られていて、1つの要素あたり1つのセルがあります。 n番目の要素を探すには、n個のコンスセルを調べる必要があるので、 リストの先頭から遠い要素を参照するには余計に時間がかかります。 しかし、リストには要素を追加したり削除したりできます。

以下の図は、これらの型の関係を示します。

　　　　　┌────────────────────────┐
　　　　　│　　　　　　シーケンス　　　　　　　　　　　　　│
　　　　　│┌───┐　┌───────────────┐　│
　　　　　││　　　│　│　　　　　　　　　　　　　　　│　│
　　　　　││リスト│　│　　　　　　配列　　　　　　　│　│
　　　　　││　　　│　│　┌────┐　┌───┐　　│　│
　　　　　││　　　│　│　│　　　　│　│　　　｜　　│　│
　　　　　│└───┘　│　│ベクトル│　│文字列｜　　│　│
　　　　　│　　　　　　│　│　　　　│　│　　　｜　　│　│
　　　　　│　　　　　　│　└────┘　└───┘　　│　│
　　　　　│　　　　　　│　┌────┐　┌────┐　│　│
　　　　　│　　　　　　│　│文字　　│　│ブール　│　│　│
　　　　　│　　　　　　│　│テーブル│　│ベクトル│　│　│
　　　　　│　　　　　　│　└────┘　└────┘　│　│
　　　　　│　　　　　　└───────────────┘　│
　　　　　└────────────────────────┘

ベクトルやリストの要素は、どんなLispオブジェクトでもかまいません。 文字列の要素はすべて文字です。

• Sequence Functions: Functions that accept any kind of sequence.
• Arrays: Characteristics of arrays in Emacs Lisp.
• Array Functions: Functions specifically for arrays.
• Vectors: Special characteristics of Emacs Lisp vectors.
• Vector Functions: Functions specifically for vectors.
• Char-Tables: How to work with char-tables.
• Bool-Vectors: How to work with bool-vectors.

シーケンス

Emacs Lispでは、シーケンス（sequence）とはリストか配列のことです。 すべてのシーケンスに共通する性質は、 要素の順序付けた集まりであるということです。 本節では任意のシーケンスを受け付ける関数を説明します。

sequencep object

Function

objectが、リスト、ベクトル、あるいは、文字列ならばtを返し、 さもなければnilを返す。

length sequence

Function

この関数はsequence内の要素の個数を返す。 sequenceが（最後のCDRがnilではないため） リストではないコンスセルであると、 エラーwrong-type-argumentを通知する。 関連する関数safe-lengthについては、see List Elements。 (length '(1 2 3)) => 3 (length ()) => 0 (length "foobar") => 6 (length [1 2 3]) => 3 (length (make-bool-vector 5 nil)) => 5

elt sequence index

Function

この関数はindexで添字付けされるsequenceの要素を返す。 indexの正当な値は、0からsequenceの長さより1小さい範囲の 整数である。 sequenceがリストである場合には、 範囲外のindexに対してはnilを返す。 さもなければエラーargs-out-of-rangeを引き起こす。 (elt [1 2 3 4] 2) => 3 (elt '(1 2 3 4) 2) => 3 ;; stringを用いてeltが返す文字を明確にする (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（see Array Functions）や nth（see List Elements）を汎用にしたものである。

copy-sequence sequence

Function

sequenceのコピーを返す。 コピーは、もとのシーケンスと同じ型のオブジェクトであり、 同じ要素が同じ順序で入っている。 コピーに新たな要素を格納しても、もとのsequenceには影響せず、 その逆もそうである。 しかし、新たなシーケンスの要素はコピーしていない。 つまり、それらはもとの要素と同一（eq）である。 したがって、シーケンスのコピーにおいて、 それらの要素の内部を変更すると、もとのシーケンスでもその変更がわかる。 シーケンスがテキスト属性を持つ文字列である場合には、 コピーの中の属性リストそのものもコピーであり、 もとの属性リストを共有するのではない。 しかし、属性の実際の値は共有される。 シーケンスをコピーする別の方法については、 Building Listsのappend、Creating Stringsのconcat、 Vectorsのvconcatを参照。 (setq bar '(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 ;; 1つのシーケンスの1つの要素を置き換える (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)]

配列

配列（array）オブジェクトには、配列の要素と呼ばれる Lispオブジェクトを保持するためのスロットがいくつかあります。 配列の任意の要素は一定時間で参照できます。 一方、リストの要素の参照には、 リスト内でのその要素の位置に比例した時間が必要です。

Emacsには4つの型の配列があり、すべて1次元です。 文字列（strings）、ベクトル（vectors）、 ブールベクトル（bool-vectors）、文字テーブル（char-tables）です。 ベクトルは汎用の配列であり、 その要素は任意のLispオブジェクトでかまいません。 文字列は特化された配列であり、その要素は文字（つまり、0から255までの整数）で ある必要があります。 配列のそれぞれの型には、独自の入力構文があります。 String TypeとSee Vector Type。

配列の4つの型すべてには、以下の性質があります。

• 配列の最初の要素は添字0であり、2番目の要素は添字1であり、といった具合。 これをゼロ原点（zero-origin）の添字付けと呼ぶ。 たとえば、4要素の配列の添字は、0、1、2、そして、3。
• 配列の長さは、いったん作成すると固定される。 既存配列の長さは変更できない。
• 配列は、評価上は定数である。 いいかえれば、それ自身に評価される。
• 配列要素の参照や変更は、それぞれ、 関数arefやasetで行う （see Array Functions）。

文字テーブル以外の配列を作成するときには、 その長さを指定する必要があります。 文字テーブルの長さは指定できません。 というのは、その長さは文字コードの範囲で決まるからです。

原理的には、テキスト文字の配列が必要ならば文字列かベクトルを使います。 実用上は、以下の4つの理由から、そのような場合には文字列を使います。

• 同じ要素のベクトルの1/4の領域を専有するだけ。
• 文字列の表示方法は、その内容をテキストとして明確に示す。
• 文字列は、テキスト属性を保持できる。 see Text Properties。
• Emacsの特化された編集機能や入出力機能の多くは、 文字列だけを受け付ける。 たとえば、文字のベクトルをバッファには挿入できないが、 文字列ならば挿入できる。 see Strings and Characters。

一方、（キー列のような）キーボード入力文字の配列には、 ベクトルが必要です。 というのは、キーボード入力文字の多くは、文字列に納まる範囲外だからです。 See Key Sequence Input。

配列操作関数

本節では任意の配列型を受け付ける関数を説明します。

arrayp object

Function

この関数はobjectが配列 （つまり、ベクトル、文字列、ブールベクトル、あるいは、文字テーブル）ならば、 tを返す。 (arrayp [a]) => t (arrayp "asdf") => t (arrayp (syntax-table)) ;; 文字テーブル => t

aref array index

Function

この関数はarrayのindex番目の要素を返す。 最初の要素の添字は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 Sequence Functionsの関数eltも参照。

aset array index object

Function

この関数は配列arrayのindex番目の要素にobjectを設定する。 objectを返す。 (setq w [foo bar baz]) => [foo bar baz] (aset w 0 'fu) => fu w => [fu bar baz] (setq x "asdfasfd") => "asdfasfd" (aset x 3 ?Z) => 90 x => "asdZasfd" arrayが文字列であり、かつ、objectが文字でなければ、 結果はエラーwrong-type-argumentとなる。 arrayが文字列であり、かつ、objectが文字であっても、 現在(aref object index)に保存されている文字のバイト数と objectが使うバイト数が異なれば、やはり、エラーとなる。 see Splitting Characters。

fillarray array object

Function

この関数は、配列arrayをobjectで埋め、 arrayの各要素がobjectとなるようにする。 arrayを返す。 (setq a [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 "When in the course") => "When in the course" (fillarray s ?-) => "------------------" arrayが文字列であり、かつ、objectが文字でなければ、 結果はエラーwrong-type-argumentになる。

配列であることが既知のオブジェクトに対しては、 汎用のシーケンス関数copy-sequenceやlengthがしばしば有用です。 See Sequence Functions。

ベクトル

Lispの配列は、ほとんどの言語の配列と同様に、 その要素を一定時間で参照可能なメモリのブロックです。 ベクトル（vector）は指定長の汎用配列です。 その要素はどんなLispオブジェクトでもかまいません。 （対照的に、文字列は要素としては文字だけを保持する。） Emacsでは、オブジェクト配列obarray（シンボルのベクトル）、 キーマップ（コマンドのベクトル）の一部にベクトルを使っています。 これらは、内部的には、バイトコード関数の表現の一部にも使っています。 そのような関数を表示すると、その中にベクトルがあるのがわかります。

Emacs Lispでは、ベクトルの要素の添字は0から始まります。

ベクトルは要素を角括弧で囲んで表示します。 したがって、要素がシンボルa、b、aであるベクトルは、 [a b a]と表示されます。 Lispへの入力では同じようにベクトルを書きます。

文字列や数と同様に、評価上、ベクトルは定数とみなします。 それを評価した結果は、同じベクトルです。 この評価では、ベクトルの要素を評価したり調べたりはしません。

以下は、これらの原理を例示するものです。

(setq avector [1 two '(three) "four" [five]])
     => [1 two (quote (three)) "four" [five]]
(eval avector)
     => [1 two (quote (three)) "four" [five]]
(eq avector (eval avector))
     => t

ベクトル向け関数

ベクトルに関連した関数はつぎのとおりです。

vectorp object

Function

この関数は、objectがベクトルならばtを返す。 (vectorp [a]) => t (vectorp "asdf") => nil

vector &rest objects

Function

この関数は、引数objectsを要素とするベクトルを作成しそれを返す。 (vector 'foo 23 [bar baz] "rats") => [foo 23 [bar baz] "rats"] (vector) => []

make-vector length object

Function

この関数は、各要素をobjectに初期化した length個の要素から成る新たなベクトルを返す。 (setq sleepy (make-vector 9 'Z)) => [Z Z Z Z Z Z Z Z Z]

vconcat &rest sequences

Function

この関数は、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は、引数としてバイトコード関数でも受け付ける。 これは、バイトコード関数オブジェクトの全内容を簡単に参照できるように するための特別な機能である。 see Byte-Code Objects。 関数vconcatは、引数として整数も受け付ける。 整数はその10進の表示表現の文字列に変換してから、 その文字列を整数のかわりに使う。 この機能を使わないでほしい。 削除する予定である。 読者がこの機能を使っていたら、今すぐプログラムを直すこと！ 整数をこのような10進数に変換する正しい方法は、 format（see Formatting Strings）や number-to-string（see String Conversion）を使うことである。 他の連結関数については、 Mapping Functionsのmapconcat、 Creating Stringsのconcat、 Building Listsのappendを参照。

関数appendは、ベクトルを同じ要素から成るリストへ変換する便利な方法です （see Building Lists）。

(setq avector [1 two (quote (three)) "four" [five]])
     => [1 two (quote (three)) "four" [five]]
(append avector nil)
     => (1 two (quote (three)) "four" [five])

文字テーブル

文字テーブルはベクトルによく似ていますが、 文字コードで添字付けする点が異なります。 修飾子を伴わない任意の正当な文字コードは、文字テーブルの添字に使えます。 文字テーブルの要素は、任意の配列のように、arefやasetで 参照できます。 さらに、文字テーブルでは、 特定の文字コードには対応しない追加データを保持するための追加スロットを 保持できます。 評価時には、文字テーブルは定数です。

各文字テーブルには、シンボルであるサブタイプ（subtype）があります。 サブタイプには2つの目的があります。 異なる使い方をする文字テーブルを区別するためと、 追加スロットの個数を制御するためです。 たとえば、表示テーブルはサブタイプがdisplay-tableである 文字テーブルであり、 構文テーブルはサブタイプがsyntax-tableである文字テーブルです。 正当なサブタイプには、char-table-extra-slots属性があるはずで、 その値は0から10までの整数です。 この整数が文字テーブルの追加スロットの個数を指定します。

文字テーブルは、別の文字テーブルである親を持てます。 その場合、特定の文字cに対する文字テーブルの指定がnilのときには、 親において指定された値を継承します。 いいかえれば、char-table自体にnilを指定してあると、 (aref char-table c)は、 char-tableの親の値を返します。

文字テーブルは、デフォルト値も持てます。 その場合、文字テーブルが指定する値がnilであると、 (aref char-table c)はデフォルト値を返します。

make-char-table subtype &optional init

Function

サブタイプがsubtypeである新たに作成した文字テーブルを返す。 各要素をinitで初期化する。 なお、initのデフォルトはnilである。 文字テーブル作成後には、文字テーブルのサブタイプは変更できない。 文字テーブルの長さを指定する引数はない。 なぜなら、すべての文字テーブルでは、 任意の正当な文字コードを添字として使えるからである。

char-table-p object

Function

この関数は、objectが文字テーブルならばtを返し、 さもなければnilを返す。

char-table-subtype char-table

Function

この関数はchar-tableのサブタイプを表すシンボルを返す。

set-char-table-default char-table new-default

Function

この関数はchar-tableのデフォルト値をnew-defaultにする。 文字テーブルのデフォルト値を参照するための特別な関数はない。 それには(char-table-range char-table nil)を使う。

char-table-parent char-table

Function

この関数はchar-tableの親を返す。 親は、nilであるか他の文字テーブルである。

set-char-table-parent char-table new-parent

Function

この関数はchar-tableの親をnew-parentにする。

char-table-extra-slot char-table n

Function

この関数はchar-tableの追加スロットnの内容を返す。 文字テーブル内の追加スロットの個数はそのサブタイプで決まる。

set-char-table-extra-slot char-table n value

Function

この関数はchar-tableの追加スロットnにvalueを格納する。

文字テーブルでは、1つの文字コードに対して1つの要素値を指定できます。 また、文字集合全体に対して1つの値を指定することもできます。

char-table-range char-table range

Function

これは、char-tableにおいて文字範囲rangeに指定されている値を返す。 rangeとして可能なものは以下のとおり。 nil デフォルト値を指す。 char （charが正当な文字コードであると仮定して） 文字charに対する要素を指す。 charset 文字集合charset全体に対して指定してある値を指す （see Character Sets）。 generic-char 文字集合に対する汎用文字を表す。 引数として汎用文字を指定することは、文字集合名を指定することと同値。 汎用文字の説明は、see Splitting Characters。

set-char-table-range char-table range value

Function

この関数は文字範囲rangeに対するchar-tableの値を設定する。 rangeとして可能なものは以下のとおり。 nil デフォルト値を指す。 t 文字コードの範囲全体を指す。 char （charが正当な文字コードであると仮定して） 文字charに対する要素を指す。 charset 文字集合charset全体に対して指定してある値を指す （see Character Sets）。 generic-char 文字集合に対する汎用文字を表す。 引数として汎用文字を指定することは、文字集合名を指定することと同値。 汎用文字の説明は、see Splitting Characters。

map-char-table function char-table

Function

この関数は、char-tableの各要素についてfunctionを呼び出す。 functionをキーと値の2つの引数で呼び出す。 キーはchar-table-rangeに対する可能なrange引数であり、 正当な文字か汎用文字である。 値は(char-table-range char-table key)である。 全体として、functionに渡すキー・値の対は、 char-tableに格納されたすべての値を表す。 戻り値はつねにnilである。 この関数が有用であるようにするには、 functionには副作用があるべきである。 たとえば、つぎは構文テーブルの各要素の調べ方である。 (let (accumulator) (map-char-table #'(lambda (key value) (setq accumulator (cons (list key value) accumulator))) (syntax-table)) accumulator) => ((475008 nil) (474880 nil) (474752 nil) (474624 nil) ... (5 (3)) (4 (3)) (3 (3)) (2 (3)) (1 (3)) (0 (3)))

ブールベクトル

ブールベクトルはベクトルによく似ていますが、 tとnilの値だけを保存できる点が異なります。 ブールベクトルの要素にnil以外の値を保存しようとすると、 その効果はtを保存することになります。 すべての配列と同様に、ブールベクトルの添字は0から始まり、 ブールベクトルをいったん作成すると長さは変更できません。 評価時には、ブールベクトルは定数です。

ブールベクトルを操作する特別な関数は2つあります。 それに加えて、他の種類の配列を扱う関数でも操作できます。

make-bool-vector length initial

Function

initialに初期化した長さlengthの新たなブールベクトルを返す。

bool-vector-p object

Function

objectがブールベクトルであればtを返し、 さもなければnilを返す。

シンボル

シンボル（symbol）とは、一意な名前が付いたオブジェクトです。 本章では、シンボル、その構成要素、属性リスト、作成方法とインターン方法に ついて説明します。 シンボルの変数としての使用方法、関数名としての使用方法について説明した 別の章もあります。 VariablesとSee Functions。 シンボルの正確な入力構文については、See Symbol Type。

symbolpで、任意のLispオブジェクトがシンボルかどうか調べられます。

symbolp object

Function

この関数は、objectがシンボルならばtを返し、 さもなければnilを返す。

• Symbol Components: Symbols have names, values, function definitions and property lists.
• Definitions: A definition says how a symbol will be used.
• Creating Symbols: How symbols are kept unique.
• Property Lists: Each symbol has a property list for recording miscellaneous information.

シンボルの構成要素

各シンボルには4つの構成要素（つまり、『セル』）があり、 それぞれで別のオブジェクトを参照します。

表示名（print name）

表示名セル（print name cell）には、 シンボルの入力や表示に使う名前である文字列が入っている。 Creating Symbolsのsymbol-nameを参照。

値（value）

値セル（value cell）には、 シンボルの変数としての現在値が入っている。 シンボルをフォームとして使用したとき、 フォームの値はシンボルの値セルの内容である。 Accessing Variablesのsymbol-valueを参照。

関数（function）

関数セル（function cell）には、シンボルの関数定義が入っている。 シンボルを関数として使用したとき、その関数定義を使う。 シンボルが、編集コマンドを実行するためのキーマップやキーボードマクロを 表すときもこのセルを使う。 各シンボルには値セルと関数セルが別々にあるので、 変数名と関数名は衝突しない。 Function Cellsのsymbol-functionを参照。

属性リスト（property list）

属性リストセル（property list cell）には、 シンボルの属性リストが入っている。 Property Listsのsymbol-plistを参照。

表示名セルはつねに文字列を保持していて、変更できません。 他の3つのセルには、任意の指定したLispオブジェクトを個別に設定できます。

表示名セルは、シンボルの名前である文字列を保持しています。 シンボルはテキスト上はその名前で表現されるので、 2つのシンボルが同じ名前を持たないことが重要です。 Lispリーダがこのことを保証します。 シンボルを読み取るたびに、新たにシンボルを作成するまえに、 指定した名前のシンボルが存在するかどうか調べます。 （GNU Emacs Lispでは、これにはハッシュアルゴリズムと オブジェクト配列obarrayを使う。 see Creating Symbols。）

普通の使い方では、関数セルには関数（see Functions）や マクロ（see Macros）が入っていて、 Lispインタープリタはそのように仮定します（see Evaluation）。 シンボルの関数セルには、 キーボードマクロ（see Keyboard Macros）、キーマップ（see Keymaps）、 自動ロードオブジェクト（see Autoloading）が入っていることもあります。 『関数foo』といった場合、実際には、シンボルfooの関数セルに 入っている関数を意味します。 必要な場合に限って区別します。

属性リストセルは、通常、正しい形式の属性リスト（see Property Lists）が 入っている必要があり、さまざまな関数がそのように仮定しています。

関数セルや値セルは空（void）でもかまいません。 つまり、セルはどんなオブジェクトも指していません。 （このことは、シンボルvoidを保持しているとか、 シンボルnilを保持しているのとは違う。） 空である関数セルや値セルを参照すると、 その結果はSymbol's value as variable is void （「変数としてのシンボルの値は空」）のようなエラーになります。

4つの関数、symbol-name、symbol-value、 symbol-plist、symbol-functionは、 シンボルの4つのセルの内容を返します。 以下に、シンボルbuffer-file-nameの 4つのセルの内容を表示する例を示します。

(symbol-name 'buffer-file-name)
     => "buffer-file-name"
(symbol-value 'buffer-file-name)
     => "/gnu/elisp/symbols.texi"
(symbol-plist 'buffer-file-name)
     => (variable-documentation 29529)
(symbol-function 'buffer-file-name)
     => #<subr buffer-file-name>

このシンボルは、カレントバッファで訪問しているファイルの名前を保持するので、 値セルの内容は本書Emacs Lispマニュアルの本章のソースファイルの名前です。 属性リストセルには、リスト(variable-documentation 29529)が入っていて、 ドキュメント関数に対してファイルDOC-versionのどこに 変数buffer-file-nameの説明文字列が入っているか伝えます。 （29529は、当該説明文字列の開始位置を表す DOC-versionの先頭からのオフセット。 Documentation Basicsを参照。） 関数セルには、ファイルの名前を返す関数が入っています。 buffer-file-nameは基本関数の名前です。 これには入力構文はなく、 ハッシュ記法（see Primitive Function Type）で表示されています。 Lispで書いた関数を表すシンボルでは、 このセルにラムダ式（あるいはバイトコードオブジェクト）が入っています。

シンボルを定義する

Lispにおける定義（definition）とは、 特定のシンボルをどのように使うかを意思表示するスペシャルフォームです。 Emacs Lispでは、シンボルを変数と定義したり、 関数（あるいはマクロ）と定義したり、あるいは、それらを独立に定義できます。

定義を行う構文では、典型的には、値を指定したり、 シンボルを特定の使い方をすると指定したりし、 さらに、そのような使い方をしたときの意味を表すための説明文字列を指定します。 したがって、シンボルを変数として定義するときには、 変数に初期値を与え、その変数の説明文字列を指定できます。

defvarとdefconstは、シンボルをグローバル変数として定義する スペシャルフォームです。 これらはDefining Variablesで詳しく説明してあります。 カスタマイズ可能なようにユーザーオプション用の変数を定義するには、 defcustom（see Customization）を使います。

defunは、シンボルを関数として定義し、 ラムダ式を作ってシンボルの関数セルに格納します。 したがって、このラムダ式がシンボルの関数定義になります。 （用語『関数定義』は、関数セルの内容を意味し、 defunがシンボルに関数としての定義を与えることからきている。） defsubstとdefaliasは、関数を定義する別の2つの方法です。 See Functions。

defmacroは、シンボルをマクロとして定義します。 マクロオブジェクトを作ってシンボルの関数セルに格納します。 シンボルは、マクロか関数のいずれかであって、 同時に両方にはならないことに注意してください。 というのは、マクロ定義も関数定義も関数セルに収められ、 そのセルにはどんなときでもたった1つのLispオブジェクトしか 保持できないからです。 See Macros。

Emacs Lispでは、シンボルを変数や関数として使うための 定義は必須ではありません。 したがって、シンボルをあらかじめ定義しようがしまいが、 setqを使ってシンボルをグローバル変数にできます。 定義の真の目的は、プログラマに対する指針であり、プログラミングツールなのです。 これらは、コードを読むプログラマに対して、 特定のシンボルを変数として使うのか関数として使うのか、 その意図を伝えます。 さらに、etagsやmake-docfileなどのユーティリティは、 定義を認識してタグテーブルやファイルDOC-versionに 適切な情報を追加します。 See Accessing Documentation。

シンボルの作成とインターン

GNU Emacs Lispにおいて、どのようにシンボルを作成するかを理解するには、 Lispがそれらをどのように読むかを知る必要があります。 Lispは、同じ文字群を読み取るたびに、同じシンボルをみつけることを保証する 必要があります。 これに失敗すると完全に混乱します。

Lispリーダがシンボルに出会うと、名前の文字群をすべて読み取ります。 そして、これらの文字群を『ハッシュ化』して、 オブジェクト配列（obarray）と呼ばれる表の添字を探します。 ハッシュ化は効率的に探索する手法です。 たとえば、Jan Jonesを電話番号簿の表紙から1ページずつ順に探すかわりに、 Jのページから探し始めます。 これは単純なハッシュ化です。 オブジェクト配列の各要素は、 あるハッシュコードを有するすべてのシンボルを格納した バケット（bucket）です。 ある名前を探すには、その名前のハッシュコードに対応するバケット内の すべてのシンボルを調べるだけで十分です。

目的の名前のシンボルがみつかれば、リーダはそのシンボルを使います。 オブジェクト配列に目的の名前のシンボルがなければ、 リーダは新たなシンボルを作成し、それをオブジェクト配列に追加します。 ある名前のシンボルを探したり追加することをシンボルを インターン（interning）するといい、 そのシンボルをインターンしたシンボル（interned symbol）と呼びます。

インターンすることで、各オブジェクト配列には 特定の名前のシンボルが1個だけあることを保証します。 他の似たような名前のシンボルが存在しても、 同じオブジェクト配列には入っていません。 したがって、同じオブジェクト配列を使って読む限り、 リーダは同じ名前に対して同じシンボルを得ることができます。

すべてのシンボルがオブジェクト配列に入っているとは限りません。 実際、どのオブジェクト配列にも属さないシンボルがいくつかあります。 これらをインターンしてないシンボル（uninterned symbols）と呼びます。 インターンしてないシンボルにも、他のシンボルと同様に4つのセルがあります。 しかし、それを参照する手段は、他のオブジェクトを介して探すか、 変数の値として探すしかありません。

Emacs Lispでは、オブジェクト配列は実際にはベクトルです。 ベクトルの各要素はバケットです。 その値は、そのバケットにハッシュ化される名前のインターンしたシンボルであるか、 そのバケットが空ならば0です。 インターンした各シンボルには、バケットのつぎのシンボルを指す （ユーザーには見えない）内部的なリンクがあります。 このリンクは見えないので、mapatoms（下記）を使う以外には、 オブジェクト配列内のすべてのシンボルを探す方法はありません。 バケット内でのシンボルの順序は関係ありません。

空のオブジェクト配列では、各要素は0です。 (make-vector length 0)でオブジェクト配列を作成できます。 これは、オブジェクト配列を作成する唯一の正当な方法です。 長さとして素数を用いると、ハッシュ化の結果がよい傾向があります。 2の巾より1小さい長さもよい結果になります。

読者自身でオブジェクト配列にシンボルを入れないでください。 うまくいきません。 オブジェクト配列にシンボルを正しく入れられるのはinternだけです。

Common Lispに関した注意： Common Lispでは、1つのシンボルを複数のオブジェクト配列に入れることができる。

下記の関数のほとんどは、引数に名前を取り、 場合によってはオブジェクト配列を引数に取ります。 名前が文字列でなかったり、オブジェクト配列がベクトルでないと、 エラーwrong-type-argumentを通知します。

symbol-name symbol

Function

この関数は、symbolの名前を表す文字列を返す。 たとえば、つぎのとおり。 (symbol-name 'foo) => "foo" 警告： 文字列の文字を置き換えるとシンボルの名前を変更するが、 オブジェクト配列は更新できないので変更しないこと！

make-symbol name

Function

この関数は、name（文字列であること）を名前とする 新たに割り付けたインターンしていないシンボルを返す。 その値と関数定義は空であり、属性リストはnilである。 以下の例では、symの値はfooとeqではない。 なぜなら、名前はfooではあるが、 インターンしていない別のシンボルであるため。 (setq sym (make-symbol "foo")) => foo (eq sym 'foo) => nil

intern name &optional obarray

Function

この関数は、nameを名前とするインターンしたシンボルを返す。 そのようなシンボルがオブジェクト配列obarrayに存在しなければ、 internは新たなものを作成し、それをオブジェクト配列に追加してから、 それを返す。 obarrayを省略すると、グローバル変数obarrayの値を使う。 (setq sym (intern "foo")) => foo (eq sym 'foo) => t (setq sym1 (intern "foo" other-obarray)) => foo (eq sym 'foo) => nil

Common Lispに関した注意： Common Lispでは、既存のシンボルをオブジェクト配列にインターンできる。 Emacs Lispでは、これはできない。 なぜなら、internの引数は文字列である必要があり、 シンボルではない。

intern-soft name &optional obarray

Function

この関数は、obarray内のnameを名前とするシンボルを返す。 ただし、その名前のシンボルがobarrayになければnilを返す。 したがって、intern-softを用いて、指定した名前のシンボルが インターンされているかどうか調べられる。 obarrayを省略すると、グローバル変数obarrayの値を使う。 (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

obarray

Variable

この変数は、internやreadが使う標準のオブジェクト配列。

mapatoms function &optional obarray

Function

この関数は、オブジェクト配列obarrayの各シンボルについて、 1回ずつ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を使った別の例については、 Accessing Documentationのdocumentationを参照。

unintern symbol &optional obarray

Function

この関数は、オブジェクト配列obarrayからsymbolを削除する。 symbolが実際にはオブジェクト配列内になければ、 uninternはなにもしない。 obarrayがnilであると、現在のオブジェクト配列を使う。 symbolのシンボルのかわりに文字列を指定すると、 それはシンボルの名前を表す。 そして、uninternはその名前のシンボルを（あれば）オブジェクト配列から 削除する。 そのようなシンボルがなければ、uninternはなにもしない。 uninternは、シンボルを削除したときにはtを返す。 さもなければnilを返す。

属性リスト

属性リスト（property list、略してplist）とは、 シンボルの属性リストセルに格納された対になった要素から成るリストです。 各対は、属性名（通常、シンボル）を属性、すなわち、属性値に対応付けます。 属性リストは、一般に、シンボルに関する情報を記録します。 変数としての説明文字列、定義されているファイルの名前、 言語理解システムにおいては（語を表す）シンボルの文法クラスなどです。

文字列内やバッファ内の文字位置も属性リストを持てます。 See Text Properties。

属性リスト内の属性名と属性値は、任意のLispオブジェクトでかまいませんが、 普通、属性名はシンボルです。 属性リスト関数は、eqを使って属性名を比較します。 コンパイラをロードした際のシンボルprognの属性リストをつぎに示します。

(lisp-indent-function 0 byte-compile byte-compile-progn)

ここで、lisp-indent-functionやbyte-compileは属性名であり、 他の2つの要素は対応する属性値です。

• Plists and Alists: Comparison of the advantages of property lists and association lists.
• Symbol Plists: Functions to access symbols' property lists.
• Other Plists: Accessing property lists stored elsewhere.

属性リストと連想リスト

連想リスト（see Association Lists）は、 属性リストに非常によく似ています。 連想リストと異なり、属性名は一意である必要があるので、 属性リスト内での対の出現順序は関係ありません。

さまざまなLisp関数やLisp変数に情報を付加するには、 属性リストは連想リストより優れています。 読者のプログラムで1つの連想リストにすべての連想を入れておいたとすると、 1つの連想を探すたびに、リスト全体を探索する必要があります。 これには時間がかかります。 一方、同じ情報を関数名や変数自身の属性リストに保持しておけば、 各探索では1つの属性リストを走査するだけでよく、 属性リストは、普通、短いものです。 このため、変数の説明文字列をvariable-documentationという名前の 属性に記録しているのです。 同様に、バイトコンパイラも、 特別な処理が必要な関数を属性を使って記録しています。

しかしながら、連想リストにもそれ独自の利点があります。 読者のアプリケーションに依存しますが、 属性を更新するより、連想リストの先頭に連想を追加するほうが速いです。 あるシンボルのすべての属性は同一の属性リストに格納してあるので、 1つの属性名を異なる目的に使うと衝突します。 （この理由から、プログラムで普通に使う 変数名や関数名の接頭辞で始まる属性名を選ぶなどして、 一意な属性名を選ぶのがよい。） 連想リストは、リストの先頭に要素を追加し、先頭から要素を削除するので、 スタックのように使えます。 属性リストでは、これは不可能です。

シンボル向け属性リスト関数

symbol-plist symbol

Function

この関数はsymbolの属性リストを返す。

setplist symbol plist

Function

この関数は、symbolの属性リストを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) 普通の使い方を意図していない特別なオブジェクト配列内のシンボルに対しては、 属性リストセルの非標準な使い方にも意味があろう。 実際、略語機構（see Abbrevs）ではそのようにしている。

get symbol property

Function

この関数は、symbolの属性リストから propertyという名前の属性の値を探す。 そのような属性がなければ、nilを返す。 つまり、nilという値と属性の欠如を区別できない。 名前propertyは既存の属性名とeqで比較するため、 どんなオブジェクトでも正当な属性である。 例については、putを参照。

put symbol property value

Function

この関数は、symbolの属性リストにおいて、 属性名propertyの古い属性値をvalueで置き換える。 関数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))

シンボルの外部の属性リスト

シンボル以外の場所に保存した属性リストの操作に便利な2つの関数があります。

plist-get plist property

Function

これは、属性リストplistに保存されている属性propertyの値を返す。 たとえば、つぎのとおり。 (plist-get '(foo 4) 'foo) => 4

plist-put plist property value

Function

これは、属性リストplistに、 propertyの値としてvalueを格納する。 これはplistを破壊的に変更するか、あるいは、 古いものを変更せずに新たなリスト構造を構築する。 関数は変更した属性リストを返すので、 plistを保持していたところへ保存し直せる。 たとえば、つぎのとおり。 (setq my-plist '(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))

つぎのようにして、plist-putを用いてputを定義できます。

(defun put (symbol prop value)
  (setplist symbol
            (plist-put (symbol-plist symbol) prop value)))

評価

Emacs Lispにおける式の評価（evaluation）は、 Lispインタープリタ（Lisp interpreter）が行います。 これは、入力としてLispオブジェクトを受け取り、 式としての値を計算するプログラムです。 計算方法は、本章で述べる規則に従ってオブジェクトのデータ型に依存します。 インタープリタは、読者のプログラムのある部分を評価するために 自動的に動作しますが、Lisp基本関数evalを介して インタープリタを明示的に呼ぶ出すこともできます。

評価することを意図したLispオブジェクトを 式（expression）とかフォーム（form）と呼びます。 式はデータオブジェクトであり単なるテキストではないという事実は、 Lisp様言語と典型的なプログラム言語との基本的な違いの1つです。 どんなオブジェクトでも評価できますが、実用上は、 数、シンボル、リスト、文字列を評価することが多いのです。

Lisp式を読み取りその式を評価することはとても一般的なことですが、 読み取りと評価は別々の動作であり、それぞれを別々に実行することもできます。 読み取り自体では、なにも評価しません。 Lispオブジェクトの表示表現をオブジェクトそのものに変換します。 このオブジェクトを評価すべきフォームとするか、 まったく別の目的に使うかは、readの呼び出し側で決まります。

評価とコマンドキーの解釈を混同しないでください。 エディタコマンドループは、有効なキーマップを用いて キーボード入力をコマンド（対話的に呼び出し可能な関数）に変換し、 call-interactivelyを使ってコマンドを起動します。 コマンドがLispで書いてあれば、 コマンド自体の実行には評価が関わってきますが、 そのことは、コマンドキーの解釈自体には含まれていません。

評価は再帰的な処理です。 つまり、フォームの評価では、 evalを呼び出してそのフォームの一部分を評価することもあります。 たとえば、関数呼び出しの評価においては、まず、 関数呼び出しの各引数を評価してから、関数本体の各フォームを評価します。 (car x)の評価を考えてみましょう。 まず最初にxを再帰的に評価する必要があります。 その値を関数carの引数として渡せるようにするのです。

関数呼び出しの評価においては、最終的に指定した関数を呼び出します。 See Functions。 関数の実行そのものも、関数定義を評価する場合もあります。 あるいは、関数はC言語で実装されたLisp基本関数かもしれませんし、 バイトコード関数かもしれません（see Byte Compilation）。

フォームの評価は、環境（environment）と呼ばれる文脈において 行われます。 環境とは、すべてのLisp変数の現在値と束縛です ⁷。 フォームが新たな束縛を作らずに変数を参照する場合には、 現在の環境におけるその変数の束縛の値を使います。 See Variables。

フォームを評価すると、変数（see Local Variables）を束縛して、 再帰的評価のための新たな環境を作ることがあります。 これらの環境は一時的なもので、そのフォームの評価を完了すると 消えてしまいます。 フォームは恒久的な変更を行ってもかまいません。 このような変更を副作用（side effects）と呼びます。 副作用を持つフォームの例は、(setq foo 1)です。

フォームの各種類ごとの評価の意味の詳細は、 以下で説明します（see Forms）。

フォームの種類

評価することを意図したLispオブジェクトをフォーム（form）と呼びます。 Emacsがどのようにフォームを評価するかは、そのデータ型に依存します。 Emacsには、評価方法が異なる3種類のフォームがあります。 シンボル、リスト、および、『その他すべての型』です。 本節では、3種類すべてについて1つ1つ説明します。 まず、自己評価型フォームである『その他すべての型』から説明します。

• Self-Evaluating Forms: Forms that evaluate to themselves.
• Symbol Forms: Symbols evaluate as variables.
• Classifying Lists: How to distinguish various sorts of list forms.
• Function Indirection: When a symbol appears as the car of a list, we find the real function via the symbol.
• Function Forms: Forms that call functions.
• Macro Forms: Forms that call macros.
• Special Forms: ``Special forms'' are idiosyncratic primitives, most of them extremely important.
• Autoloading: Functions set up to load files containing their real definitions.

自己評価型フォーム

自己評価型フォーム（self-evaluating form）とは、 リストでもシンボルでもない任意のフォームのことです。 自己評価型フォームはそれ自身に評価され、 評価結果は評価されるオブジェクトと同じものです。 つまり、数25は25と評価され、 文字列"foo"は文字列"foo"と評価されます。 同様に、ベクトルを評価してもベクトルの個々の要素を評価することはありません。 その内容をまったく変更することなく、同じベクトルを返します。

'123               ; 評価していない数
     => 123
123                ; 普通どおり評価。結果は同じ
     => 123
(eval '123)        ; 『手で』評価。結果は同じ
     => 123
(eval (eval '123)) ; 2回評価してもなにも変わらない
     => 123

Lispコードにおいては、数、文字、文字列、さらにベクトルでさえも、 それらが自己評価型である事実を利用して書くのが普通です。 しかし、入力構文を持たない型については、このようにしません。 というのは、それらをテキストとして書く方法がないからです。 そのような型を含むLisp式を構成するには、Lispプログラムを使います。

;; バッファオブジェクトを含む式を作る
(setq print-exp (list 'print (current-buffer)))
     => (print #<buffer eval.texi>)
;; それを評価する
(eval print-exp)
     -| #<buffer eval.texi>
     => #<buffer eval.texi>

シンボルフォーム

シンボルを評価するときには、シンボルを変数として扱います。 その結果は、値があれば、変数の値です。 （値セルが空であり）値がなければ、エラーを通知します。 変数の使い方について詳しくは、See Variables。

つぎの例では、setqを使ってシンボルの値を設定します。 そのあとでシンボルを評価すると、setqで保存した値を取り出せます。

(setq a 123)
     => 123
(eval 'a)
     => 123
a
     => 123

シンボルnilとtは特別に扱い、 nilの値はつねにnilであり、 tの値はつねにtです。 これらに別の値を設定したり、別の値を束縛することはできません。 したがって、evalはこれらを他のシンボルと同様に扱いますが、 これら2つのシンボルは自己評価型フォームのようにふるまいます。 :で始まる名前のシンボルも同じ意味で自己評価型であり、 同様に、その値を変更できません。 See Constant Variables。

リストフォームの分類

フォームが空ではないリストならば、その最初の要素に依存して、 関数呼び出し、マクロ呼び出し、スペシャルフォームのいずれかです。 これらの3種類のフォームは、以下に説明するように、異なる方法で評価されます。 リストの残りの要素は、関数、マクロ、スペシャルフォームの 引数（arguments）になります。

空ではないリストを評価する最初の手順は、 その先頭要素を調べることです。 この要素は、それだけで、空ではないリストのフォームの種類を決定し、 リストの残りをどのように処理するかを決定します。 SchemeなどのLispの一部の方言と違って、先頭要素は評価しません。

シンボルの関数間接

リストの先頭要素がシンボルであると、 評価処理ではシンボルの関数セルを調べ、 もとのシンボルのかわりにその内容を使います。 その内容が別のシンボルであると、 シンボルの関数間接（symbol function indirection）と呼ばれる この処理をシンボルでないものを得るまで繰り返します。 シンボルの関数セルに格納された関数名としてのシンボルの使い方について 詳しくは、See Function Names。

この処理の結果、無限ループになる場合もあります。 つまり、シンボルの関数セルが同じシンボルを指している場合です。 あるいは、シンボルの関数セルが空の場合もありえます。 その場合、サブルーティンsymbol-functionは、 エラーvoid-functionを通知します。 いずれの場合でもなければ、最終的にはシンボルでないものを取得し、 それは関数などの適切なオブジェクトであるはずです。

より正確にいえば、Lisp関数（ラムダ式）、バイトコード関数、 基本関数、Lispマクロ、スペシャルフォーム、自動ロードオブジェクトの いずれかを取得しているはずです。 これらの各種類ごとに、以下の1つ1つの節で説明します。 オブジェクトがこれらのいずれの型でもない場合には、 エラーinvalid-functionを通知します。

つぎの例は、シンボルの関数間接の処理を図示したものです。 fsetを使ってシンボルの関数セルに設定し、 symbol-functionを使って関数セルの内容を取り出します （see Function Cells）。 具体的には、シンボルcarをfirstの関数セルに格納し、 シンボルfirstをersteの関数セルに格納します。

;; このような関数セルのリンクを作る
;;   -------------       -----        -------        -------
;;  | #<subr car> | <-- | car |  <-- | first |  <-- | erste |
;;   -------------       -----        -------        -------

(symbol-function 'car)
     => #<subr car>
(fset 'first 'car)
     => car
(fset 'erste 'first)
     => first
(erste '(1 2 3))   ; ersteが指す関数を呼び出す
     => 1

一方、つぎの例では、シンボルの関数間接を使わずに関数を呼び出します。 というのは、先頭引数はLispの無名関数であって、 シンボルではないからです。

((lambda (arg) (erste arg))
 '(1 2 3))
     => 1

関数を実行することは、その本体を評価することです。 この過程では、ersteを呼び出すときにシンボルの関数間接が関わります。

組み込み関数indirect-functionは、 明示的にシンボルの関数間接を行う簡単な方法です。

indirect-function function

Function

この関数は、関数としてのfunctionの意味を返す。 functionがシンボルであればfunctionの関数定義を探し、 その値から再度繰り返す。 functionがシンボルでなければfunctionそのものを返す。 Lispでindirect-functionを定義するとつぎのようになる。 (defun indirect-function (function) (if (symbolp function) (indirect-function (symbol-function function)) function))

関数フォームの評価

評価すべきリストの先頭要素が、Lisp関数オブジェクト、 バイトコードオブジェクト、基本関数オブジェクトの場合、 そのリストは関数呼び出し（function call）です。 たとえば、つぎは、関数+の呼び出しです。

(+ 1 x)

関数呼び出しを評価する最初の手順は、 リストの残りの要素を左から右へ順に評価することです。 その結果は実引数の値になり、1つの値がリストの1つの要素に対応します。 つぎの手順は、引数のリストで関数を呼び出すことで、 実質的には、関数apply（see Calling Functions）を使います。 関数がLispで書いてあれば、関数の引数変数を束縛するために引数を使います （see Lambda Expressions）。 そして、関数本体のフォーム群を順番に評価し、 本体の最後のフォームの値が関数呼び出しの値になります。

Lispマクロの評価

評価すべきリストの先頭要素がマクロオブジェクトの場合、 そのリストはマクロ呼び出し（macro call）です。 マクロ呼び出しを評価するときは、リストの残りの要素を評価しません。 そのかわりに、要素そのものをマクロの引数として使います。 マクロ定義は、 マクロの展開形（expansion）と呼ばれる置換フォームを計算し、 もとのフォームのかわりに展開形を評価します。 展開形は、どんな種類のフォームでもかまいません。 自己評価型の定数、シンボル、あるいは、リストです。 展開形そのものがマクロ呼び出しであると、 マクロ呼び出し以外のフォームを得られるまで、 展開形を得る処理を繰り返します。

通常のマクロ呼び出しの評価は、展開形を評価することで完了します。 しかし、マクロの展開形を必ずしもただちに評価する必要はなく、 まったく評価しなくてもかまいません。 というのは、別のプログラムもマクロ呼び出しを展開し、 それらは展開形を評価するものもあれば、評価しないものもあるからです。

普通、引数の式は、マクロ展開の計算過程では評価せず、 展開形の一部として現れます。 そして、展開形を評価するときに引数が計算されます。

たとえば、つぎのようなマクロ定義があったとします。

(defmacro cadr (x)
  (list 'car (list 'cdr x)))

(cadr (assq 'handler list))のような式はマクロ呼び出しであり、 つぎのような展開形になります。

(car (cdr (assq 'handler list)))

引数(assq 'handler list)が展開形に現れていることに 注意してください。

Emacs Lispのマクロに関する完全な記述は、See Macros。

スペシャルフォーム

スペシャルフォーム（special form）は、 その引数を評価しないように特別な印が付いた基本関数です。 ほとんどのスペシャルフォームは、制御構造を定義したり、 変数を束縛したりします。 これらはどれも関数ではできないことです。

各スペシャルフォームには、どの引数は評価し、 どの引数は評価せずに使うかといったそれぞれに独自の規則があります。 特定の引数を評価するかどうかは、他の引数の評価結果に依存することもあります。

以下に、Emacs Lispのすべてのスペシャルフォームをアルファベット順に、 参照箇所とともにあげておきます。

and

see Combining Conditions

catch

see Catch and Throw

cond

see Conditionals

condition-case

see Handling Errors

defconst

see Defining Variables

defmacro

see Defining Macros

defun

see Defining Functions

defvar

see Defining Variables

function

see Anonymous Functions

if

see Conditionals

interactive

see Interactive Call

let

let*

see Local Variables

or

see Combining Conditions

prog1

prog2

progn

see Sequencing

quote

see Quoting

save-current-buffer

see Current Buffer

save-excursion

see Excursions

save-restriction

see Narrowing

save-window-excursion

see Window Configurations

setq

see Setting Variables

setq-default

see Creating Buffer-Local

track-mouse

see Mouse Tracking

unwind-protect

see Nonlocal Exits

while

see Iteration

with-output-to-temp-buffer

see Temporary Displays

Common Lispに関した注意： GNU Emacs LispとCommon Lispのスペシャルフォームを比較してみる。 setq、if、および、catchは、Emacs Lispでも Common Lispでもスペシャルフォームである。 defunは、Emacs Lispではスペシャルフォームであるが、 Common Lispではマクロである。 save-excursionは、Emacs Lispではスペシャルフォームであるが、 Common Lispには存在しない。 throwは、Common Lispでは（複数の値を返す必要があるため） スペシャルフォームであるが、 Emacs Lispでは（複数の値はないため）関数である。

自動ロード

自動ロード（autoload）は、 関数やマクロの関数定義をEmacsにまだロードしていなくても、 関数やマクロを呼び出せるようにする機構です。 定義を収めたファイルを指定します。 シンボルの関数定義に自動ロードオブジェクトあるとき、 そのシンボルを関数として呼び出すと、指定したファイルを自動的にロードします。 そうしてから、当該ファイルからロードした実際の定義を呼び出します。 See Autoload。

クォート

スペシャルフォームquoteは、単一の引数を 評価せずに書かれたとおりに返します。 これは、自己評価型オブジェクトではない 定数シンボルや定数リストをプログラム内に書く手段です。 （数、文字列、ベクトルなどの自己評価型オブジェクトをクォートする必要はない。）

quote object

Special Form

このフォームはobjectを評価せずに返す。

quoteはプログラム内で頻繁に使うので、 Lispには便利な入力構文が用意してあります。 アポストロフ文字（'）に続けた（入力構文で書いた）Lispオブジェクトは、 先頭要素がquoteであり2番目の要素がそのオブジェクトである リストに展開されます。 したがって、入力構文'xは、(quote x)の省略形です。

quoteを使った式の例をいくつかあげておきます。

(quote (+ 1 2))
     => (+ 1 2)
(quote foo)
     => foo
'foo
     => foo
''foo
     => (quote foo)
'(quote foo)
     => (quote foo)
['foo]
     => [(quote foo)]

他のクォートの書き方には、function（see Anonymous Functions）が あります。 これは、Lispで書いた無名ラムダ式をコンパイルするようにします。 また、`（see Backquote）は、 リストの一部分をクォートし、他の部分は計算結果で置き換えるために使います。

評価（eval）

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

本節で説明した関数や変数は、フォームを評価したり、 評価処理に制限を課したり、最後の戻り値を記録したりします。 ファイルをロードしても評価が行われます（see Loading）。

注意： データ構造の中に関数を格納して それをfuncallやapplyで呼び出すほうが、 データ構造の中に式を格納してそれを評価するより、 一般に明確で柔軟性があります。 関数を使うとそれらに引数として情報を渡すことができます。

eval form

Function

この関数は、式を評価する基本的な関数である。 formを現在の環境において評価し、その結果を返す。 評価処理はオブジェクトの型に依存する（see Forms）。 evalは関数なので、evalの呼び出しに現れる 引数の式は2度評価される。 evalを呼び出すまえの準備で1回、 関数eval自身による評価でもう1回である。 例を示す。 (setq foo 'bar) => bar (setq bar 'baz) => baz ;; evalは引数fooを受け取る (eval 'foo) => bar ;; evalは引数barを受け取る。それはfooの値 (eval foo) => baz evalの呼び出しの深さは、 max-lisp-eval-depth（下記参照）に制限される。

eval-region start end &optional stream read-function

コマンド

この関数は、カレントバッファのstartとendで指定した リージョン内のフォーム群を評価する。 リージョンからフォームを読み取り、 それらに対してevalを呼び出すことを リージョンの末尾に達するまで、あるいは、処理されないエラーが通知されるまで 繰り返す。 streamがnil以外ならば、 リージョン内の式を評価した結果の値はstreamを使って表示する。 see Output Streams。 read-functionがnil以外にならば、 それは関数である必要があり、 readのかわりに式を1つ1つ読むために使われる。 この関数は、入力用のストリームである1つの引数で呼び出される。 変数load-read-function（see How Programs Do Loading）を 使ってこの関数を指定することもできるが、 引数read-functionを用いたほうが堅牢である。 eval-regionはつねにnilを返す。

eval-current-buffer &optional stream

コマンド

これはeval-regionと同様だが、バッファ全体に作用する。

max-lisp-eval-depth

Variable

この変数は、 （エラーメッセージ"Lisp nesting exceeds max-lisp-eval-depth"で） エラーを通知までのeval、apply、funcallの呼び出しの 最大の深さを制限する。 この制限、および、これを超えたときのエラーは、 不正に定義された関数によってLispが無限に再帰することを防止する 1つの方法である。 深さ制限は、Lispコードによる明示的な呼び出しに加えて、 Lisp式で書かれた関数の呼び出しや関数呼び出しの引数や関数本体のフォームの 再帰的な評価などの内部的なeval、apply、funcallの 呼び出しも数える。 この変数のデフォルト値は300。 これに100未満の値を設定すると、指定した値に達するとLispは100に設定し直す。 Lispデバッガに入ったとき、 制限に近い場合にはデバッガ自身が実行できることを保証するために値を増やす。 max-specpdl-sizeは、入れ子の深さを制限する別の方法である。 see Local Variables。

values

Variable

この変数の値は、 バッファから式を読み取り、評価し、結果を表示するEmacsの標準コマンドが行った すべての式の戻り値のリストである。 リストの順序は、最新のものが最初にくる。 (setq x 1) => 1 (list 'A (1+ 2) auto-save-default) => (A 3 t) values => ((A 3 t) 1 ...) この変数は、最近評価したフォームの値を参照するのに便利である。 valuesそのものの値の表示は非常に長くなる可能性があるので、 その値を表示するのはよくない。 そのかわりに、つぎのようにして特定の要素を調べる。 ;; もっとも最近の評価結果を参照する (nth 0 values) => (A 3 t) ;; こうすると、新たな要素が追加され、 ;; すべての要素が1つうしろへさがる (nth 1 values) => (A 3 t) ;; この例を実行するまえの最新のもののつぎの要素を取得する (nth 3 values) => 1

制御構造

Lispプログラムは、式、すなわち、フォーム（forms、see Forms）から 成ります。 フォームを制御構造（control structures）で囲むことで、 フォームの実行順序を制御します。 制御構造はスペシャルフォームであり、 その内側にあるフォームの実行をいつ行うか、行わないか、 何回行うかを制御します。

もっとも単純な実行順序は逐次実行です。 最初のフォームaを実行し、 それからつぎのフォームbを実行し、といった具合です。 関数の本体やLispコードのファイルのトップレベルに複数のフォームを順に書くと、 このようになります。 つまり、書かれている順番にフォームを実行します。 これをテキスト上の順序（textual order）と呼びます。 たとえば、関数本体が2つのフォームaとbから成る場合、 関数を評価すると、まずaを評価し、つぎにbを評価して、 関数の値はbの値になります。

明示的な制御構造により、逐次実行以外の実行順序が可能になります。

Emacs Lispには数種類の制御構造があり、 逐次実行の変形、条件付き実行、繰り返し実行、 （制御された）ジャンプなどです。 これらすべては、以下に説明します。 組み込みの制御構造はスペシャルフォームです。 というのは、それらのサブフォームは必ずしも評価しませんし、 逐次評価するわけでもないからです。 マクロを使えば、独自の制御構造の構文を定義できます（see Macros）。

• Sequencing: Evaluation in textual order.
• Conditionals: if, cond, when, unless.
• Combining Conditions: and, or, not.
• Iteration: while loops.
• Nonlocal Exits: Jumping out of a sequence.

逐次実行

現れる順番にフォームを評価することは、 1つのフォームから別のフォームへ制御を移すもっとも一般的な方法です。 関数本体などのある種の文脈では、自動的にこのようになります。 それ以外では、これを行う制御構造の構文を使う必要があります。 prognがその制御構造で、Lispのもっとも単純な制御構造です。

スペシャルフォームprognはつぎのような形です。

(progn a b c ...)

これは、フォーム、a、b、c、…をこの順に評価します。 これらのフォームをprognフォームの本体と呼びます。 本体の最後のフォームの値が、progn全体の値になります。

初期のころのLispでは、prognは、 2つ以上のフォームを逐次実行しそれらの最後の値を使う唯一の方法でした。 しかし、プログラマは、（当時は）1つのフォームしか許されていない 関数の本体では、 prognを使う必要がしばしばあることに気づきました。 そのため、関数本体を『暗黙のprogn』にしたのです。 つまり、実際のprognの本体のように、 複数のフォームを許すようにしたのです。 多くの他の制御構造も、同様に、暗黙のprognです。 その結果、prognは、かつてほどは多用されません。 現在では、unwind-protect、and、orの内側や、 ifのthen部分で必要とされるのがほとんどです。

progn forms...

Special Form

このスペシャルフォームは、formsのフォームすべてを テキスト上の順に評価し、最後のフォームの結果を返す。 (progn (print "The first form") (print "The second form") (print "The third form")) -| "The first form" -| "The second form" -| "The third form" => "The third form"

他の2つの制御構造も同様にフォームを逐次評価しますが、 返す値が異なります。

prog1 form1 forms...

Special Form

このスペシャルフォームは、form1、formsのフォームすべてを テキスト上の順に評価し、form1の結果を返す。 (prog1 (print "The first form") (print "The second form") (print "The third form")) -| "The first form" -| "The second form" -| "The third form" => "The first form" 変数のリストから先頭要素を取り除き、取り除いた要素を返すにはつぎのように書く。 (prog1 (car x) (setq x (cdr x)))

prog2 form1 form2 forms...

Special Form

このスペシャルフォームは、form1、form2、formsの フォームすべてをテキスト上の順に評価し、form2の結果を返す。 (prog2 (print "The first form") (print "The second form") (print "The third form")) -| "The first form" -| "The second form" -| "The third form" => "The second form"

条件付き実行

条件付き制御構造は、選択肢を選びます。 Emacs Lispには、4つの条件付きフォームがあります。 他の言語のものとほとんど同じif、 ifの変形であるwhenやunless、 一般化したcase文であるcondです。

if condition then-form else-forms...

Special Form

ifは、conditionをもとにして、 then-formかelse-formsを選ぶ。 conditionがnil以外に評価されると、 then-formを評価し、その結果を返す。 さもなければ、else-formsをテキスト上の順に評価し、 その最後のものの値を返す。 （ifのelse部分は、暗黙のprognの例である。 see Sequencing。） conditionが値nilであり、かつ、else-formsがないと、 ifはnilを返す。 ifがスペシャルフォームであるのは、 選択しなかった分岐をけっして評価しないからである。 したがって、つぎの例では、 printはけっして呼ばれないためtrueは表示されない。 (if nil (print 'true) 'very-false) => very-false

when condition then-forms...

Macro

これはifの変形であり、else-formsがなく、 then-formsは複数のフォームでもよい。 特に、 (when condition a b c) は、つぎとまったく等価である。 (if condition (progn a b c) nil)