\input texinfo @c -*-texinfo-*- @c %**start of header @setfilename gcl.info @settitle ANSI and GNU Common Lisp Document @c %**end of header @setchapternewpage odd @ifinfo This is a Texinfo GNU Common Lisp Manual based on the draft ANSI standard for Common Lisp. Copyright 1994 William F. Schelter @end ifinfo @titlepage @sp 10 @comment The title is printed in a large font. @center @titlefont{GNU Common Lisp Manual} @end titlepage @defcodeindex fu @c function index @defcodeindex IR @c reference index @defcodeindex IC @c Code index @defindex IT @c Text index @defindex IG @c Glossary index @defindex IE @c Example index @defcodeindex IP @c Package index @defcodeindex IK @c Keyword Index @node Top, Introduction (Introduction), (dir), (dir) @menu * Introduction (Introduction):: * Syntax:: * Evaluation and Compilation:: * Types and Classes:: * Data and Control Flow:: * Iteration:: * Objects:: * Structures:: * Conditions:: * Symbols:: * Packages:: * Numbers (Numbers):: * Characters:: * Conses:: * Arrays:: * Strings:: * Sequences:: * Hash Tables:: * Filenames:: * Files:: * Streams:: * Printer:: * Reader:: * System Construction:: * Environment:: * Glossary (Glossary):: * Appendix:: --- The Detailed Node Listing --- Introduction * Scope; Purpose; and History:: * Organization of the Document:: * Referenced Publications:: * Definitions:: * Conformance:: * Language Extensions:: * Language Subsets:: * Deprecated Language Features:: * Symbols in the COMMON-LISP Package:: Scope, Purpose, and History * Scope and Purpose:: * History:: Definitions * Notational Conventions:: * Error Terminology:: * Sections Not Formally Part Of This Standard:: * Interpreting Dictionary Entries:: Notational Conventions * Font Key:: * Modified BNF Syntax:: * Splicing in Modified BNF Syntax:: * Indirection in Modified BNF Syntax:: * Additional Uses for Indirect Definitions in Modified BNF Syntax:: * Special Symbols:: * Objects with Multiple Notations:: * Case in Symbols:: * Numbers (Objects with Multiple Notations):: * Use of the Dot Character:: * NIL:: * Designators:: * Nonsense Words:: Interpreting Dictionary Entries * The ``Affected By'' Section of a Dictionary Entry:: * The ``Arguments'' Section of a Dictionary Entry:: * The ``Arguments and Values'' Section of a Dictionary Entry:: * The ``Binding Types Affected'' Section of a Dictionary Entry:: * The ``Class Precedence List'' Section of a Dictionary Entry:: * Dictionary Entries for Type Specifiers:: * The ``Compound Type Specifier Kind'' Section of a Dictionary Entry:: * The ``Compound Type Specifier Syntax'' Section of a Dictionary Entry:: * The ``Compound Type Specifier Arguments'' Section of a Dictionary Entry:: * The ``Compound Type Specifier Description'' Section of a Dictionary Entry:: * The ``Constant Value'' Section of a Dictionary Entry:: * The ``Description'' Section of a Dictionary Entry:: * The ``Examples'' Section of a Dictionary Entry:: * The ``Exceptional Situations'' Section of a Dictionary Entry:: * The ``Initial Value'' Section of a Dictionary Entry:: * The ``Argument Precedence Order'' Section of a Dictionary Entry:: * The ``Method Signature'' Section of a Dictionary Entry:: * The ``Name'' Section of a Dictionary Entry:: * The ``Notes'' Section of a Dictionary Entry:: * The ``Pronunciation'' Section of a Dictionary Entry:: * The ``See Also'' Section of a Dictionary Entry:: * The ``Side Effects'' Section of a Dictionary Entry:: * The ``Supertypes'' Section of a Dictionary Entry:: * The ``Syntax'' Section of a Dictionary Entry:: * Special ``Syntax'' Notations for Overloaded Operators:: * Naming Conventions for Rest Parameters:: * Requiring Non-Null Rest Parameters in the ``Syntax'' Section:: * Return values in the ``Syntax'' Section:: * No Arguments or Values in the ``Syntax'' Section:: * Unconditional Transfer of Control in the ``Syntax'' Section:: * The ``Valid Context'' Section of a Dictionary Entry:: * The ``Value Type'' Section of a Dictionary Entry:: Conformance * Conforming Implementations:: * Conforming Programs:: Conforming Implementations * Required Language Features:: * Documentation of Implementation-Dependent Features:: * Documentation of Extensions:: * Treatment of Exceptional Situations:: * Resolution of Apparent Conflicts in Exceptional Situations:: * Examples of Resolution of Apparent Conflict in Exceptional Situations:: * Conformance Statement:: Conforming Programs * Use of Implementation-Defined Language Features:: * Use of Read-Time Conditionals:: Deprecated Language Features * Deprecated Functions:: * Deprecated Argument Conventions:: * Deprecated Variables:: * Deprecated Reader Syntax:: Syntax * Character Syntax:: * Reader Algorithm:: * Interpretation of Tokens:: * Standard Macro Characters:: Character Syntax * Readtables:: * Variables that affect the Lisp Reader:: * Standard Characters:: * Character Syntax Types:: Readtables * The Current Readtable:: * The Standard Readtable:: * The Initial Readtable:: Character Syntax Types * Constituent Characters:: * Constituent Traits:: * Invalid Characters:: * Macro Characters:: * Multiple Escape Characters:: * Examples of Multiple Escape Characters:: * Single Escape Character:: * Examples of Single Escape Characters:: * Whitespace Characters:: * Examples of Whitespace Characters:: Interpretation of Tokens * Numbers as Tokens:: * Constructing Numbers from Tokens:: * The Consing Dot:: * Symbols as Tokens:: * Valid Patterns for Tokens:: * Package System Consistency Rules:: Numbers as Tokens * Potential Numbers as Tokens:: * Escape Characters and Potential Numbers:: * Examples of Potential Numbers:: Constructing Numbers from Tokens * Syntax of a Rational:: * Syntax of an Integer:: * Syntax of a Ratio:: * Syntax of a Float:: * Syntax of a Complex:: Standard Macro Characters * Left-Parenthesis:: * Right-Parenthesis:: * Single-Quote:: * Semicolon:: * Double-Quote:: * Backquote:: * Comma:: * Sharpsign:: * Re-Reading Abbreviated Expressions:: Single-Quote * Examples of Single-Quote:: Semicolon * Examples of Semicolon:: * Notes about Style for Semicolon:: * Use of Single Semicolon:: * Use of Double Semicolon:: * Use of Triple Semicolon:: * Use of Quadruple Semicolon:: * Examples of Style for Semicolon:: Backquote * Notes about Backquote:: Sharpsign * Sharpsign Backslash:: * Sharpsign Single-Quote:: * Sharpsign Left-Parenthesis:: * Sharpsign Asterisk:: * Examples of Sharpsign Asterisk:: * Sharpsign Colon:: * Sharpsign Dot:: * Sharpsign B:: * Sharpsign O:: * Sharpsign X:: * Sharpsign R:: * Sharpsign C:: * Sharpsign A:: * Sharpsign S:: * Sharpsign P:: * Sharpsign Equal-Sign:: * Sharpsign Sharpsign:: * Sharpsign Plus:: * Sharpsign Minus:: * Sharpsign Vertical-Bar:: * Examples of Sharpsign Vertical-Bar:: * Notes about Style for Sharpsign Vertical-Bar:: * Sharpsign Less-Than-Sign:: * Sharpsign Whitespace:: * Sharpsign Right-Parenthesis:: Evaluation and Compilation * Evaluation:: * Compilation:: * Declarations:: * Lambda Lists:: * Error Checking in Function Calls:: * Traversal Rules and Side Effects:: * Destructive Operations:: * Evaluation and Compilation Dictionary:: Evaluation * Introduction to Environments:: * The Evaluation Model:: * Lambda Expressions:: * Closures and Lexical Binding:: * Shadowing:: * Extent:: * Return Values:: Introduction to Environments * The Global Environment:: * Dynamic Environments:: * Lexical Environments:: * The Null Lexical Environment:: * Environment Objects:: The Evaluation Model * Form Evaluation:: * Symbols as Forms:: * Lexical Variables:: * Dynamic Variables:: * Constant Variables:: * Symbols Naming Both Lexical and Dynamic Variables:: * Conses as Forms:: * Special Forms:: * Macro Forms:: * Function Forms:: * Lambda Forms:: * Self-Evaluating Objects:: * Examples of Self-Evaluating Objects:: Compilation * Compiler Terminology:: * Compilation Semantics:: * File Compilation:: * Literal Objects in Compiled Files:: * Exceptional Situations in the Compiler:: Compilation Semantics * Compiler Macros:: * Purpose of Compiler Macros:: * Naming of Compiler Macros:: * When Compiler Macros Are Used:: * Notes about the Implementation of Compiler Macros:: * Minimal Compilation:: * Semantic Constraints:: File Compilation * Processing of Top Level Forms:: * Processing of Defining Macros:: * Constraints on Macros and Compiler Macros:: Literal Objects in Compiled Files * Externalizable Objects:: * Similarity of Literal Objects:: * Similarity of Aggregate Objects:: * Definition of Similarity:: * Extensions to Similarity Rules:: * Additional Constraints on Externalizable Objects:: Declarations * Minimal Declaration Processing Requirements:: * Declaration Specifiers:: * Declaration Identifiers:: * Declaration Scope:: Declaration Identifiers * Shorthand notation for Type Declarations:: Declaration Scope * Examples of Declaration Scope:: Lambda Lists * Ordinary Lambda Lists:: * Generic Function Lambda Lists:: * Specialized Lambda Lists:: * Macro Lambda Lists:: * Destructuring Lambda Lists:: * Boa Lambda Lists:: * Defsetf Lambda Lists:: * Deftype Lambda Lists:: * Define-modify-macro Lambda Lists:: * Define-method-combination Arguments Lambda Lists:: * Syntactic Interaction of Documentation Strings and Declarations:: Ordinary Lambda Lists * Specifiers for the required parameters:: * Specifiers for optional parameters:: * A specifier for a rest parameter:: * Specifiers for keyword parameters:: * Suppressing Keyword Argument Checking:: * Examples of Suppressing Keyword Argument Checking:: * Specifiers for @b{&aux} variables:: * Examples of Ordinary Lambda Lists:: Macro Lambda Lists * Destructuring by Lambda Lists:: * Data-directed Destructuring by Lambda Lists:: * Examples of Data-directed Destructuring by Lambda Lists:: * Lambda-list-directed Destructuring by Lambda Lists:: Error Checking in Function Calls * Argument Mismatch Detection:: Argument Mismatch Detection * Safe and Unsafe Calls:: * Error Detection Time in Safe Calls:: * Too Few Arguments:: * Too Many Arguments:: * Unrecognized Keyword Arguments:: * Invalid Keyword Arguments:: * Odd Number of Keyword Arguments:: * Destructuring Mismatch:: * Errors When Calling a Next Method:: Destructive Operations * Modification of Literal Objects:: * Transfer of Control during a Destructive Operation:: Transfer of Control during a Destructive Operation * Examples of Transfer of Control during a Destructive Operation:: Evaluation and Compilation Dictionary * lambda (Symbol):: * lambda:: * compile:: * eval:: * eval-when:: * load-time-value:: * quote:: * compiler-macro-function:: * define-compiler-macro:: * defmacro:: * macro-function:: * macroexpand; macroexpand-1:: * define-symbol-macro:: * symbol-macrolet:: * *macroexpand-hook*:: * proclaim:: * declaim:: * declare:: * ignore; ignorable:: * dynamic-extent:: * type:: * inline; notinline:: * ftype:: * declaration:: * optimize:: * special:: * locally:: * the:: * special-operator-p:: * constantp:: Types and Classes * Introduction (Types and Classes):: * Types:: * Classes:: * Types and Classes Dictionary:: Types * Data Type Definition:: * Type Relationships:: * Type Specifiers:: Classes * Introduction to Classes:: * Defining Classes:: * Creating Instances of Classes:: * Inheritance:: * Determining the Class Precedence List:: * Redefining Classes:: * Integrating Types and Classes:: Introduction to Classes * Standard Metaclasses:: Inheritance * Examples of Inheritance:: * Inheritance of Class Options:: Determining the Class Precedence List * Topological Sorting:: * Examples of Class Precedence List Determination:: Redefining Classes * Modifying the Structure of Instances:: * Initializing Newly Added Local Slots (Redefining Classes):: * Customizing Class Redefinition:: Types and Classes Dictionary * nil (Type):: * boolean:: * function (System Class):: * compiled-function:: * generic-function:: * standard-generic-function:: * class:: * built-in-class:: * structure-class:: * standard-class:: * method:: * standard-method:: * structure-object:: * standard-object:: * method-combination:: * t (System Class):: * satisfies:: * member:: * not (Type Specifier):: * and (Type Specifier):: * or (Type Specifier):: * values (Type Specifier):: * eql (Type Specifier):: * coerce:: * deftype:: * subtypep:: * type-of:: * typep:: * type-error:: * type-error-datum; type-error-expected-type:: * simple-type-error:: Data and Control Flow * Generalized Reference:: * Transfer of Control to an Exit Point:: * Data and Control Flow Dictionary:: Generalized Reference * Overview of Places and Generalized Reference:: * Kinds of Places:: * Treatment of Other Macros Based on SETF:: Overview of Places and Generalized Reference * Evaluation of Subforms to Places:: * Examples of Evaluation of Subforms to Places:: * Setf Expansions:: * Examples of Setf Expansions:: Kinds of Places * Variable Names as Places:: * Function Call Forms as Places:: * VALUES Forms as Places:: * THE Forms as Places:: * APPLY Forms as Places:: * Setf Expansions and Places:: * Macro Forms as Places:: * Symbol Macros as Places:: * Other Compound Forms as Places:: Data and Control Flow Dictionary * apply:: * defun:: * fdefinition:: * fboundp:: * fmakunbound:: * flet; labels; macrolet:: * funcall:: * function (Special Operator):: * function-lambda-expression:: * functionp:: * compiled-function-p:: * call-arguments-limit:: * lambda-list-keywords:: * lambda-parameters-limit:: * defconstant:: * defparameter; defvar:: * destructuring-bind:: * let; let*:: * progv:: * setq:: * psetq:: * block:: * catch:: * go:: * return-from:: * return:: * tagbody:: * throw:: * unwind-protect:: * nil:: * not:: * t:: * eq:: * eql:: * equal:: * equalp:: * identity:: * complement:: * constantly:: * every; some; notevery; notany:: * and:: * cond:: * if:: * or:: * when; unless:: * case; ccase; ecase:: * typecase; ctypecase; etypecase:: * multiple-value-bind:: * multiple-value-call:: * multiple-value-list:: * multiple-value-prog1:: * multiple-value-setq:: * values:: * values-list:: * multiple-values-limit:: * nth-value:: * prog; prog*:: * prog1; prog2:: * progn:: * define-modify-macro:: * defsetf:: * define-setf-expander:: * get-setf-expansion:: * setf; psetf:: * shiftf:: * rotatef:: * control-error:: * program-error:: * undefined-function:: Iteration * The LOOP Facility:: * Iteration Dictionary:: The LOOP Facility * Overview of the Loop Facility:: * Variable Initialization and Stepping Clauses:: * Value Accumulation Clauses:: * Termination Test Clauses:: * Unconditional Execution Clauses:: * Conditional Execution Clauses:: * Miscellaneous Clauses:: * Examples of Miscellaneous Loop Features:: * Notes about Loop:: Overview of the Loop Facility * Simple vs Extended Loop:: * Simple Loop:: * Extended Loop:: * Loop Keywords:: * Parsing Loop Clauses:: * Expanding Loop Forms:: * Summary of Loop Clauses:: * Summary of Variable Initialization and Stepping Clauses:: * Summary of Value Accumulation Clauses:: * Summary of Termination Test Clauses:: * Summary of Unconditional Execution Clauses:: * Summary of Conditional Execution Clauses:: * Summary of Miscellaneous Clauses:: * Order of Execution:: * Destructuring:: * Restrictions on Side-Effects:: Variable Initialization and Stepping Clauses * Iteration Control:: * The for-as-arithmetic subclause:: * Examples of for-as-arithmetic subclause:: * The for-as-in-list subclause:: * Examples of for-as-in-list subclause:: * The for-as-on-list subclause:: * Examples of for-as-on-list subclause:: * The for-as-equals-then subclause:: * Examples of for-as-equals-then subclause:: * The for-as-across subclause:: * Examples of for-as-across subclause:: * The for-as-hash subclause:: * The for-as-package subclause:: * Examples of for-as-package subclause:: * Local Variable Initializations:: * Examples of WITH clause:: Value Accumulation Clauses * Examples of COLLECT clause:: * Examples of APPEND and NCONC clauses:: * Examples of COUNT clause:: * Examples of MAXIMIZE and MINIMIZE clauses:: * Examples of SUM clause:: Termination Test Clauses * Examples of REPEAT clause:: * Examples of ALWAYS; NEVER; and THEREIS clauses:: * Examples of WHILE and UNTIL clauses:: Unconditional Execution Clauses * Examples of unconditional execution:: Conditional Execution Clauses * Examples of WHEN clause:: Miscellaneous Clauses * Control Transfer Clauses:: * Examples of NAMED clause:: * Initial and Final Execution:: Examples of Miscellaneous Loop Features * Examples of clause grouping:: Iteration Dictionary * do; do*:: * dotimes:: * dolist:: * loop:: * loop-finish:: Objects * Object Creation and Initialization:: * Changing the Class of an Instance:: * Reinitializing an Instance:: * Meta-Objects:: * Slots:: * Generic Functions and Methods:: * Objects Dictionary:: Object Creation and Initialization * Initialization Arguments:: * Declaring the Validity of Initialization Arguments:: * Defaulting of Initialization Arguments:: * Rules for Initialization Arguments:: * Shared-Initialize:: * Initialize-Instance:: * Definitions of Make-Instance and Initialize-Instance:: Changing the Class of an Instance * Modifying the Structure of the Instance:: * Initializing Newly Added Local Slots (Changing the Class of an Instance):: * Customizing the Change of Class of an Instance:: Reinitializing an Instance * Customizing Reinitialization:: Meta-Objects * Standard Meta-objects:: Slots * Introduction to Slots:: * Accessing Slots:: * Inheritance of Slots and Slot Options:: Generic Functions and Methods * Introduction to Generic Functions:: * Introduction to Methods:: * Agreement on Parameter Specializers and Qualifiers:: * Congruent Lambda-lists for all Methods of a Generic Function:: * Keyword Arguments in Generic Functions and Methods:: * Method Selection and Combination:: * Inheritance of Methods:: Keyword Arguments in Generic Functions and Methods * Examples of Keyword Arguments in Generic Functions and Methods:: Method Selection and Combination * Determining the Effective Method:: * Selecting the Applicable Methods:: * Sorting the Applicable Methods by Precedence Order:: * Applying method combination to the sorted list of applicable methods:: * Standard Method Combination:: * Declarative Method Combination:: * Built-in Method Combination Types:: Objects Dictionary * function-keywords:: * ensure-generic-function:: * allocate-instance:: * reinitialize-instance:: * shared-initialize:: * update-instance-for-different-class:: * update-instance-for-redefined-class:: * change-class:: * slot-boundp:: * slot-exists-p:: * slot-makunbound:: * slot-missing:: * slot-unbound:: * slot-value:: * method-qualifiers:: * no-applicable-method:: * no-next-method:: * remove-method:: * make-instance:: * make-instances-obsolete:: * make-load-form:: * make-load-form-saving-slots:: * with-accessors:: * with-slots:: * defclass:: * defgeneric:: * defmethod:: * find-class:: * next-method-p:: * call-method; make-method:: * call-next-method:: * compute-applicable-methods:: * define-method-combination:: * find-method:: * add-method:: * initialize-instance:: * class-name:: * (setf class-name):: * class-of:: * unbound-slot:: * unbound-slot-instance:: Structures * Structures Dictionary:: Structures Dictionary * defstruct:: * copy-structure:: Conditions * Condition System Concepts:: * Conditions Dictionary:: Condition System Concepts * Condition Types:: * Creating Conditions:: * Printing Conditions:: * Signaling and Handling Conditions:: * Assertions:: * Notes about the Condition System's Background:: Condition Types * Serious Conditions:: Creating Conditions * Condition Designators:: Printing Conditions * Recommended Style in Condition Reporting:: * Capitalization and Punctuation in Condition Reports:: * Leading and Trailing Newlines in Condition Reports:: * Embedded Newlines in Condition Reports:: * Note about Tabs in Condition Reports:: * Mentioning Containing Function in Condition Reports:: Signaling and Handling Conditions * Signaling:: * Resignaling a Condition:: * Restarts:: * Interactive Use of Restarts:: * Interfaces to Restarts:: * Restart Tests:: * Associating a Restart with a Condition:: Conditions Dictionary * condition:: * warning:: * style-warning:: * serious-condition:: * error (Condition Type):: * cell-error:: * cell-error-name:: * parse-error:: * storage-condition:: * assert:: * error:: * cerror:: * check-type:: * simple-error:: * invalid-method-error:: * method-combination-error:: * signal:: * simple-condition:: * simple-condition-format-control; simple-condition-format-arguments:: * warn:: * simple-warning:: * invoke-debugger:: * break:: * *debugger-hook*:: * *break-on-signals*:: * handler-bind:: * handler-case:: * ignore-errors:: * define-condition:: * make-condition:: * restart:: * compute-restarts:: * find-restart:: * invoke-restart:: * invoke-restart-interactively:: * restart-bind:: * restart-case:: * restart-name:: * with-condition-restarts:: * with-simple-restart:: * abort:: * continue:: * muffle-warning:: * store-value:: * use-value:: * abort; continue; muffle-warning; store-value; use-value:: Symbols * Symbol Concepts:: * Symbols Dictionary:: Symbols Dictionary * symbol:: * keyword:: * symbolp:: * keywordp:: * make-symbol:: * copy-symbol:: * gensym:: * *gensym-counter*:: * gentemp:: * symbol-function:: * symbol-name:: * symbol-package:: * symbol-plist:: * symbol-value:: * get:: * remprop:: * boundp:: * makunbound:: * set:: * unbound-variable:: Packages * Package Concepts:: * Packages Dictionary:: Package Concepts * Introduction to Packages:: * Standardized Packages:: Introduction to Packages * Package Names and Nicknames:: * Symbols in a Package:: * Internal and External Symbols:: * Package Inheritance:: * Accessibility of Symbols in a Package:: * Locating a Symbol in a Package:: * Prevention of Name Conflicts in Packages:: Standardized Packages * The COMMON-LISP Package:: * Constraints on the COMMON-LISP Package for Conforming Implementations:: * Constraints on the COMMON-LISP Package for Conforming Programs:: * Some Exceptions to Constraints on the COMMON-LISP Package for Conforming Programs:: * The COMMON-LISP-USER Package:: * The KEYWORD Package:: * Interning a Symbol in the KEYWORD Package:: * Notes about The KEYWORD Package:: * Implementation-Defined Packages:: Packages Dictionary * package:: * export:: * find-symbol:: * find-package:: * find-all-symbols:: * import:: * list-all-packages:: * rename-package:: * shadow:: * shadowing-import:: * delete-package:: * make-package:: * with-package-iterator:: * unexport:: * unintern:: * in-package:: * unuse-package:: * use-package:: * defpackage:: * do-symbols; do-external-symbols; do-all-symbols:: * intern:: * package-name:: * package-nicknames:: * package-shadowing-symbols:: * package-use-list:: * package-used-by-list:: * packagep:: * *package*:: * package-error:: * package-error-package:: Numbers * Number Concepts:: * Numbers Dictionary:: Number Concepts * Numeric Operations:: * Implementation-Dependent Numeric Constants:: * Rational Computations:: * Floating-point Computations:: * Complex Computations:: * Interval Designators:: * Random-State Operations:: Numeric Operations * Associativity and Commutativity in Numeric Operations:: * Examples of Associativity and Commutativity in Numeric Operations:: * Contagion in Numeric Operations:: * Viewing Integers as Bits and Bytes:: * Logical Operations on Integers:: * Byte Operations on Integers:: Rational Computations * Rule of Unbounded Rational Precision:: * Rule of Canonical Representation for Rationals:: * Rule of Float Substitutability:: Floating-point Computations * Rule of Float and Rational Contagion:: * Examples of Rule of Float and Rational Contagion:: * Rule of Float Approximation:: * Rule of Float Underflow and Overflow:: * Rule of Float Precision Contagion:: Complex Computations * Rule of Complex Substitutability:: * Rule of Complex Contagion:: * Rule of Canonical Representation for Complex Rationals:: * Examples of Rule of Canonical Representation for Complex Rationals:: * Principal Values and Branch Cuts:: Numbers Dictionary * number:: * complex (System Class):: * real:: * float (System Class):: * short-float; single-float; double-float; long-float:: * rational:: * ratio:: * integer:: * signed-byte:: * unsigned-byte:: * mod:: * bit:: * fixnum:: * bignum:: * =; /=; <; >; <=; >=:: * max; min:: * minusp; plusp:: * zerop:: * floor; ffloor; ceiling; fceiling; truncate; ftruncate; round; fround:: * sin; cos; tan:: * asin; acos; atan:: * pi:: * sinh; cosh; tanh; asinh; acosh; atanh:: * *:: * +:: * -:: * /:: * 1+; 1-:: * abs:: * evenp; oddp:: * exp; expt:: * gcd:: * incf; decf:: * lcm:: * log:: * mod; rem:: * signum:: * sqrt; isqrt:: * random-state:: * make-random-state:: * random:: * random-state-p:: * *random-state*:: * numberp:: * cis:: * complex:: * complexp:: * conjugate:: * phase:: * realpart; imagpart:: * upgraded-complex-part-type:: * realp:: * numerator; denominator:: * rational; rationalize:: * rationalp:: * ash:: * integer-length:: * integerp:: * parse-integer:: * boole:: * boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-c2; boole-clr; boole-eqv; boole-ior; boole-nand; boole-nor; boole-orc1; boole-orc2; boole-set; boole-xor:: * logand; logandc1; logandc2; logeqv; logior; lognand; lognor; lognot; logorc1; logorc2; logxor:: * logbitp:: * logcount:: * logtest:: * byte; byte-size; byte-position:: * deposit-field:: * dpb:: * ldb:: * ldb-test:: * mask-field:: * most-positive-fixnum; most-negative-fixnum:: * decode-float; scale-float; float-radix; float-sign; float-digits; float-precision; integer-decode-float:: * float:: * floatp:: * most-positive-short-float; least-positive-short-float; least-positive-normalized-short-float; most-positive-double-float; least-positive-double-float; least-positive-normalized-double-float; most-positive-long-float; least-positive-long-float; least-positive-normalized-long-float; most-positive-single-float; least-positive-single-float; least-positive-normalized-single-float; most-negative-short-float; least-negative-short-float; least-negative-normalized-short-float; most-negative-single-float; least-negative-single-float; least-negative-normalized-single-float; most-negative-double-float; least-negative-double-float; least-negative-normalized-double-float; most-negative-long-float; least-negative-long-float; least-negative-normalized-long-float:: * short-float-epsilon; short-float-negative-epsilon; single-float-epsilon; single-float-negative-epsilon; double-float-epsilon; double-float-negative-epsilon; long-float-epsilon; long-float-negative-epsilon:: * arithmetic-error:: * arithmetic-error-operands; arithmetic-error-operation:: * division-by-zero:: * floating-point-invalid-operation:: * floating-point-inexact:: * floating-point-overflow:: * floating-point-underflow:: Characters * Character Concepts:: * Characters Dictionary:: Character Concepts * Introduction to Characters:: * Introduction to Scripts and Repertoires:: * Character Attributes:: * Character Categories:: * Identity of Characters:: * Ordering of Characters:: * Character Names:: * Treatment of Newline during Input and Output:: * Character Encodings:: * Documentation of Implementation-Defined Scripts:: Introduction to Scripts and Repertoires * Character Scripts:: * Character Repertoires:: Character Categories * Graphic Characters:: * Alphabetic Characters:: * Characters With Case:: * Uppercase Characters:: * Lowercase Characters:: * Corresponding Characters in the Other Case:: * Case of Implementation-Defined Characters:: * Numeric Characters:: * Alphanumeric Characters:: * Digits in a Radix:: Characters Dictionary * character (System Class):: * base-char:: * standard-char:: * extended-char:: * char=; char/=; char<; char>; char<=; char>=; char-equal; char-not-equal; char-lessp; char-greaterp; char-not-greaterp; char-not-lessp:: * character:: * characterp:: * alpha-char-p:: * alphanumericp:: * digit-char:: * digit-char-p:: * graphic-char-p:: * standard-char-p:: * char-upcase; char-downcase:: * upper-case-p; lower-case-p; both-case-p:: * char-code:: * char-int:: * code-char:: * char-code-limit:: * char-name:: * name-char:: Conses * Cons Concepts:: * Conses Dictionary:: Cons Concepts * Conses as Trees:: * Conses as Lists:: Conses as Trees * General Restrictions on Parameters that must be Trees:: Conses as Lists * Lists as Association Lists:: * Lists as Sets:: * General Restrictions on Parameters that must be Lists:: Conses Dictionary * list:: * null (System Class):: * cons (System Class):: * atom (Type):: * cons:: * consp:: * atom:: * rplaca; rplacd:: * car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cdadr; cddar; cdddr; caaaar; caaadr; caadar; caaddr; cadaar; cadadr; caddar; cadddr; cdaaar; cdaadr; cdadar; cdaddr; cddaar; cddadr; cdddar; cddddr:: * copy-tree:: * sublis; nsublis:: * subst; subst-if; subst-if-not; nsubst; nsubst-if; nsubst-if-not:: * tree-equal:: * copy-list:: * list; list*:: * list-length:: * listp:: * make-list:: * push:: * pop:: * first; second; third; fourth; fifth; sixth; seventh; eighth; ninth; tenth:: * nth:: * endp:: * null:: * nconc:: * append:: * revappend; nreconc:: * butlast; nbutlast:: * last:: * ldiff; tailp:: * nthcdr:: * rest:: * member; member-if; member-if-not:: * mapc; mapcar; mapcan; mapl; maplist; mapcon:: * acons:: * assoc; assoc-if; assoc-if-not:: * copy-alist:: * pairlis:: * rassoc; rassoc-if; rassoc-if-not:: * get-properties:: * getf:: * remf:: * intersection; nintersection:: * adjoin:: * pushnew:: * set-difference; nset-difference:: * set-exclusive-or; nset-exclusive-or:: * subsetp:: * union; nunion:: Arrays * Array Concepts:: * Arrays Dictionary:: Array Concepts * Array Elements:: * Specialized Arrays:: Array Elements * Array Indices:: * Array Dimensions:: * Implementation Limits on Individual Array Dimensions:: * Array Rank:: * Vectors:: * Fill Pointers:: * Multidimensional Arrays:: * Storage Layout for Multidimensional Arrays:: * Implementation Limits on Array Rank:: Specialized Arrays * Array Upgrading:: * Required Kinds of Specialized Arrays:: Arrays Dictionary * array:: * simple-array:: * vector (System Class):: * simple-vector:: * bit-vector:: * simple-bit-vector:: * make-array:: * adjust-array:: * adjustable-array-p:: * aref:: * array-dimension:: * array-dimensions:: * array-element-type:: * array-has-fill-pointer-p:: * array-displacement:: * array-in-bounds-p:: * array-rank:: * array-row-major-index:: * array-total-size:: * arrayp:: * fill-pointer:: * row-major-aref:: * upgraded-array-element-type:: * array-dimension-limit:: * array-rank-limit:: * array-total-size-limit:: * simple-vector-p:: * svref:: * vector:: * vector-pop:: * vector-push; vector-push-extend:: * vectorp:: * bit; sbit:: * bit-and; bit-andc1; bit-andc2; bit-eqv; bit-ior; bit-nand; bit-nor; bit-not; bit-orc1; bit-orc2; bit-xor:: * bit-vector-p:: * simple-bit-vector-p:: Strings * String Concepts:: * Strings Dictionary:: String Concepts * Implications of Strings Being Arrays:: * Subtypes of STRING:: Strings Dictionary * string (System Class):: * base-string:: * simple-string:: * simple-base-string:: * simple-string-p:: * char; schar:: * string:: * string-upcase; string-downcase; string-capitalize; nstring-upcase; nstring-downcase; nstring-capitalize:: * string-trim; string-left-trim; string-right-trim:: * string=; string/=; string<; string>; string<=; string>=; string-equal; string-not-equal; string-lessp; string-greaterp; string-not-greaterp; string-not-lessp:: * stringp:: * make-string:: Sequences * Sequence Concepts:: * Rules about Test Functions:: * Sequences Dictionary:: Sequence Concepts * General Restrictions on Parameters that must be Sequences:: Rules about Test Functions * Satisfying a Two-Argument Test:: * Satisfying a One-Argument Test:: Satisfying a Two-Argument Test * Examples of Satisfying a Two-Argument Test:: Satisfying a One-Argument Test * Examples of Satisfying a One-Argument Test:: Sequences Dictionary * sequence:: * copy-seq:: * elt:: * fill:: * make-sequence:: * subseq:: * map:: * map-into:: * reduce:: * count; count-if; count-if-not:: * length:: * reverse; nreverse:: * sort; stable-sort:: * find; find-if; find-if-not:: * position; position-if; position-if-not:: * search:: * mismatch:: * replace:: * substitute; substitute-if; substitute-if-not; nsubstitute; nsubstitute-if; nsubstitute-if-not:: * concatenate:: * merge:: * remove; remove-if; remove-if-not; delete; delete-if; delete-if-not:: * remove-duplicates; delete-duplicates:: Hash Tables * Hash Table Concepts:: * Hash Tables Dictionary:: Hash Table Concepts * Hash-Table Operations:: * Modifying Hash Table Keys:: Modifying Hash Table Keys * Visible Modification of Objects with respect to EQ and EQL:: * Visible Modification of Objects with respect to EQUAL:: * Visible Modification of Conses with respect to EQUAL:: * Visible Modification of Bit Vectors and Strings with respect to EQUAL:: * Visible Modification of Objects with respect to EQUALP:: * Visible Modification of Structures with respect to EQUALP:: * Visible Modification of Arrays with respect to EQUALP:: * Visible Modification of Hash Tables with respect to EQUALP:: * Visible Modifications by Language Extensions:: Hash Tables Dictionary * hash-table:: * make-hash-table:: * hash-table-p:: * hash-table-count:: * hash-table-rehash-size:: * hash-table-rehash-threshold:: * hash-table-size:: * hash-table-test:: * gethash:: * remhash:: * maphash:: * with-hash-table-iterator:: * clrhash:: * sxhash:: Filenames * Overview of Filenames:: * Pathnames:: * Logical Pathnames:: * Filenames Dictionary:: Overview of Filenames * Namestrings as Filenames:: * Pathnames as Filenames:: * Parsing Namestrings Into Pathnames:: Pathnames * Pathname Components:: * Interpreting Pathname Component Values:: * Merging Pathnames:: Pathname Components * The Pathname Host Component:: * The Pathname Device Component:: * The Pathname Directory Component:: * The Pathname Name Component:: * The Pathname Type Component:: * The Pathname Version Component:: Interpreting Pathname Component Values * Strings in Component Values:: * Special Characters in Pathname Components:: * Case in Pathname Components:: * Local Case in Pathname Components:: * Common Case in Pathname Components:: * Special Pathname Component Values:: * NIL as a Component Value:: * :WILD as a Component Value:: * :UNSPECIFIC as a Component Value:: * Relation between component values NIL and :UNSPECIFIC:: * Restrictions on Wildcard Pathnames:: * Restrictions on Examining Pathname Components:: * Restrictions on Examining a Pathname Host Component:: * Restrictions on Examining a Pathname Device Component:: * Restrictions on Examining a Pathname Directory Component:: * Directory Components in Non-Hierarchical File Systems:: * Restrictions on Examining a Pathname Name Component:: * Restrictions on Examining a Pathname Type Component:: * Restrictions on Examining a Pathname Version Component:: * Notes about the Pathname Version Component:: * Restrictions on Constructing Pathnames:: Merging Pathnames * Examples of Merging Pathnames:: Logical Pathnames * Syntax of Logical Pathname Namestrings:: * Logical Pathname Components:: Syntax of Logical Pathname Namestrings * Additional Information about Parsing Logical Pathname Namestrings:: * The Host part of a Logical Pathname Namestring:: * The Device part of a Logical Pathname Namestring:: * The Directory part of a Logical Pathname Namestring:: * The Type part of a Logical Pathname Namestring:: * The Version part of a Logical Pathname Namestring:: * Wildcard Words in a Logical Pathname Namestring:: * Lowercase Letters in a Logical Pathname Namestring:: * Other Syntax in a Logical Pathname Namestring:: Logical Pathname Components * Unspecific Components of a Logical Pathname:: * Null Strings as Components of a Logical Pathname:: Filenames Dictionary * pathname (System Class):: * logical-pathname (System Class):: * pathname:: * make-pathname:: * pathnamep:: * pathname-host; pathname-device; pathname-directory; pathname-name; pathname-type; pathname-version:: * load-logical-pathname-translations:: * logical-pathname-translations:: * logical-pathname:: * *default-pathname-defaults*:: * namestring; file-namestring; directory-namestring; host-namestring; enough-namestring:: * parse-namestring:: * wild-pathname-p:: * pathname-match-p:: * translate-logical-pathname:: * translate-pathname:: * merge-pathnames:: Files * File System Concepts:: * Files Dictionary:: File System Concepts * Coercion of Streams to Pathnames:: * File Operations on Open and Closed Streams:: * Truenames:: Truenames * Examples of Truenames:: Files Dictionary * directory:: * probe-file:: * ensure-directories-exist:: * truename:: * file-author:: * file-write-date:: * rename-file:: * delete-file:: * file-error:: * file-error-pathname:: Streams * Stream Concepts:: * Streams Dictionary:: Stream Concepts * Introduction to Streams:: * Stream Variables:: * Stream Arguments to Standardized Functions:: * Restrictions on Composite Streams:: Introduction to Streams * Abstract Classifications of Streams (Introduction to Streams):: * Input; Output; and Bidirectional Streams:: * Open and Closed Streams:: * Interactive Streams:: * Abstract Classifications of Streams:: * File Streams:: * Other Subclasses of Stream:: Streams Dictionary * stream:: * broadcast-stream:: * concatenated-stream:: * echo-stream:: * file-stream:: * string-stream:: * synonym-stream:: * two-way-stream:: * input-stream-p; output-stream-p:: * interactive-stream-p:: * open-stream-p:: * stream-element-type:: * streamp:: * read-byte:: * write-byte:: * peek-char:: * read-char:: * read-char-no-hang:: * terpri; fresh-line:: * unread-char:: * write-char:: * read-line:: * write-string; write-line:: * read-sequence:: * write-sequence:: * file-length:: * file-position:: * file-string-length:: * open:: * stream-external-format:: * with-open-file:: * close:: * with-open-stream:: * listen:: * clear-input:: * finish-output; force-output; clear-output:: * y-or-n-p; yes-or-no-p:: * make-synonym-stream:: * synonym-stream-symbol:: * broadcast-stream-streams:: * make-broadcast-stream:: * make-two-way-stream:: * two-way-stream-input-stream; two-way-stream-output-stream:: * echo-stream-input-stream; echo-stream-output-stream:: * make-echo-stream:: * concatenated-stream-streams:: * make-concatenated-stream:: * get-output-stream-string:: * make-string-input-stream:: * make-string-output-stream:: * with-input-from-string:: * with-output-to-string:: * *debug-io*; *error-output*; *query-io*; *standard-input*; *standard-output*; *trace-output*:: * *terminal-io*:: * stream-error:: * stream-error-stream:: * end-of-file:: Printer * The Lisp Printer:: * The Lisp Pretty Printer:: * Formatted Output:: * Printer Dictionary:: The Lisp Printer * Overview of The Lisp Printer:: * Printer Dispatching:: * Default Print-Object Methods:: * Examples of Printer Behavior:: Overview of The Lisp Printer * Multiple Possible Textual Representations:: * Printer Escaping:: Default Print-Object Methods * Printing Numbers:: * Printing Integers:: * Printing Ratios:: * Printing Floats:: * Printing Complexes:: * Note about Printing Numbers:: * Printing Characters:: * Printing Symbols:: * Package Prefixes for Symbols:: * Effect of Readtable Case on the Lisp Printer:: * Examples of Effect of Readtable Case on the Lisp Printer:: * Printing Strings:: * Printing Lists and Conses:: * Printing Bit Vectors:: * Printing Other Vectors:: * Printing Other Arrays:: * Examples of Printing Arrays:: * Printing Random States:: * Printing Pathnames:: * Printing Structures:: * Printing Other Objects:: The Lisp Pretty Printer * Pretty Printer Concepts:: * Examples of using the Pretty Printer:: * Notes about the Pretty Printer's Background:: Pretty Printer Concepts * Dynamic Control of the Arrangement of Output:: * Format Directive Interface:: * Compiling Format Strings:: * Pretty Print Dispatch Tables:: * Pretty Printer Margins:: Formatted Output * FORMAT Basic Output:: * FORMAT Radix Control:: * FORMAT Floating-Point Printers:: * FORMAT Printer Operations:: * FORMAT Pretty Printer Operations:: * FORMAT Layout Control:: * FORMAT Control-Flow Operations:: * FORMAT Miscellaneous Operations:: * FORMAT Miscellaneous Pseudo-Operations:: * Additional Information about FORMAT Operations:: * Examples of FORMAT:: * Notes about FORMAT:: FORMAT Basic Output * Tilde C: Character:: * Tilde Percent: Newline:: * Tilde Ampersand: Fresh-Line:: * Tilde Vertical-Bar: Page:: * Tilde Tilde: Tilde:: FORMAT Radix Control * Tilde R: Radix:: * Tilde D: Decimal:: * Tilde B: Binary:: * Tilde O: Octal:: * Tilde X: Hexadecimal:: FORMAT Floating-Point Printers * Tilde F: Fixed-Format Floating-Point:: * Tilde E: Exponential Floating-Point:: * Tilde G: General Floating-Point:: * Tilde Dollarsign: Monetary Floating-Point:: FORMAT Printer Operations * Tilde A: Aesthetic:: * Tilde S: Standard:: * Tilde W: Write:: FORMAT Pretty Printer Operations * Tilde Underscore: Conditional Newline:: * Tilde Less-Than-Sign: Logical Block:: * Tilde I: Indent:: * Tilde Slash: Call Function:: FORMAT Layout Control * Tilde T: Tabulate:: * Tilde Less-Than-Sign: Justification:: * Tilde Greater-Than-Sign: End of Justification:: FORMAT Control-Flow Operations * Tilde Asterisk: Go-To:: * Tilde Left-Bracket: Conditional Expression:: * Tilde Right-Bracket: End of Conditional Expression:: * Tilde Left-Brace: Iteration:: * Tilde Right-Brace: End of Iteration:: * Tilde Question-Mark: Recursive Processing:: FORMAT Miscellaneous Operations * Tilde Left-Paren: Case Conversion:: * Tilde Right-Paren: End of Case Conversion:: * Tilde P: Plural:: FORMAT Miscellaneous Pseudo-Operations * Tilde Semicolon: Clause Separator:: * Tilde Circumflex: Escape Upward:: * Tilde Newline: Ignored Newline:: Additional Information about FORMAT Operations * Nesting of FORMAT Operations:: * Missing and Additional FORMAT Arguments:: * Additional FORMAT Parameters:: * Undefined FORMAT Modifier Combinations:: Printer Dictionary * copy-pprint-dispatch:: * formatter:: * pprint-dispatch:: * pprint-exit-if-list-exhausted:: * pprint-fill; pprint-linear; pprint-tabular:: * pprint-indent:: * pprint-logical-block:: * pprint-newline:: * pprint-pop:: * pprint-tab:: * print-object:: * print-unreadable-object:: * set-pprint-dispatch:: * write; prin1; print; pprint; princ:: * write-to-string; prin1-to-string; princ-to-string:: * *print-array*:: * *print-base*; *print-radix*:: * *print-case*:: * *print-circle*:: * *print-escape*:: * *print-gensym*:: * *print-level*; *print-length*:: * *print-lines*:: * *print-miser-width*:: * *print-pprint-dispatch*:: * *print-pretty*:: * *print-readably*:: * *print-right-margin*:: * print-not-readable:: * print-not-readable-object:: * format:: Reader * Reader Concepts:: * Reader Dictionary:: Reader Concepts * Dynamic Control of the Lisp Reader:: * Effect of Readtable Case on the Lisp Reader:: * Argument Conventions of Some Reader Functions:: Effect of Readtable Case on the Lisp Reader * Examples of Effect of Readtable Case on the Lisp Reader:: Argument Conventions of Some Reader Functions * The EOF-ERROR-P argument:: * The RECURSIVE-P argument:: Reader Dictionary * readtable:: * copy-readtable:: * make-dispatch-macro-character:: * read; read-preserving-whitespace:: * read-delimited-list:: * read-from-string:: * readtable-case:: * readtablep:: * set-dispatch-macro-character; get-dispatch-macro-character:: * set-macro-character; get-macro-character:: * set-syntax-from-char:: * with-standard-io-syntax:: * *read-base*:: * *read-default-float-format*:: * *read-eval*:: * *read-suppress*:: * *readtable*:: * reader-error:: System Construction * System Construction Concepts:: * System Construction Dictionary:: System Construction Concepts * Loading:: * Features:: Features * Feature Expressions:: * Examples of Feature Expressions:: System Construction Dictionary * compile-file:: * compile-file-pathname:: * load:: * with-compilation-unit:: * *features*:: * *compile-file-pathname*; *compile-file-truename*:: * *load-pathname*; *load-truename*:: * *compile-print*; *compile-verbose*:: * *load-print*; *load-verbose*:: * *modules*:: * provide; require:: Environment * The External Environment:: * Environment Dictionary:: The External Environment * Top level loop:: * Debugging Utilities:: * Environment Inquiry:: * Time:: Time * Decoded Time:: * Universal Time:: * Internal Time:: * Seconds:: Environment Dictionary * decode-universal-time:: * encode-universal-time:: * get-universal-time; get-decoded-time:: * sleep:: * apropos; apropos-list:: * describe:: * describe-object:: * trace; untrace:: * step:: * time:: * internal-time-units-per-second:: * get-internal-real-time:: * get-internal-run-time:: * disassemble:: * documentation; (setf documentation):: * room:: * ed:: * inspect:: * dribble:: * -:: * +; ++; +++:: * *; **; ***:: * /; //; ///:: * lisp-implementation-type; lisp-implementation-version:: * short-site-name; long-site-name:: * machine-instance:: * machine-type:: * machine-version:: * software-type; software-version:: * user-homedir-pathname:: Glossary * Glossary:: Appendix * Removed Language Features:: Removed Language Features * Requirements for removed and deprecated features:: * Removed Types:: * Removed Operators:: * Removed Argument Conventions:: * Removed Variables:: * Removed Reader Syntax:: * Packages No Longer Required:: @end menu @c includes @c @include chap-1.texi @c @include chap-2.texi @c @include chap-3.texi @c @include chap-4.texi @c @include chap-5.texi @c @include chap-6.texi @c @include chap-7.texi @c @include chap-8.texi @c @include chap-9.texi @c @include chap-10.texi @c @include chap-11.texi @c @include chap-12.texi @c @include chap-13.texi @c @include chap-14.texi @c @include chap-15.texi @c @include chap-16.texi @c @include chap-17.texi @c @include chap-18.texi @c @include chap-19.texi @c @include chap-20.texi @c @include chap-21.texi @c @include chap-22.texi @c @include chap-23.texi @c @include chap-24.texi @c @include chap-25.texi @c @include chap-26.texi @c @include chap-a.texi @bye