@menu
* Overview:: Installation, usage, etc.
-* Program Structure:: Arglists, `eval-when', `defalias'
-* Predicates:: `typep' and `equalp'
-* Control Structure:: `setf', `do', `loop', etc.
-* Macros:: Destructuring, `define-compiler-macro'
-* Declarations:: `proclaim', `declare', etc.
-* Symbols:: Property lists, `gensym'
+* Program Structure:: Arglists, @code{eval-when}, @code{defalias}
+* Predicates:: @code{typep} and @code{equalp}
+* Control Structure:: @code{setf}, @code{do}, @code{loop}, etc.
+* Macros:: Destructuring, @code{define-compiler-macro}
+* Declarations:: @code{proclaim}, @code{declare}, etc.
+* Symbols:: Property lists, @code{gensym}
* Numbers:: Predicates, functions, random numbers
* Sequences:: Mapping, functions, searching, sorting
-* Lists:: `caddr', `sublis', `member*', `assoc*', etc.
-* Structures:: `defstruct'
-* Assertions:: `check-type', `assert', `ignore-errors'.
+* Lists:: @code{caddr}, @code{sublis}, @code{member*}, @code{assoc*}, etc.
+* Structures:: @code{defstruct}
+* Assertions:: @code{check-type}, @code{assert}, @code{ignore-errors}.
* Efficiency Concerns:: Hints and techniques
* Common Lisp Compatibility:: All known differences with Steele
and the @code{eval-when} construct.
@menu
-* Argument Lists:: `&key', `&aux', `defun*', `defmacro*'.
-* Time of Evaluation:: The `eval-when' construct.
+* Argument Lists:: @code{&key}, @code{&aux}, @code{defun*}, @code{defmacro*}.
+* Time of Evaluation:: The @code{eval-when} construct.
@end menu
@iftex
facts are true or false.
@menu
-* Type Predicates:: `typep', `deftype', and `coerce'
-* Equality Predicates:: `equalp'
+* Type Predicates:: @code{typep}, @code{deftype}, and @code{coerce}
+* Equality Predicates:: @code{equalp}
@end menu
@node Type Predicates, Equality Predicates, Predicates, Predicates
constructs.
@menu
-* Assignment:: The `psetq' form
-* Generalized Variables:: `setf', `incf', `push', etc.
-* Variable Bindings:: `progv', `lexical-let', `flet', `macrolet'
-* Conditionals:: `case', `typecase'
-* Blocks and Exits:: `block', `return', `return-from'
-* Iteration:: `do', `dotimes', `dolist', `do-symbols'
-* Loop Facility:: The Common Lisp `loop' macro
-* Multiple Values:: `values', `multiple-value-bind', etc.
+* Assignment:: The @code{psetq} form
+* Generalized Variables:: @code{setf}, @code{incf}, @code{push}, etc.
+* Variable Bindings:: @code{progv}, @code{lexical-let}, @code{flet}, @code{macrolet}
+* Conditionals:: @code{case}, @code{typecase}
+* Blocks and Exits:: @code{block}, @code{return}, @code{return-from}
+* Iteration:: @code{do}, @code{dotimes}, @code{dolist}, @code{do-symbols}
+* Loop Facility:: The Common Lisp @code{loop} macro
+* Multiple Values:: @code{values}, @code{multiple-value-bind}, etc.
@end menu
@node Assignment, Generalized Variables, Control Structure, Control Structure
is a set of forms that can be generalized variables in Lisp.
@menu
-* Basic Setf:: `setf' and place forms
-* Modify Macros:: `incf', `push', `rotatef', `letf', `callf', etc.
-* Customizing Setf:: `define-modify-macro', `defsetf', `define-setf-method'
+* Basic Setf:: @code{setf} and place forms
+* Modify Macros:: @code{incf}, @code{push}, @code{rotatef}, @code{letf}, @code{callf}, etc.
+* Customizing Setf:: @code{define-modify-macro}, @code{defsetf}, @code{define-setf-method}
@end menu
@node Basic Setf, Modify Macros, Generalized Variables, Generalized Variables
are also related to variable bindings.
@menu
-* Dynamic Bindings:: The `progv' form
-* Lexical Bindings:: `lexical-let' and lexical closures
-* Function Bindings:: `flet' and `labels'
-* Macro Bindings:: `macrolet' and `symbol-macrolet'
+* Dynamic Bindings:: The @code{progv} form
+* Lexical Bindings:: @code{lexical-let} and lexical closures
+* Function Bindings:: @code{flet} and @code{labels}
+* Macro Bindings:: @code{macrolet} and @code{symbol-macrolet}
@end menu
@node Dynamic Bindings, Lexical Bindings, Variable Bindings, Variable Bindings
with an easy-to-use but very powerful and expressive syntax.
@menu
-* Loop Basics:: `loop' macro, basic clause structure
-* Loop Examples:: Working examples of `loop' macro
-* For Clauses:: Clauses introduced by `for' or `as'
-* Iteration Clauses:: `repeat', `while', `thereis', etc.
-* Accumulation Clauses:: `collect', `sum', `maximize', etc.
-* Other Clauses:: `with', `if', `initially', `finally'
+* Loop Basics:: @code{loop} macro, basic clause structure
+* Loop Examples:: Working examples of @code{loop} macro
+* For Clauses:: Clauses introduced by @code{for} or @code{as}
+* Iteration Clauses:: @code{repeat}, @code{while}, @code{thereis}, etc.
+* Accumulation Clauses:: @code{collect}, @code{sum}, @code{maximize}, etc.
+* Other Clauses:: @code{with}, @code{if}, @code{initially}, @code{finally}
@end menu
@node Loop Basics, Loop Examples, Loop Facility, Loop Facility
missing from Emacs Lisp.
@menu
-* Property Lists:: `get*', `remprop', `getf', `remf'
-* Creating Symbols:: `gensym', `gentemp'
+* Property Lists:: @code{get*}, @code{remprop}, @code{getf}, @code{remf}
+* Creating Symbols:: @code{gensym}, @code{gentemp}
@end menu
@node Property Lists, Creating Symbols, Symbols, Symbols
which were left out of Emacs Lisp.
@menu
-* Predicates on Numbers:: `plusp', `oddp', `floatp-safe', etc.
-* Numerical Functions:: `abs', `floor*', etc.
-* Random Numbers:: `random*', `make-random-state'
-* Implementation Parameters:: `most-positive-float'
+* Predicates on Numbers:: @code{plusp}, @code{oddp}, @code{floatp-safe}, etc.
+* Numerical Functions:: @code{abs}, @code{floor*}, etc.
+* Random Numbers:: @code{random*}, @code{make-random-state}
+* Implementation Parameters:: @code{most-positive-float}
@end menu
@iftex
@menu
* Sequence Basics:: Arguments shared by all sequence functions
-* Mapping over Sequences:: `mapcar*', `mapcan', `map', `every', etc.
-* Sequence Functions:: `subseq', `remove*', `substitute', etc.
-* Searching Sequences:: `find', `position', `count', `search', etc.
-* Sorting Sequences:: `sort*', `stable-sort', `merge'
+* Mapping over Sequences:: @code{mapcar*}, @code{mapcan}, @code{map}, @code{every}, etc.
+* Sequence Functions:: @code{subseq}, @code{remove*}, @code{substitute}, etc.
+* Searching Sequences:: @code{find}, @code{position}, @code{count}, @code{search}, etc.
+* Sorting Sequences:: @code{sort*}, @code{stable-sort}, @code{merge}
@end menu
@node Sequence Basics, Mapping over Sequences, Sequences, Sequences
The functions described here operate on lists.
@menu
-* List Functions:: `caddr', `first', `list*', etc.
-* Substitution of Expressions:: `subst', `sublis', etc.
-* Lists as Sets:: `member*', `adjoin', `union', etc.
-* Association Lists:: `assoc*', `rassoc*', `acons', `pairlis'
+* List Functions:: @code{caddr}, @code{first}, @code{list*}, etc.
+* Substitution of Expressions:: @code{subst}, @code{sublis}, etc.
+* Lists as Sets:: @code{member*}, @code{adjoin}, @code{union}, etc.
+* Association Lists:: @code{assoc*}, @code{rassoc*}, @code{acons}, @code{pairlis}
@end menu
@node List Functions, Substitution of Expressions, Lists, Lists