[Top] [Contents] [Index] [ ? ]

ANSI and GNU Common Lisp Document

1. Introduction  
2. Syntax  
3. Evaluation and Compilation  
4. Types and Classes  
5. Data and Control Flow  
6. Iteration  
7. Objects  
8. Structures  
9. Conditions  
10. Symbols  
11. Packages  
12. Numbers  
13. Characters  
14. Conses  
15. Arrays  
16. Strings  
17. Sequences  
18. Hash Tables  
19. Filenames  
20. Files  
21. Streams  
22. Printer  
23. Reader  
24. System Construction  
25. Environment  
26. Glossary  
27. Appendix  

 -- The Detailed Node Listing ---

Introduction

1.1 Scope, Purpose, and History  
1.2 Organization of the Document  
1.3 Referenced Publications  
1.4 Definitions  
1.5 Conformance  
1.6 Language Extensions  
1.7 Language Subsets  
1.8 Deprecated Language Features  
1.9 Symbols in the COMMON-LISP Package  

Scope, Purpose, and History

1.1.1 Scope and Purpose  
1.1.2 History  

Definitions

1.4.1 Notational Conventions  
1.4.2 Error Terminology  
1.4.3 Sections Not Formally Part Of This Standard  
1.4.4 Interpreting Dictionary Entries  

Notational Conventions

1.4.1.1 Font Key  
1.4.1.2 Modified BNF Syntax  
1.4.1.3 Splicing in Modified BNF Syntax  
1.4.1.4 Indirection in Modified BNF Syntax  
1.4.1.5 Additional Uses for Indirect Definitions in Modified BNF Syntax  
1.4.1.6 Special Symbols  
1.4.1.7 Objects with Multiple Notations  
1.4.1.8 Case in Symbols  
1.4.1.9 Numbers  
1.4.1.10 Use of the Dot Character  
1.4.1.11 NIL  
1.4.1.12 Designators  
1.4.1.13 Nonsense Words  

Interpreting Dictionary Entries

1.4.4.1 The "Affected By" Section of a Dictionary Entry  
1.4.4.2 The "Arguments" Section of a Dictionary Entry  
1.4.4.3 The "Arguments and Values" Section of a Dictionary Entry  
1.4.4.4 The "Binding Types Affected" Section of a Dictionary Entry  
1.4.4.5 The "Class Precedence List" Section of a Dictionary Entry  
1.4.4.6 Dictionary Entries for Type Specifiers  
1.4.4.7 The "Compound Type Specifier Kind" Section of a Dictionary Entry  
1.4.4.8 The "Compound Type Specifier Syntax" Section of a Dictionary Entry  
1.4.4.9 The "Compound Type Specifier Arguments" Section of a Dictionary Entry  
1.4.4.10 The "Compound Type Specifier Description" Section of a Dictionary Entry  
1.4.4.11 The "Constant Value" Section of a Dictionary Entry  
1.4.4.12 The "Description" Section of a Dictionary Entry  
1.4.4.13 The "Examples" Section of a Dictionary Entry  
1.4.4.14 The "Exceptional Situations" Section of a Dictionary Entry  
1.4.4.15 The "Initial Value" Section of a Dictionary Entry  
1.4.4.16 The "Argument Precedence Order" Section of a Dictionary Entry  
1.4.4.17 The "Method Signature" Section of a Dictionary Entry  
1.4.4.18 The "Name" Section of a Dictionary Entry  
1.4.4.19 The "Notes" Section of a Dictionary Entry  
1.4.4.20 The "Pronunciation" Section of a Dictionary Entry  
1.4.4.21 The "See Also" Section of a Dictionary Entry  
1.4.4.22 The "Side Effects" Section of a Dictionary Entry  
1.4.4.23 The "Supertypes" Section of a Dictionary Entry  
1.4.4.24 The "Syntax" Section of a Dictionary Entry  
1.4.4.25 Special "Syntax" Notations for Overloaded Operators  
1.4.4.26 Naming Conventions for Rest Parameters  
1.4.4.27 Requiring Non-Null Rest Parameters in the "Syntax" Section  
1.4.4.28 Return values in the "Syntax" Section  
1.4.4.29 No Arguments or Values in the "Syntax" Section  
1.4.4.30 Unconditional Transfer of Control in the "Syntax" Section  
1.4.4.31 The "Valid Context" Section of a Dictionary Entry  
1.4.4.32 The "Value Type" Section of a Dictionary Entry  

Conformance

1.5.1 Conforming Implementations  
1.5.2 Conforming Programs  

Conforming Implementations

1.5.1.1 Required Language Features  
1.5.1.2 Documentation of Implementation-Dependent Features  
1.5.1.3 Documentation of Extensions  
1.5.1.4 Treatment of Exceptional Situations  
1.5.1.5 Resolution of Apparent Conflicts in Exceptional Situations  
1.5.1.6 Examples of Resolution of Apparent Conflict in Exceptional Situations  
1.5.1.7 Conformance Statement  

Conforming Programs

1.5.2.1 Use of Implementation-Defined Language Features  
1.5.2.2 Use of Read-Time Conditionals  

Deprecated Language Features

1.8.1 Deprecated Functions  
1.8.2 Deprecated Argument Conventions  
1.8.3 Deprecated Variables  
1.8.4 Deprecated Reader Syntax  

Syntax

2.1 Character Syntax  
2.2 Reader Algorithm  
2.3 Interpretation of Tokens  
2.4 Standard Macro Characters  

Character Syntax

2.1.1 Readtables  
2.1.2 Variables that affect the Lisp Reader  
2.1.3 Standard Characters  
2.1.4 Character Syntax Types  

Readtables

2.1.1.1 The Current Readtable  
2.1.1.2 The Standard Readtable  
2.1.1.3 The Initial Readtable  

Character Syntax Types

2.1.4.1 Constituent Characters  
2.1.4.2 Constituent Traits  
2.1.4.3 Invalid Characters  
2.1.4.4 Macro Characters  
2.1.4.5 Multiple Escape Characters  
2.1.4.6 Examples of Multiple Escape Characters  
2.1.4.7 Single Escape Character  
2.1.4.8 Examples of Single Escape Characters  
2.1.4.9 Whitespace Characters  
2.1.4.10 Examples of Whitespace Characters  

Interpretation of Tokens

2.3.1 Numbers as Tokens  
2.3.2 Constructing Numbers from Tokens  
2.3.3 The Consing Dot  
2.3.4 Symbols as Tokens  
2.3.5 Valid Patterns for Tokens  
2.3.6 Package System Consistency Rules  

Numbers as Tokens

2.3.1.1 Potential Numbers as Tokens  
2.3.1.2 Escape Characters and Potential Numbers  
2.3.1.3 Examples of Potential Numbers  

Constructing Numbers from Tokens

2.3.2.1 Syntax of a Rational  
2.3.2.2 Syntax of an Integer  
2.3.2.3 Syntax of a Ratio  
2.3.2.4 Syntax of a Float  
2.3.2.5 Syntax of a Complex  

Standard Macro Characters

2.4.1 Left-Parenthesis  
2.4.2 Right-Parenthesis  
2.4.3 Single-Quote  
2.4.4 Semicolon  
2.4.5 Double-Quote  
2.4.6 Backquote  
2.4.7 Comma  
2.4.8 Sharpsign  
2.4.9 Re-Reading Abbreviated Expressions  

Single-Quote

2.4.3.1 Examples of Single-Quote  

Semicolon

2.4.4.1 Examples of Semicolon  
2.4.4.2 Notes about Style for Semicolon  
2.4.4.3 Use of Single Semicolon  
2.4.4.4 Use of Double Semicolon  
2.4.4.5 Use of Triple Semicolon  
2.4.4.6 Use of Quadruple Semicolon  
2.4.4.7 Examples of Style for Semicolon  

Backquote

2.4.6.1 Notes about Backquote  

Sharpsign

2.4.8.1 Sharpsign Backslash  
2.4.8.2 Sharpsign Single-Quote  
2.4.8.3 Sharpsign Left-Parenthesis  
2.4.8.4 Sharpsign Asterisk  
2.4.8.5 Examples of Sharpsign Asterisk  
2.4.8.6 Sharpsign Colon  
2.4.8.7 Sharpsign Dot  
2.4.8.8 Sharpsign B  
2.4.8.9 Sharpsign O  
2.4.8.10 Sharpsign X  
2.4.8.11 Sharpsign R  
2.4.8.12 Sharpsign C  
2.4.8.13 Sharpsign A  
2.4.8.14 Sharpsign S  
2.4.8.15 Sharpsign P  
2.4.8.16 Sharpsign Equal-Sign  
2.4.8.17 Sharpsign Sharpsign  
2.4.8.18 Sharpsign Plus  
2.4.8.19 Sharpsign Minus  
2.4.8.20 Sharpsign Vertical-Bar  
2.4.8.21 Examples of Sharpsign Vertical-Bar  
2.4.8.22 Notes about Style for Sharpsign Vertical-Bar  
2.4.8.23 Sharpsign Less-Than-Sign  
2.4.8.24 Sharpsign Whitespace  
2.4.8.25 Sharpsign Right-Parenthesis  

Evaluation and Compilation

3.1 Evaluation  
3.2 Compilation  
3.3 Declarations  
3.4 Lambda Lists  
3.5 Error Checking in Function Calls  
3.6 Traversal Rules and Side Effects  
3.7 Destructive Operations  
3.8 Evaluation and Compilation Dictionary  

Evaluation

3.1.1 Introduction to Environments  
3.1.2 The Evaluation Model  
3.1.3 Lambda Expressions  
3.1.4 Closures and Lexical Binding  
3.1.5 Shadowing  
3.1.6 Extent  
3.1.7 Return Values  

Introduction to Environments

3.1.1.1 The Global Environment  
3.1.1.2 Dynamic Environments  
3.1.1.3 Lexical Environments  
3.1.1.4 The Null Lexical Environment  
3.1.1.5 Environment Objects  

The Evaluation Model

3.1.2.1 Form Evaluation  
3.1.2.2 Symbols as Forms  
3.1.2.3 Lexical Variables  
3.1.2.4 Dynamic Variables  
3.1.2.5 Constant Variables  
3.1.2.6 Symbols Naming Both Lexical and Dynamic Variables  
3.1.2.7 Conses as Forms  
3.1.2.8 Special Forms  
3.1.2.9 Macro Forms  
3.1.2.10 Function Forms  
3.1.2.11 Lambda Forms  
3.1.2.12 Self-Evaluating Objects  
3.1.2.13 Examples of Self-Evaluating Objects  

Compilation

3.2.1 Compiler Terminology  
3.2.2 Compilation Semantics  
3.2.3 File Compilation  
3.2.4 Literal Objects in Compiled Files  
3.2.5 Exceptional Situations in the Compiler  

Compilation Semantics

3.2.2.1 Compiler Macros  
3.2.2.2 Purpose of Compiler Macros  
3.2.2.3 Naming of Compiler Macros  
3.2.2.4 When Compiler Macros Are Used  
3.2.2.5 Notes about the Implementation of Compiler Macros  
3.2.2.6 Minimal Compilation  
3.2.2.7 Semantic Constraints  

File Compilation

3.2.3.1 Processing of Top Level Forms  
3.2.3.2 Processing of Defining Macros  
3.2.3.3 Constraints on Macros and Compiler Macros  

Literal Objects in Compiled Files

3.2.4.1 Externalizable Objects  
3.2.4.2 Similarity of Literal Objects  
3.2.4.3 Similarity of Aggregate Objects  
3.2.4.4 Definition of Similarity  
3.2.4.5 Extensions to Similarity Rules  
3.2.4.6 Additional Constraints on Externalizable Objects  

Declarations

3.3.1 Minimal Declaration Processing Requirements  
3.3.2 Declaration Specifiers  
3.3.3 Declaration Identifiers  
3.3.4 Declaration Scope  

Declaration Identifiers

3.3.3.1 Shorthand notation for Type Declarations  

Declaration Scope

3.3.4.1 Examples of Declaration Scope  

Lambda Lists

3.4.1 Ordinary Lambda Lists  
3.4.2 Generic Function Lambda Lists  
3.4.3 Specialized Lambda Lists  
3.4.4 Macro Lambda Lists  
3.4.5 Destructuring Lambda Lists  
3.4.6 Boa Lambda Lists  
3.4.7 Defsetf Lambda Lists  
3.4.8 Deftype Lambda Lists  
3.4.9 Define-modify-macro Lambda Lists  
3.4.10 Define-method-combination Arguments Lambda Lists  
3.4.11 Syntactic Interaction of Documentation Strings and Declarations  

Ordinary Lambda Lists

3.4.1.1 Specifiers for the required parameters  
3.4.1.2 Specifiers for optional parameters  
3.4.1.3 A specifier for a rest parameter  
3.4.1.4 Specifiers for keyword parameters  
3.4.1.5 Suppressing Keyword Argument Checking  
3.4.1.6 Examples of Suppressing Keyword Argument Checking  
3.4.1.7 Specifiers for &aux variables  
3.4.1.8 Examples of Ordinary Lambda Lists  

Macro Lambda Lists

3.4.4.1 Destructuring by Lambda Lists  
3.4.4.2 Data-directed Destructuring by Lambda Lists  
3.4.4.3 Examples of Data-directed Destructuring by Lambda Lists  
3.4.4.4 Lambda-list-directed Destructuring by Lambda Lists  

Error Checking in Function Calls

3.5.1 Argument Mismatch Detection  

Argument Mismatch Detection

3.5.1.1 Safe and Unsafe Calls  
3.5.1.2 Error Detection Time in Safe Calls  
3.5.1.3 Too Few Arguments  
3.5.1.4 Too Many Arguments  
3.5.1.5 Unrecognized Keyword Arguments  
3.5.1.6 Invalid Keyword Arguments  
3.5.1.7 Odd Number of Keyword Arguments  
3.5.1.8 Destructuring Mismatch  
3.5.1.9 Errors When Calling a Next Method  

Destructive Operations

3.7.1 Modification of Literal Objects  
3.7.2 Transfer of Control during a Destructive Operation  

Transfer of Control during a Destructive Operation

3.7.2.1 Examples of Transfer of Control during a Destructive Operation  

Evaluation and Compilation Dictionary

3.8.1 lambda [Symbol]  
3.8.2 lambda [Macro]  
3.8.3 compile [Function]  
3.8.4 eval [Function]  
3.8.5 eval-when [Special Operator]  
3.8.6 load-time-value [Special Operator]  
3.8.7 quote [Special Operator]  
3.8.8 compiler-macro-function [Accessor]  
3.8.9 define-compiler-macro [Macro]  
3.8.10 defmacro [Macro]  
3.8.11 macro-function [Accessor]  
3.8.12 macroexpand, macroexpand-1 [Function]  
3.8.13 define-symbol-macro [Macro]  
3.8.14 symbol-macrolet [Special Operator]  
3.8.15 *macroexpand-hook* [Variable]  
3.8.16 proclaim [Function]  
3.8.17 declaim [Macro]  
3.8.18 declare [Symbol]  
3.8.19 ignore, ignorable [Declaration]  
3.8.20 dynamic-extent [Declaration]  
3.8.21 type [Declaration]  
3.8.22 inline, notinline [Declaration]  
3.8.23 ftype [Declaration]  
3.8.24 declaration [Declaration]  
3.8.25 optimize [Declaration]  
3.8.26 special [Declaration]  
3.8.27 locally [Special Operator]  
3.8.28 the [Special Operator]  
3.8.29 special-operator-p [Function]  
3.8.30 constantp [Function]  

Types and Classes

4.1 Introduction  
4.2 Types  
4.3 Classes  
4.4 Types and Classes Dictionary  

Types

4.2.1 Data Type Definition  
4.2.2 Type Relationships  
4.2.3 Type Specifiers  

Classes

4.3.1 Introduction to Classes  
4.3.2 Defining Classes  
4.3.3 Creating Instances of Classes  
4.3.4 Inheritance  
4.3.5 Determining the Class Precedence List  
4.3.6 Redefining Classes  
4.3.7 Integrating Types and Classes  

Introduction to Classes

4.3.1.1 Standard Metaclasses  

Inheritance

4.3.4.1 Examples of Inheritance  
4.3.4.2 Inheritance of Class Options  

Determining the Class Precedence List

4.3.5.1 Topological Sorting  
4.3.5.2 Examples of Class Precedence List Determination  

Redefining Classes

4.3.6.1 Modifying the Structure of Instances  
4.3.6.2 Initializing Newly Added Local Slots  
4.3.6.3 Customizing Class Redefinition  

Types and Classes Dictionary

4.4.1 nil [Type]  
4.4.2 boolean [Type]  
4.4.3 function [System Class]  
4.4.4 compiled-function [Type]  
4.4.5 generic-function [System Class]  
4.4.6 standard-generic-function [System Class]  
4.4.7 class [System Class]  
4.4.8 built-in-class [System Class]  
4.4.9 structure-class [System Class]  
4.4.10 standard-class [System Class]  
4.4.11 method [System Class]  
4.4.12 standard-method [System Class]  
4.4.13 structure-object [Class]  
4.4.14 standard-object [Class]  
4.4.15 method-combination [System Class]  
4.4.16 t [System Class]  
4.4.17 satisfies [Type Specifier]  
14.2.33 member, member-if, member-if-not [Function]  
4.4.19 not [Type Specifier]  
4.4.20 and [Type Specifier]  
4.4.21 or [Type Specifier]  
4.4.22 values [Type Specifier]  
4.4.23 eql [Type Specifier]  
4.4.24 coerce [Function]  
4.4.25 deftype [Macro]  
4.4.26 subtypep [Function]  
4.4.27 type-of [Function]  
4.4.28 typep [Function]  
4.4.29 type-error [Condition Type]  
4.4.30 type-error-datum, type-error-expected-type [Function]  
4.4.31 simple-type-error [Condition Type]  

Data and Control Flow

5.1 Generalized Reference  
5.2 Transfer of Control to an Exit Point  
5.3 Data and Control Flow Dictionary  

Generalized Reference

5.1.1 Overview of Places and Generalized Reference  
5.1.2 Kinds of Places  
5.1.3 Treatment of Other Macros Based on SETF  

Overview of Places and Generalized Reference

5.1.1.1 Evaluation of Subforms to Places  
5.1.1.2 Examples of Evaluation of Subforms to Places  
5.1.1.3 Setf Expansions  
5.1.1.4 Examples of Setf Expansions  

Kinds of Places

5.1.2.1 Variable Names as Places  
5.1.2.2 Function Call Forms as Places  
5.1.2.3 VALUES Forms as Places  
5.1.2.4 THE Forms as Places  
5.1.2.5 APPLY Forms as Places  
5.1.2.6 Setf Expansions and Places  
5.1.2.7 Macro Forms as Places  
5.1.2.8 Symbol Macros as Places  
5.1.2.9 Other Compound Forms as Places  

Data and Control Flow Dictionary

5.3.1 apply [Function]  
5.3.2 defun [Macro]  
5.3.3 fdefinition [Accessor]  
5.3.4 fboundp [Function]  
5.3.5 fmakunbound [Function]  
5.3.6 flet, labels, macrolet [Special Operator]  
5.3.7 funcall [Function]  
5.3.8 function [Special Operator]  
5.3.9 function-lambda-expression [Function]  
5.3.10 functionp [Function]  
5.3.11 compiled-function-p [Function]  
5.3.12 call-arguments-limit [Constant Variable]  
5.3.13 lambda-list-keywords [Constant Variable]  
5.3.14 lambda-parameters-limit [Constant Variable]  
5.3.15 defconstant [Macro]  
5.3.16 defparameter, defvar [Macro]  
5.3.17 destructuring-bind [Macro]  
5.3.18 let, let* [Special Operator]  
5.3.19 progv [Special Operator]  
5.3.20 setq [Special Form]  
5.3.21 psetq [Macro]  
5.3.22 block [Special Operator]  
5.3.23 catch [Special Operator]  
5.3.24 go [Special Operator]  
5.3.25 return-from [Special Operator]  
5.3.26 return [Macro]  
5.3.27 tagbody [Special Operator]  
5.3.28 throw [Special Operator]  
5.3.29 unwind-protect [Special Operator]  
5.3.30 nil [Constant Variable]  
5.3.31 not [Function]  
5.3.32 t [Constant Variable]  
5.3.33 eq [Function]  
5.3.34 eql [Function]  
5.3.35 equal [Function]  
5.3.36 equalp [Function]  
5.3.37 identity [Function]  
5.3.38 complement [Function]  
5.3.39 constantly [Function]  
5.3.40 every, some, notevery, notany [Function]  
5.3.41 and [Macro]  
5.3.42 cond [Macro]  
5.3.43 if [Special Operator]  
5.3.44 or [Macro]  
5.3.45 when, unless [Macro]  
5.3.46 case, ccase, ecase [Macro]  
5.3.47 typecase, ctypecase, etypecase [Macro]  
5.3.48 multiple-value-bind [Macro]  
5.3.49 multiple-value-call [Special Operator]  
5.3.50 multiple-value-list [Macro]  
5.3.51 multiple-value-prog1 [Special Operator]  
5.3.52 multiple-value-setq [Macro]  
5.3.53 values [Accessor]  
5.3.54 values-list [Function]  
5.3.55 multiple-values-limit [Constant Variable]  
5.3.56 nth-value [Macro]  
5.3.57 prog, prog* [Macro]  
5.3.58 prog1, prog2 [Macro]  
5.3.59 progn [Special Operator]  
5.3.60 define-modify-macro [Macro]  
5.3.61 defsetf [Macro]  
5.3.62 define-setf-expander [Macro]  
5.3.63 get-setf-expansion [Function]  
5.3.64 setf, psetf [Macro]  
5.3.65 shiftf [Macro]  
5.3.66 rotatef [Macro]  
5.3.67 control-error [Condition Type]  
5.3.68 program-error [Condition Type]  
5.3.69 undefined-function [Condition Type]  

Iteration

6.1 The LOOP Facility  
6.2 Iteration Dictionary  

The LOOP Facility

6.1.1 Overview of the Loop Facility  
6.1.2 Variable Initialization and Stepping Clauses  
6.1.3 Value Accumulation Clauses  
6.1.4 Termination Test Clauses  
6.1.5 Unconditional Execution Clauses  
6.1.6 Conditional Execution Clauses  
6.1.7 Miscellaneous Clauses  
6.1.8 Examples of Miscellaneous Loop Features  
6.1.9 Notes about Loop  

Overview of the Loop Facility

6.1.1.1 Simple vs Extended Loop  
6.1.1.2 Simple Loop  
6.1.1.3 Extended Loop  
6.1.1.4 Loop Keywords  
6.1.1.5 Parsing Loop Clauses  
6.1.1.6 Expanding Loop Forms  
6.1.1.7 Summary of Loop Clauses  
6.1.1.8 Summary of Variable Initialization and Stepping Clauses  
6.1.1.9 Summary of Value Accumulation Clauses  
6.1.1.10 Summary of Termination Test Clauses  
6.1.1.11 Summary of Unconditional Execution Clauses  
6.1.1.12 Summary of Conditional Execution Clauses  
6.1.1.13 Summary of Miscellaneous Clauses  
6.1.1.14 Order of Execution  
6.1.1.15 Destructuring  
6.1.1.16 Restrictions on Side-Effects  

Variable Initialization and Stepping Clauses

6.1.2.1 Iteration Control  
6.1.2.2 The for-as-arithmetic subclause  
6.1.2.3 Examples of for-as-arithmetic subclause  
6.1.2.4 The for-as-in-list subclause  
6.1.2.5 Examples of for-as-in-list subclause  
6.1.2.6 The for-as-on-list subclause  
6.1.2.7 Examples of for-as-on-list subclause  
6.1.2.8 The for-as-equals-then subclause  
6.1.2.9 Examples of for-as-equals-then subclause  
6.1.2.10 The for-as-across subclause  
6.1.2.11 Examples of for-as-across subclause  
6.1.2.12 The for-as-hash subclause  
6.1.2.13 The for-as-package subclause  
6.1.2.14 Examples of for-as-package subclause  
6.1.2.15 Local Variable Initializations  
6.1.2.16 Examples of WITH clause  

Value Accumulation Clauses

6.1.3.1 Examples of COLLECT clause  
6.1.3.2 Examples of APPEND and NCONC clauses  
6.1.3.3 Examples of COUNT clause  
6.1.3.4 Examples of MAXIMIZE and MINIMIZE clauses  
6.1.3.5 Examples of SUM clause  

Termination Test Clauses

6.1.4.1 Examples of REPEAT clause  
6.1.4.2 Examples of ALWAYS, NEVER, and THEREIS clauses  
6.1.4.3 Examples of WHILE and UNTIL clauses  

Unconditional Execution Clauses

6.1.5.1 Examples of unconditional execution  

Conditional Execution Clauses

6.1.6.1 Examples of WHEN clause  

Miscellaneous Clauses

6.1.7.1 Control Transfer Clauses  
6.1.7.2 Examples of NAMED clause  
6.1.7.3 Initial and Final Execution  

Examples of Miscellaneous Loop Features

6.1.8.1 Examples of clause grouping  

Iteration Dictionary

6.2.1 do, do* [Macro]  
6.2.2 dotimes [Macro]  
6.2.3 dolist [Macro]  
6.2.4 loop [Macro]  
6.2.5 loop-finish [Local Macro]  

Objects

7.1 Object Creation and Initialization  
7.2 Changing the Class of an Instance  
7.3 Reinitializing an Instance  
7.4 Meta-Objects  
7.5 Slots  
7.6 Generic Functions and Methods  
7.7 Objects Dictionary  

Object Creation and Initialization

7.1.1 Initialization Arguments  
7.1.2 Declaring the Validity of Initialization Arguments  
7.1.3 Defaulting of Initialization Arguments  
7.1.4 Rules for Initialization Arguments  
7.1.5 Shared-Initialize  
7.1.6 Initialize-Instance  
7.1.7 Definitions of Make-Instance and Initialize-Instance  

Changing the Class of an Instance

7.2.1 Modifying the Structure of the Instance  
7.2.2 Initializing Newly Added Local Slots  
7.2.3 Customizing the Change of Class of an Instance  

Reinitializing an Instance

7.3.1 Customizing Reinitialization  

Meta-Objects

7.4.1 Standard Meta-objects  

Slots

7.5.1 Introduction to Slots  
7.5.2 Accessing Slots  
7.5.3 Inheritance of Slots and Slot Options  

Generic Functions and Methods

7.6.1 Introduction to Generic Functions  
7.6.2 Introduction to Methods  
7.6.3 Agreement on Parameter Specializers and Qualifiers  
7.6.4 Congruent Lambda-lists for all Methods of a Generic Function  
7.6.5 Keyword Arguments in Generic Functions and Methods  
7.6.6 Method Selection and Combination  
7.6.7 Inheritance of Methods  

Keyword Arguments in Generic Functions and Methods

7.6.5.1 Examples of Keyword Arguments in Generic Functions and Methods  

Method Selection and Combination

7.6.6.1 Determining the Effective Method  
7.6.6.2 Selecting the Applicable Methods  
7.6.6.3 Sorting the Applicable Methods by Precedence Order  
7.6.6.4 Applying method combination to the sorted list of applicable methods  
7.6.6.5 Standard Method Combination  
7.6.6.6 Declarative Method Combination  
7.6.6.7 Built-in Method Combination Types  

Objects Dictionary

7.7.1 function-keywords [Standard Generic Function]  
7.7.2 ensure-generic-function [Function]  
7.7.3 allocate-instance [Standard Generic Function]  
7.7.4 reinitialize-instance [Standard Generic Function]  
7.7.5 shared-initialize [Standard Generic Function]  
7.7.6 update-instance-for-different-class [Standard Generic Function]  
7.7.7 update-instance-for-redefined-class [Standard Generic Function]  
7.7.8 change-class [Standard Generic Function]  
7.7.9 slot-boundp [Function]  
7.7.10 slot-exists-p [Function]  
7.7.11 slot-makunbound [Function]  
7.7.12 slot-missing [Standard Generic Function]  
7.7.13 slot-unbound [Standard Generic Function]  
7.7.14 slot-value [Function]  
7.7.15 method-qualifiers [Standard Generic Function]  
7.7.16 no-applicable-method [Standard Generic Function]  
7.7.17 no-next-method [Standard Generic Function]  
7.7.18 remove-method [Standard Generic Function]  
7.7.19 make-instance [Standard Generic Function]  
7.7.20 make-instances-obsolete [Standard Generic Function]  
7.7.21 make-load-form [Standard Generic Function]  
7.7.22 make-load-form-saving-slots [Function]  
7.7.23 with-accessors [Macro]  
7.7.24 with-slots [Macro]  
7.7.25 defclass [Macro]  
7.7.26 defgeneric [Macro]  
7.7.27 defmethod [Macro]  
7.7.28 find-class [Accessor]  
7.7.29 next-method-p [Local Function]  
7.7.30 call-method, make-method [Local Macro]  
7.7.31 call-next-method [Local Function]  
7.7.32 compute-applicable-methods [Standard Generic Function]  
7.7.33 define-method-combination [Macro]  
7.7.34 find-method [Standard Generic Function]  
7.7.35 add-method [Standard Generic Function]  
7.7.36 initialize-instance [Standard Generic Function]  
7.7.37 class-name [Standard Generic Function]  
7.7.38 (setf class-name) [Standard Generic Function]  
7.7.39 class-of [Function]  
7.7.40 unbound-slot [Condition Type]  
7.7.41 unbound-slot-instance [Function]  

Structures

8.1 Structures Dictionary  

Structures Dictionary

8.1.1 defstruct [Macro]  
8.1.2 copy-structure [Function]  

Conditions

9.1 Condition System Concepts  
9.2 Conditions Dictionary  

Condition System Concepts

9.1.1 Condition Types  
9.1.2 Creating Conditions  
9.1.3 Printing Conditions  
9.1.4 Signaling and Handling Conditions  
9.1.5 Assertions  
9.1.6 Notes about the Condition System's Background  

Condition Types

9.1.1.1 Serious Conditions  

Creating Conditions

9.1.2.1 Condition Designators  

Printing Conditions

9.1.3.1 Recommended Style in Condition Reporting  
9.1.3.2 Capitalization and Punctuation in Condition Reports  
9.1.3.3 Leading and Trailing Newlines in Condition Reports  
9.1.3.4 Embedded Newlines in Condition Reports  
9.1.3.5 Note about Tabs in Condition Reports  
9.1.3.6 Mentioning Containing Function in Condition Reports  

Signaling and Handling Conditions

9.1.4.1 Signaling  
9.1.4.2 Resignaling a Condition  
9.1.4.3 Restarts  
9.1.4.4 Interactive Use of Restarts  
9.1.4.5 Interfaces to Restarts  
9.1.4.6 Restart Tests  
9.1.4.7 Associating a Restart with a Condition  

Conditions Dictionary

9.2.1 condition [Condition Type]  
9.2.2 warning [Condition Type]  
9.2.3 style-warning [Condition Type]  
9.2.4 serious-condition [Condition Type]  
9.2.5 error [Condition Type]  
9.2.6 cell-error [Condition Type]  
9.2.7 cell-error-name [Function]  
9.2.8 parse-error [Condition Type]  
9.2.9 storage-condition [Condition Type]  
9.2.10 assert [Macro]  
9.2.11 error [Function]  
9.2.12 cerror [Function]  
9.2.13 check-type [Macro]  
9.2.14 simple-error [Condition Type]  
9.2.15 invalid-method-error [Function]  
9.2.16 method-combination-error [Function]  
9.2.17 signal [Function]  
9.2.18 simple-condition [Condition Type]  
9.2.19 simple-condition-format-control, simple-condition-format-arguments  
9.2.20 warn [Function]  
9.2.21 simple-warning [Condition Type]  
9.2.22 invoke-debugger [Function]  
9.2.23 break [Function]  
9.2.24 *debugger-hook* [Variable]  
9.2.25 *break-on-signals* [Variable]  
9.2.26 handler-bind [Macro]  
9.2.27 handler-case [Macro]  
9.2.28 ignore-errors [Macro]  
9.2.29 define-condition [Macro]  
9.2.30 make-condition [Function]  
9.2.31 restart [System Class]  
9.2.32 compute-restarts [Function]  
9.2.33 find-restart [Function]  
9.2.34 invoke-restart [Function]  
9.2.35 invoke-restart-interactively [Function]  
9.2.36 restart-bind [Macro]  
9.2.37 restart-case [Macro]  
9.2.38 restart-name [Function]  
9.2.39 with-condition-restarts [Macro]  
9.2.40 with-simple-restart [Macro]  
9.2.46 abort, continue, muffle-warning, store-value, use-value [Function]  
9.2.42 continue [Restart]  
9.2.43 muffle-warning [Restart]  
9.2.44 store-value [Restart]  
9.2.45 use-value [Restart]  
9.2.46 abort, continue, muffle-warning, store-value, use-value [Function]  

Symbols

10.1 Symbol Concepts  
10.2 Symbols Dictionary  

Symbols Dictionary

10.2.1 symbol [System Class]  
10.2.2 keyword [Type]  
10.2.3 symbolp [Function]  
10.2.4 keywordp [Function]  
10.2.5 make-symbol [Function]  
10.2.6 copy-symbol [Function]  
10.2.7 gensym [Function]  
10.2.8 *gensym-counter* [Variable]  
10.2.9 gentemp [Function]  
10.2.10 symbol-function [Accessor]  
10.2.11 symbol-name [Function]  
10.2.12 symbol-package [Function]  
10.2.13 symbol-plist [Accessor]  
10.2.14 symbol-value [Accessor]  
10.2.15 get [Accessor]  
10.2.16 remprop [Function]  
10.2.17 boundp [Function]  
10.2.18 makunbound [Function]  
10.2.19 set [Function]  
10.2.20 unbound-variable [Condition Type]  

Packages

11.1 Package Concepts  
11.2 Packages Dictionary  

Package Concepts

11.1.1 Introduction to Packages  
11.1.2 Standardized Packages  

Introduction to Packages

11.1.1.1 Package Names and Nicknames  
11.1.1.2 Symbols in a Package  
11.1.1.3 Internal and External Symbols  
11.1.1.4 Package Inheritance  
11.1.1.5 Accessibility of Symbols in a Package  
11.1.1.6 Locating a Symbol in a Package  
11.1.1.7 Prevention of Name Conflicts in Packages  

Standardized Packages

11.1.2.1 The COMMON-LISP Package  
11.1.2.2 Constraints on the COMMON-LISP Package for Conforming Implementations  
11.1.2.3 Constraints on the COMMON-LISP Package for Conforming Programs  
11.1.2.4 Some Exceptions to Constraints on the COMMON-LISP Package for Conforming Programs  
11.1.2.5 The COMMON-LISP-USER Package  
11.1.2.6 The KEYWORD Package  
11.1.2.7 Interning a Symbol in the KEYWORD Package  
11.1.2.8 Notes about The KEYWORD Package  
11.1.2.9 Implementation-Defined Packages  

Packages Dictionary

11.2.1 package [System Class]  
11.2.2 export [Function]  
11.2.3 find-symbol [Function]  
11.2.4 find-package [Function]  
11.2.5 find-all-symbols [Function]  
11.2.6 import [Function]  
11.2.7 list-all-packages [Function]  
11.2.8 rename-package [Function]  
11.2.9 shadow [Function]  
11.2.10 shadowing-import [Function]  
11.2.11 delete-package [Function]  
11.2.12 make-package [Function]  
11.2.13 with-package-iterator [Macro]  
11.2.14 unexport [Function]  
11.2.15 unintern [Function]  
11.2.16 in-package [Macro]  
11.2.17 unuse-package [Function]  
11.2.18 use-package [Function]  
11.2.19 defpackage [Macro]  
11.2.20 do-symbols, do-external-symbols, do-all-symbols [Macro]  
11.2.21 intern [Function]  
11.2.22 package-name [Function]  
11.2.23 package-nicknames [Function]  
11.2.24 package-shadowing-symbols [Function]  
11.2.25 package-use-list [Function]  
11.2.26 package-used-by-list [Function]  
11.2.27 packagep [Function]  
11.2.28 *package* [Variable]  
11.2.29 package-error [Condition Type]  
11.2.30 package-error-package [Function]  

Numbers

12.1 Number Concepts  
12.2 Numbers Dictionary  

Number Concepts

12.1.1 Numeric Operations  
12.1.2 Implementation-Dependent Numeric Constants  
12.1.3 Rational Computations  
12.1.4 Floating-point Computations  
12.1.5 Complex Computations  
12.1.6 Interval Designators  
12.1.7 Random-State Operations  

Numeric Operations

12.1.1.1 Associativity and Commutativity in Numeric Operations  
12.1.1.2 Examples of Associativity and Commutativity in Numeric Operations  
12.1.1.3 Contagion in Numeric Operations  
12.1.1.4 Viewing Integers as Bits and Bytes  
12.1.1.5 Logical Operations on Integers  
12.1.1.6 Byte Operations on Integers  

Rational Computations

12.1.3.1 Rule of Unbounded Rational Precision  
12.1.3.2 Rule of Canonical Representation for Rationals  
12.1.3.3 Rule of Float Substitutability  

Floating-point Computations

12.1.4.1 Rule of Float and Rational Contagion  
12.1.4.2 Examples of Rule of Float and Rational Contagion  
12.1.4.3 Rule of Float Approximation  
12.1.4.4 Rule of Float Underflow and Overflow  
12.1.4.5 Rule of Float Precision Contagion  

Complex Computations

12.1.5.1 Rule of Complex Substitutability  
12.1.5.2 Rule of Complex Contagion  
12.1.5.3 Rule of Canonical Representation for Complex Rationals  
12.1.5.4 Examples of Rule of Canonical Representation for Complex Rationals  
12.1.5.5 Principal Values and Branch Cuts  

Numbers Dictionary

12.2.1 number [System Class]  
12.2.2 complex [System Class]  
12.2.3 real [System Class]  
12.2.4 float [System Class]  
12.2.5 short-float, single-float, double-float, long-float [Type]  
12.2.54 rational, rationalize [Function]  
12.2.7 ratio [System Class]  
12.2.8 integer [System Class]  
12.2.9 signed-byte [Type]  
12.2.10 unsigned-byte [Type]  
12.2.36 mod, rem [Function]  
15.2.33 bit, sbit [Accessor]  
12.2.13 fixnum [Type]  
12.2.14 bignum [Type]  
12.2.15 =, /=, <, >, <=, >= [Function]  
12.2.16 max, min [Function]  
12.2.17 minusp, plusp [Function]  
12.2.18 zerop [Function]  
12.2.19 floor, ffloor, ceiling, fceiling,  
12.2.20 sin, cos, tan [Function]  
12.2.21 asin, acos, atan [Function]  
12.2.22 pi [Constant Variable]  
12.2.23 sinh, cosh, tanh, asinh, acosh, atanh [Function]  
25.2.22 *, **, *** [Variable]  
25.2.21 +, ++, +++ [Variable]  
25.2.20 - [Variable]  
25.2.23 /, //, /// [Variable]  
12.2.28 1+, 1- [Function]  
12.2.29 abs [Function]  
12.2.30 evenp, oddp [Function]  
12.2.31 exp, expt [Function]  
12.2.32 gcd [Function]  
12.2.33 incf, decf [Macro]  
12.2.34 lcm [Function]  
12.2.35 log [Function]  
12.2.36 mod, rem [Function]  
12.2.37 signum [Function]  
12.2.38 sqrt, isqrt [Function]  
12.2.39 random-state [System Class]  
12.2.40 make-random-state [Function]  
12.2.41 random [Function]  
12.2.42 random-state-p [Function]  
12.2.43 *random-state* [Variable]  
12.2.44 numberp [Function]  
12.2.45 cis [Function]  
12.2.46 complex [Function]  
12.2.47 complexp [Function]  
12.2.48 conjugate [Function]  
12.2.49 phase [Function]  
12.2.50 realpart, imagpart [Function]  
12.2.51 upgraded-complex-part-type [Function]  
12.2.52 realp [Function]  
12.2.53 numerator, denominator [Function]  
12.2.54 rational, rationalize [Function]  
12.2.55 rationalp [Function]  
12.2.56 ash [Function]  
12.2.57 integer-length [Function]  
12.2.58 integerp [Function]  
12.2.59 parse-integer [Function]  
12.2.60 boole [Function]  
12.2.61 boole-1, boole-2, boole-and, boole-andc1, boole-andc2,  
12.2.62 logand, logandc1, logandc2, logeqv, logior,  
12.2.63 logbitp [Function]  
12.2.64 logcount [Function]  
12.2.65 logtest [Function]  
12.2.66 byte, byte-size, byte-position [Function]  
12.2.67 deposit-field [Function]  
12.2.68 dpb [Function]  
12.2.69 ldb [Accessor]  
12.2.70 ldb-test [Function]  
12.2.71 mask-field [Accessor]  
12.2.72 most-positive-fixnum, most-negative-fixnum [Constant Variable]  
12.2.73 decode-float, scale-float, float-radix, float-sign,  
12.2.74 float [Function]  
12.2.75 floatp [Function]  
12.2.76 most-positive-short-float, least-positive-short-float,  
12.2.77 short-float-epsilon, short-float-negative-epsilon,  
12.2.78 arithmetic-error [Condition Type]  
12.2.79 arithmetic-error-operands, arithmetic-error-operation [Function]  
12.2.80 division-by-zero [Condition Type]  
12.2.81 floating-point-invalid-operation [Condition Type]  
12.2.82 floating-point-inexact [Condition Type]  
12.2.83 floating-point-overflow [Condition Type]  
12.2.84 floating-point-underflow [Condition Type]  

Characters

13.1 Character Concepts  
13.2 Characters Dictionary  

Character Concepts

13.1.1 Introduction to Characters  
13.1.2 Introduction to Scripts and Repertoires  
13.1.3 Character Attributes  
13.1.4 Character Categories  
13.1.5 Identity of Characters  
13.1.6 Ordering of Characters  
13.1.7 Character Names  
13.1.8 Treatment of Newline during Input and Output  
13.1.9 Character Encodings  
13.1.10 Documentation of Implementation-Defined Scripts  

Introduction to Scripts and Repertoires

13.1.2.1 Character Scripts  
13.1.2.2 Character Repertoires  

Character Categories

13.1.4.1 Graphic Characters  
13.1.4.2 Alphabetic Characters  
13.1.4.3 Characters With Case  
13.1.4.4 Uppercase Characters  
13.1.4.5 Lowercase Characters  
13.1.4.6 Corresponding Characters in the Other Case  
13.1.4.7 Case of Implementation-Defined Characters  
13.1.4.8 Numeric Characters  
13.1.4.9 Alphanumeric Characters  
13.1.4.10 Digits in a Radix  

Characters Dictionary

13.2.1 character [System Class]  
13.2.2 base-char [Type]  
13.2.3 standard-char [Type]  
13.2.4 extended-char [Type]  
13.2.5 char=, char/=, char<, char>, char<=, char>=,  
13.2.6 character [Function]  
13.2.7 characterp [Function]  
13.2.8 alpha-char-p [Function]  
13.2.9 alphanumericp [Function]  
13.2.10 digit-char [Function]  
13.2.11 digit-char-p [Function]  
13.2.12 graphic-char-p [Function]  
13.2.13 standard-char-p [Function]  
13.2.14 char-upcase, char-downcase [Function]  
13.2.15 upper-case-p, lower-case-p, both-case-p [Function]  
13.2.16 char-code [Function]  
13.2.17 char-int [Function]  
13.2.18 code-char [Function]  
13.2.19 char-code-limit [Constant Variable]  
13.2.20 char-name [Function]  
13.2.21 name-char [Function]  

Conses

14.1 Cons Concepts  
14.2 Conses Dictionary  

Cons Concepts

14.1.1 Conses as Trees  
14.1.2 Conses as Lists  

Conses as Trees

14.1.1.1 General Restrictions on Parameters that must be Trees  

Conses as Lists

14.1.2.1 Lists as Association Lists  
14.1.2.2 Lists as Sets  
14.1.2.3 General Restrictions on Parameters that must be Lists  

Conses Dictionary

14.2.15 list, list* [Function]  
14.2.2 null [System Class]  
14.2.3 cons [System Class]  
14.2.4 atom [Type]  
14.2.5 cons [Function]  
14.2.6 consp [Function]  
14.2.7 atom [Function]  
14.2.8 rplaca, rplacd [Function]  
14.2.9 car, cdr,  
14.2.10 copy-tree [Function]  
14.2.11 sublis, nsublis [Function]  
14.2.12 subst, subst-if, subst-if-not, nsubst, nsubst-if, nsubst-if-not  
14.2.13 tree-equal [Function]  
14.2.14 copy-list [Function]  
14.2.15 list, list* [Function]  
14.2.16 list-length [Function]  
14.2.17 listp [Function]  
14.2.18 make-list [Function]  
14.2.19 push [Macro]  
14.2.20 pop [Macro]  
14.2.21 first, second, third, fourth, fifth,  
14.2.22 nth [Accessor]  
14.2.23 endp [Function]  
14.2.24 null [Function]  
14.2.25 nconc [Function]  
14.2.26 append [Function]  
14.2.27 revappend, nreconc [Function]  
14.2.28 butlast, nbutlast [Function]  
14.2.29 last [Function]  
14.2.30 ldiff, tailp [Function]  
14.2.31 nthcdr [Function]  
14.2.32 rest [Accessor]  
14.2.33 member, member-if, member-if-not [Function]  
14.2.34 mapc, mapcar, mapcan, mapl, maplist, mapcon [Function]  
14.2.35 acons [Function]  
14.2.36 assoc, assoc-if, assoc-if-not [Function]  
14.2.37 copy-alist [Function]  
14.2.38 pairlis [Function]  
14.2.39 rassoc, rassoc-if, rassoc-if-not [Function]  
14.2.40 get-properties [Function]  
14.2.41 getf [Accessor]  
14.2.42 remf [Macro]  
14.2.43 intersection, nintersection [Function]  
14.2.44 adjoin [Function]  
14.2.45 pushnew [Macro]  
14.2.46 set-difference, nset-difference [Function]  
14.2.47 set-exclusive-or, nset-exclusive-or [Function]  
14.2.48 subsetp [Function]  
14.2.49 union, nunion [Function]  

Arrays

15.1 Array Concepts  
15.2 Arrays Dictionary  

Array Concepts

15.1.1 Array Elements  
15.1.2 Specialized Arrays  

Array Elements

15.1.1.1 Array Indices  
15.1.1.2 Array Dimensions  
15.1.1.3 Implementation Limits on Individual Array Dimensions  
15.1.1.4 Array Rank  
15.1.1.5 Vectors  
15.1.1.6 Fill Pointers  
15.1.1.7 Multidimensional Arrays  
15.1.1.8 Storage Layout for Multidimensional Arrays  
15.1.1.9 Implementation Limits on Array Rank  

Specialized Arrays

15.1.2.1 Array Upgrading  
15.1.2.2 Required Kinds of Specialized Arrays  

Arrays Dictionary

15.2.1 array [System Class]  
15.2.2 simple-array [Type]  
15.2.3 vector [System Class]  
15.2.4 simple-vector [Type]  
15.2.5 bit-vector [System Class]  
15.2.6 simple-bit-vector [Type]  
15.2.7 make-array [Function]  
15.2.8 adjust-array [Function]  
15.2.9 adjustable-array-p [Function]  
15.2.10 aref [Accessor]  
15.2.11 array-dimension [Function]  
15.2.12 array-dimensions [Function]  
15.2.13 array-element-type [Function]  
15.2.14 array-has-fill-pointer-p [Function]  
15.2.15 array-displacement [Function]  
15.2.16 array-in-bounds-p [Function]  
15.2.17 array-rank [Function]  
15.2.18 array-row-major-index [Function]  
15.2.19 array-total-size [Function]  
15.2.20 arrayp [Function]  
15.2.21 fill-pointer [Accessor]  
15.2.22 row-major-aref [Accessor]  
15.2.23 upgraded-array-element-type [Function]  
15.2.24 array-dimension-limit [Constant Variable]  
15.2.25 array-rank-limit [Constant Variable]  
15.2.26 array-total-size-limit [Constant Variable]  
15.2.27 simple-vector-p [Function]  
15.2.28 svref [Accessor]  
15.2.29 vector [Function]  
15.2.30 vector-pop [Function]  
15.2.31 vector-push, vector-push-extend [Function]  
15.2.32 vectorp [Function]  
15.2.33 bit, sbit [Accessor]  
15.2.34 bit-and, bit-andc1, bit-andc2, bit-eqv,  
15.2.35 bit-vector-p [Function]  
15.2.36 simple-bit-vector-p [Function]  

Strings

16.1 String Concepts  
16.2 Strings Dictionary  

String Concepts

16.1.1 Implications of Strings Being Arrays  
16.1.2 Subtypes of STRING  

Strings Dictionary

16.2.1 string [System Class]  
16.2.2 base-string [Type]  
16.2.3 simple-string [Type]  
16.2.4 simple-base-string [Type]  
16.2.5 simple-string-p [Function]  
16.2.6 char, schar [Accessor]  
16.2.7 string [Function]  
16.2.8 string-upcase, string-downcase, string-capitalize,  
16.2.9 string-trim, string-left-trim, string-right-trim [Function]  
16.2.10 string=, string/=, string<, string>, string<=, string>=,  
16.2.11 stringp [Function]  
16.2.12 make-string [Function]  

Sequences

17.1 Sequence Concepts  
17.2 Rules about Test Functions  
17.3 Sequences Dictionary  

Sequence Concepts

17.1.1 General Restrictions on Parameters that must be Sequences  

Rules about Test Functions

17.2.1 Satisfying a Two-Argument Test  
17.2.2 Satisfying a One-Argument Test  

Satisfying a Two-Argument Test

17.2.1.1 Examples of Satisfying a Two-Argument Test  

Satisfying a One-Argument Test

17.2.2.1 Examples of Satisfying a One-Argument Test  

Sequences Dictionary

17.3.1 sequence [System Class]  
17.3.2 copy-seq [Function]  
17.3.3 elt [Accessor]  
17.3.4 fill [Function]  
17.3.5 make-sequence [Function]  
17.3.6 subseq [Accessor]  
17.3.7 map [Function]  
17.3.8 map-into [Function]  
17.3.9 reduce [Function]  
17.3.10 count, count-if, count-if-not [Function]  
17.3.11 length [Function]  
17.3.12 reverse, nreverse [Function]  
17.3.13 sort, stable-sort [Function]  
17.3.14 find, find-if, find-if-not [Function]  
17.3.15 position, position-if, position-if-not [Function]  
17.3.16 search [Function]  
17.3.17 mismatch [Function]  
17.3.18 replace [Function]  
17.3.19 substitute, substitute-if, substitute-if-not,  
17.3.20 concatenate [Function]  
17.3.21 merge [Function]  
17.3.22 remove, remove-if, remove-if-not,  
17.3.23 remove-duplicates, delete-duplicates [Function]  

Hash Tables

18.1 Hash Table Concepts  
18.2 Hash Tables Dictionary  

Hash Table Concepts

18.1.1 Hash-Table Operations  
18.1.2 Modifying Hash Table Keys  

Modifying Hash Table Keys

18.1.2.1 Visible Modification of Objects with respect to EQ and EQL  
18.1.2.2 Visible Modification of Objects with respect to EQUAL  
18.1.2.3 Visible Modification of Conses with respect to EQUAL  
18.1.2.4 Visible Modification of Bit Vectors and Strings with respect to EQUAL  
18.1.2.5 Visible Modification of Objects with respect to EQUALP  
18.1.2.6 Visible Modification of Structures with respect to EQUALP  
18.1.2.7 Visible Modification of Arrays with respect to EQUALP  
18.1.2.8 Visible Modification of Hash Tables with respect to EQUALP  
18.1.2.9 Visible Modifications by Language Extensions  

Hash Tables Dictionary

18.2.1 hash-table [System Class]  
18.2.2 make-hash-table [Function]  
18.2.3 hash-table-p [Function]  
18.2.4 hash-table-count [Function]  
18.2.5 hash-table-rehash-size [Function]  
18.2.6 hash-table-rehash-threshold [Function]  
18.2.7 hash-table-size [Function]  
18.2.8 hash-table-test [Function]  
18.2.9 gethash [Accessor]  
18.2.10 remhash [Function]  
18.2.11 maphash [Function]  
18.2.12 with-hash-table-iterator [Macro]  
18.2.13 clrhash [Function]  
18.2.14 sxhash [Function]  

Filenames

19.1 Overview of Filenames  
19.2 Pathnames  
19.3 Logical Pathnames  
19.4 Filenames Dictionary  

Overview of Filenames

19.1.1 Namestrings as Filenames  
19.1.2 Pathnames as Filenames  
19.1.3 Parsing Namestrings Into Pathnames  

Pathnames

19.2.1 Pathname Components  
19.2.2 Interpreting Pathname Component Values  
19.2.3 Merging Pathnames  

Pathname Components

19.2.1.1 The Pathname Host Component  
19.2.1.2 The Pathname Device Component  
19.2.1.3 The Pathname Directory Component  
19.2.1.4 The Pathname Name Component  
19.2.1.5 The Pathname Type Component  
19.2.1.6 The Pathname Version Component  

Interpreting Pathname Component Values

19.2.2.1 Strings in Component Values  
19.2.2.2 Special Characters in Pathname Components  
19.2.2.3 Case in Pathname Components  
19.2.2.4 Local Case in Pathname Components  
19.2.2.5 Common Case in Pathname Components  
19.2.2.6 Special Pathname Component Values  
19.2.2.7 NIL as a Component Value  
19.2.2.8 :WILD as a Component Value  
19.2.2.9 :UNSPECIFIC as a Component Value  
19.2.2.10 Relation between component values NIL and :UNSPECIFIC  
19.2.2.11 Restrictions on Wildcard Pathnames  
19.2.2.12 Restrictions on Examining Pathname Components  
19.2.2.13 Restrictions on Examining a Pathname Host Component  
19.2.2.14 Restrictions on Examining a Pathname Device Component  
19.2.2.15 Restrictions on Examining a Pathname Directory Component  
19.2.2.16 Directory Components in Non-Hierarchical File Systems  
19.2.2.17 Restrictions on Examining a Pathname Name Component  
19.2.2.18 Restrictions on Examining a Pathname Type Component  
19.2.2.19 Restrictions on Examining a Pathname Version Component  
19.2.2.20 Notes about the Pathname Version Component  
19.2.2.21 Restrictions on Constructing Pathnames  

Merging Pathnames

19.2.3.1 Examples of Merging Pathnames  

Logical Pathnames

19.3.1 Syntax of Logical Pathname Namestrings  
19.3.2 Logical Pathname Components  

Syntax of Logical Pathname Namestrings

19.3.1.1 Additional Information about Parsing Logical Pathname Namestrings  
19.3.1.2 The Host part of a Logical Pathname Namestring  
19.3.1.3 The Device part of a Logical Pathname Namestring  
19.3.1.4 The Directory part of a Logical Pathname Namestring  
19.3.1.5 The Type part of a Logical Pathname Namestring  
19.3.1.6 The Version part of a Logical Pathname Namestring  
19.3.1.7 Wildcard Words in a Logical Pathname Namestring  
19.3.1.8 Lowercase Letters in a Logical Pathname Namestring  
19.3.1.9 Other Syntax in a Logical Pathname Namestring  

Logical Pathname Components

19.3.2.1 Unspecific Components of a Logical Pathname  
19.3.2.2 Null Strings as Components of a Logical Pathname  

Filenames Dictionary

19.4.1 pathname [System Class]  
19.4.2 logical-pathname [System Class]  
19.4.3 pathname [Function]  
19.4.4 make-pathname [Function]  
19.4.5 pathnamep [Function]  
19.4.6 pathname-host, pathname-device, pathname-directory,  
19.4.7 load-logical-pathname-translations [Function]  
19.4.8 logical-pathname-translations [Accessor]  
19.4.9 logical-pathname [Function]  
19.4.10 *default-pathname-defaults* [Variable]  
19.4.11 namestring, file-namestring, directory-namestring,  
19.4.12 parse-namestring [Function]  
19.4.13 wild-pathname-p [Function]  
19.4.14 pathname-match-p [Function]  
19.4.15 translate-logical-pathname [Function]  
19.4.16 translate-pathname [Function]  
19.4.17 merge-pathnames [Function]  

Files

20.1 File System Concepts  
20.2 Files Dictionary  

File System Concepts

20.1.1 Coercion of Streams to Pathnames  
20.1.2 File Operations on Open and Closed Streams  
20.1.3 Truenames  

Truenames

20.1.3.1 Examples of Truenames  

Files Dictionary

20.2.1 directory [Function]  
20.2.2 probe-file [Function]  
20.2.3 ensure-directories-exist [Function]  
20.2.4 truename [Function]  
20.2.5 file-author [Function]  
20.2.6 file-write-date [Function]  
20.2.7 rename-file [Function]  
20.2.8 delete-file [Function]  
20.2.9 file-error [Condition Type]  
20.2.10 file-error-pathname [Function]  

Streams

21.1 Stream Concepts  
21.2 Streams Dictionary  

Stream Concepts

21.1.1 Introduction to Streams  
21.1.2 Stream Variables  
21.1.3 Stream Arguments to Standardized Functions  
21.1.4 Restrictions on Composite Streams  

Introduction to Streams

21.1.1.1 Abstract Classifications of Streams  
21.1.1.2 Input, Output, and Bidirectional Streams  
21.1.1.3 Open and Closed Streams  
21.1.1.4 Interactive Streams  
21.1.1.5 Abstract Classifications of Streams  
21.1.1.6 File Streams  
21.1.1.7 Other Subclasses of Stream  

Streams Dictionary

21.2.1 stream [System Class]  
21.2.2 broadcast-stream [System Class]  
21.2.3 concatenated-stream [System Class]  
21.2.4 echo-stream [System Class]  
21.2.5 file-stream [System Class]  
21.2.6 string-stream [System Class]  
21.2.7 synonym-stream [System Class]  
21.2.8 two-way-stream [System Class]  
21.2.9 input-stream-p, output-stream-p [Function]  
21.2.10 interactive-stream-p [Function]  
21.2.11 open-stream-p [Function]  
21.2.12 stream-element-type [Function]  
21.2.13 streamp [Function]  
21.2.14 read-byte [Function]  
21.2.15 write-byte [Function]  
21.2.16 peek-char [Function]  
21.2.17 read-char [Function]  
21.2.18 read-char-no-hang [Function]  
21.2.19 terpri, fresh-line [Function]  
21.2.20 unread-char [Function]  
21.2.21 write-char [Function]  
21.2.22 read-line [Function]  
21.2.23 write-string, write-line [Function]  
21.2.24 read-sequence [Function]  
21.2.25 write-sequence [Function]  
21.2.26 file-length [Function]  
21.2.27 file-position [Function]  
21.2.28 file-string-length [Function]  
21.2.29 open [Function]  
21.2.30 stream-external-format [Function]  
21.2.31 with-open-file [macro]  
21.2.32 close [Function]  
21.2.33 with-open-stream [Macro]  
21.2.34 listen [Function]  
21.2.35 clear-input [Function]  
21.2.36 finish-output, force-output, clear-output [Function]  
21.2.37 y-or-n-p, yes-or-no-p [Function]  
21.2.38 make-synonym-stream [Function]  
21.2.39 synonym-stream-symbol [Function]  
21.2.40 broadcast-stream-streams [Function]  
21.2.41 make-broadcast-stream [Function]  
21.2.42 make-two-way-stream [Function]  
21.2.43 two-way-stream-input-stream, two-way-stream-output-stream  
21.2.44 echo-stream-input-stream, echo-stream-output-stream [Function]  
21.2.45 make-echo-stream [Function]  
21.2.46 concatenated-stream-streams [Function]  
21.2.47 make-concatenated-stream [Function]  
21.2.48 get-output-stream-string [Function]  
21.2.49 make-string-input-stream [Function]  
21.2.50 make-string-output-stream [Function]  
21.2.51 with-input-from-string [Macro]  
21.2.52 with-output-to-string [Macro]  
21.2.53 *debug-io*, *error-output*, *query-io*,  
21.2.54 *terminal-io* [Variable]  
21.2.55 stream-error [Condition Type]  
21.2.56 stream-error-stream [Function]  
21.2.57 end-of-file [Condition Type]  

Printer

22.1 The Lisp Printer  
22.2 The Lisp Pretty Printer  
22.3 Formatted Output  
22.4 Printer Dictionary  

The Lisp Printer

22.1.1 Overview of The Lisp Printer  
22.1.2 Printer Dispatching  
22.1.3 Default Print-Object Methods  
22.1.4 Examples of Printer Behavior  

Overview of The Lisp Printer

22.1.1.1 Multiple Possible Textual Representations  
22.1.1.2 Printer Escaping  

Default Print-Object Methods

22.1.3.1 Printing Numbers  
22.1.3.2 Printing Integers  
22.1.3.3 Printing Ratios  
22.1.3.4 Printing Floats  
22.1.3.5 Printing Complexes  
22.1.3.6 Note about Printing Numbers  
22.1.3.7 Printing Characters  
22.1.3.8 Printing Symbols  
22.1.3.9 Package Prefixes for Symbols  
22.1.3.10 Effect of Readtable Case on the Lisp Printer  
22.1.3.11 Examples of Effect of Readtable Case on the Lisp Printer  
22.1.3.12 Printing Strings  
22.1.3.13 Printing Lists and Conses  
22.1.3.14 Printing Bit Vectors  
22.1.3.15 Printing Other Vectors  
22.1.3.16 Printing Other Arrays  
22.1.3.17 Examples of Printing Arrays  
22.1.3.18 Printing Random States  
22.1.3.19 Printing Pathnames  
22.1.3.20 Printing Structures  
22.1.3.21 Printing Other Objects  

The Lisp Pretty Printer

22.2.1 Pretty Printer Concepts  
22.2.2 Examples of using the Pretty Printer  
22.2.3 Notes about the Pretty Printer's Background  

Pretty Printer Concepts

22.2.1.1 Dynamic Control of the Arrangement of Output  
22.2.1.2 Format Directive Interface  
22.2.1.3 Compiling Format Strings  
22.2.1.4 Pretty Print Dispatch Tables  
22.2.1.5 Pretty Printer Margins  

Formatted Output

22.3.1 FORMAT Basic Output  
22.3.2 FORMAT Radix Control  
22.3.3 FORMAT Floating-Point Printers  
22.3.4 FORMAT Printer Operations  
22.3.5 FORMAT Pretty Printer Operations  
22.3.6 FORMAT Layout Control  
22.3.7 FORMAT Control-Flow Operations  
22.3.8 FORMAT Miscellaneous Operations  
22.3.9 FORMAT Miscellaneous Pseudo-Operations  
22.3.10 Additional Information about FORMAT Operations  
22.3.11 Examples of FORMAT  
22.3.12 Notes about FORMAT  

FORMAT Basic Output

22.3.1.1 Tilde C: Character  
22.3.1.2 Tilde Percent: Newline  
22.3.1.3 Tilde Ampersand: Fresh-Line  
22.3.1.4 Tilde Vertical-Bar: Page  
22.3.1.5 Tilde Tilde: Tilde  

FORMAT Radix Control

22.3.2.1 Tilde R: Radix  
22.3.2.2 Tilde D: Decimal  
22.3.2.3 Tilde B: Binary  
22.3.2.4 Tilde O: Octal  
22.3.2.5 Tilde X: Hexadecimal  

FORMAT Floating-Point Printers

22.3.3.1 Tilde F: Fixed-Format Floating-Point  
22.3.3.2 Tilde E: Exponential Floating-Point  
22.3.3.3 Tilde G: General Floating-Point  
22.3.3.4 Tilde Dollarsign: Monetary Floating-Point  

FORMAT Printer Operations

22.3.4.1 Tilde A: Aesthetic  
22.3.4.2 Tilde S: Standard  
22.3.4.3 Tilde W: Write  

FORMAT Pretty Printer Operations

22.3.5.1 Tilde Underscore: Conditional Newline  
22.3.5.2 Tilde Less-Than-Sign: Logical Block  
22.3.5.3 Tilde I: Indent  
22.3.5.4 Tilde Slash: Call Function  

FORMAT Layout Control

22.3.6.1 Tilde T: Tabulate  
22.3.6.2 Tilde Less-Than-Sign: Justification  
22.3.6.3 Tilde Greater-Than-Sign: End of Justification  

FORMAT Control-Flow Operations

22.3.7.1 Tilde Asterisk: Go-To  
22.3.7.2 Tilde Left-Bracket: Conditional Expression  
22.3.7.3 Tilde Right-Bracket: End of Conditional Expression  
22.3.7.4 Tilde Left-Brace: Iteration  
22.3.7.5 Tilde Right-Brace: End of Iteration  
22.3.7.6 Tilde Question-Mark: Recursive Processing  

FORMAT Miscellaneous Operations

22.3.8.1 Tilde Left-Paren: Case Conversion  
22.3.8.2 Tilde Right-Paren: End of Case Conversion  
22.3.8.3 Tilde P: Plural  

FORMAT Miscellaneous Pseudo-Operations

22.3.9.1 Tilde Semicolon: Clause Separator  
22.3.9.2 Tilde Circumflex: Escape Upward  
22.3.9.3 Tilde Newline: Ignored Newline  

Additional Information about FORMAT Operations

22.3.10.1 Nesting of FORMAT Operations  
22.3.10.2 Missing and Additional FORMAT Arguments  
22.3.10.3 Additional FORMAT Parameters  
22.3.10.4 Undefined FORMAT Modifier Combinations  

Printer Dictionary

22.4.1 copy-pprint-dispatch [Function]  
22.4.2 formatter [Macro]  
22.4.3 pprint-dispatch [Function]  
22.4.4 pprint-exit-if-list-exhausted [Local Macro]  
22.4.5 pprint-fill, pprint-linear, pprint-tabular [Function]  
22.4.6 pprint-indent [Function]  
22.4.7 pprint-logical-block [Macro]  
22.4.8 pprint-newline [Function]  
22.4.9 pprint-pop [Local Macro]  
22.4.10 pprint-tab [Function]  
22.4.11 print-object [Standard Generic Function]  
22.4.12 print-unreadable-object [Macro]  
22.4.13 set-pprint-dispatch [Function]  
22.4.14 write, prin1, print, pprint, princ [Function]  
22.4.15 write-to-string, prin1-to-string, princ-to-string [Function]  
22.4.16 *print-array* [Variable]  
22.4.17 *print-base*, *print-radix* [Variable]  
22.4.18 *print-case* [Variable]  
22.4.19 *print-circle* [Variable]  
22.4.20 *print-escape* [Variable]  
22.4.21 *print-gensym* [Variable]  
22.4.22 *print-level*, *print-length* [Variable]  
22.4.23 *print-lines* [Variable]  
22.4.24 *print-miser-width* [Variable]  
22.4.25 *print-pprint-dispatch* [Variable]  
22.4.26 *print-pretty* [Variable]  
22.4.27 *print-readably* [Variable]  
22.4.28 *print-right-margin* [Variable]  
22.4.29 print-not-readable [Condition Type]  
22.4.30 print-not-readable-object [Function]  
22.4.31 format [Function]  

Reader

23.1 Reader Concepts  
23.2 Reader Dictionary  

Reader Concepts

23.1.1 Dynamic Control of the Lisp Reader  
23.1.2 Effect of Readtable Case on the Lisp Reader  
23.1.3 Argument Conventions of Some Reader Functions  

Effect of Readtable Case on the Lisp Reader

23.1.2.1 Examples of Effect of Readtable Case on the Lisp Reader  

Argument Conventions of Some Reader Functions

23.1.3.1 The EOF-ERROR-P argument  
23.1.3.2 The RECURSIVE-P argument  

Reader Dictionary

23.2.1 readtable [System Class]  
23.2.2 copy-readtable [Function]  
23.2.3 make-dispatch-macro-character [Function]  
23.2.4 read, read-preserving-whitespace [Function]  
23.2.5 read-delimited-list [Function]  
23.2.6 read-from-string [Function]  
23.2.7 readtable-case [Accessor]  
23.2.8 readtablep [Function]  
23.2.9 set-dispatch-macro-character, get-dispatch-macro-character  
23.2.10 set-macro-character, get-macro-character [Function]  
23.2.11 set-syntax-from-char [Function]  
23.2.12 with-standard-io-syntax [Macro]  
23.2.13 *read-base* [Variable]  
23.2.14 *read-default-float-format* [Variable]  
23.2.15 *read-eval* [Variable]  
23.2.16 *read-suppress* [Variable]  
23.2.17 *readtable* [Variable]  
23.2.18 reader-error [Condition Type]  

System Construction

24.1 System Construction Concepts  
24.2 System Construction Dictionary  

System Construction Concepts

24.1.1 Loading  
24.1.2 Features  

Features

24.1.2.1 Feature Expressions  
24.1.2.2 Examples of Feature Expressions  

System Construction Dictionary

24.2.1 compile-file [Function]  
24.2.2 compile-file-pathname [Function]  
24.2.3 load [Function]  
24.2.4 with-compilation-unit [Macro]  
24.2.5 *features* [Variable]  
24.2.6 *compile-file-pathname*, *compile-file-truename* [Variable]  
24.2.7 *load-pathname*, *load-truename* [Variable]  
24.2.8 *compile-print*, *compile-verbose* [Variable]  
24.2.9 *load-print*, *load-verbose* [Variable]  
24.2.10 *modules* [Variable]  
24.2.11 provide, require [Function]  

Environment

25.1 The External Environment  
25.2 Environment Dictionary  

The External Environment

25.1.1 Top level loop  
25.1.2 Debugging Utilities  
25.1.3 Environment Inquiry  
25.1.4 Time  

Time

25.1.4.1 Decoded Time  
25.1.4.2 Universal Time  
25.1.4.3 Internal Time  
25.1.4.4 Seconds  

Environment Dictionary

25.2.1 decode-universal-time [Function]  
25.2.2 encode-universal-time [function]  
25.2.3 get-universal-time, get-decoded-time [Function]  
25.2.4 sleep [Function]  
25.2.5 apropos, apropos-list [Function]  
25.2.6 describe [Function]  
25.2.7 describe-object [Standard Generic Function]  
25.2.8 trace, untrace [Macro]  
25.2.9 step [Macro]  
25.2.10 time [Macro]  
25.2.11 internal-time-units-per-second [Constant Variable]  
25.2.12 get-internal-real-time [Function]  
25.2.13 get-internal-run-time [Function]  
25.2.14 disassemble [Function]  
25.2.15 documentation, (setf documentation) [Standard Generic Function]  
25.2.16 room [Function]  
25.2.17 ed [Function]  
25.2.18 inspect [Function]  
25.2.19 dribble [Function]  
25.2.20 - [Variable]  
25.2.21 +, ++, +++ [Variable]  
25.2.22 *, **, *** [Variable]  
25.2.23 /, //, /// [Variable]  
25.2.24 lisp-implementation-type,  
25.2.25 short-site-name, long-site-name [Function]  
25.2.26 machine-instance [Function]  
25.2.27 machine-type [Function]  
25.2.28 machine-version [Function]  
25.2.29 software-type, software-version [Function]  
25.2.30 user-homedir-pathname [Function]  

Glossary

26.1 Glossary  

Appendix

27.1 Removed Language Features  

Removed Language Features

27.1.1 Requirements for removed and deprecated features  
27.1.2 Removed Types  
27.1.3 Removed Operators  
27.1.4 Removed Argument Conventions  
27.1.5 Removed Variables  
27.1.6 Removed Reader Syntax  
27.1.7 Packages No Longer Required  



This document was generated by root on November, 25 2000 using texi2html