+ @{ @<var> @! (@<var> @[@<value-form>@]) @}^*) \\ \ind
+ @<declaration>^* \\
+ @<form>^*
+ \-\nlret @<result-form>}
+ This is a helper to ensure that macro expansions evaluate their arguments
+ exactly once each, in the correct order.
+
+ Each @<var> is bound to an appropriate value (often a gensym) and then the
+ @<form>s are evaluated as an implicit @|progn| in the resulting environment
+ to produce an output form. This output form is then enclosed in one or
+ more binding forms to produce a @<result-form>. When the @<result-form> is
+ evaluated, the behaviour will be as if each @<value-form> is evaluated
+ exactly once each, in order, and each value is captured in the
+ corresponding @<var>.
+
+ A simple @|once-only| expansion might look something like
+ \begin{prog}
+ (let (\=(@<var>_1 (gensym)) \\
+ \>\qquad\vdots \\
+ \>(@<var>_n (gensym))) \\ \ind
+ `(let (\=(,@<var>_1 ,@<value-form>_1) \\
+ \>\qquad\vdots \\
+ \>(,@<var>_n ,@<value-form>_n)) \\ \ind
+ @<declaration>_1 \dots\ @<declaration>_m \\
+ @<form>_1 \dots\ @<form>_\ell))
+ \end{prog}
+ However, if @|once-only| can determine that some @<value-form> is a
+ constant (e.g., it is @|quote|d, self-evaluating, or reported as
+ @|constantp| in the given environment @<env>), then it need not allocate a
+ gensym: it can instead bind the @<var> directly to the constant value.
+
+ If a @<value-form> is omitted, then the value of the corresponding @<var>
+ is used. It is conventional usage for a macro to wrap @|once-only| around
+ its body so as to convert the arguments which it should evaluate into safe
+ gensyms capturing their runtime values. (Not that the simple expansion
+ given above can't do this correctly.) A bare symbol may be written in
+ place of a singleton list.
+\end{describe}
+
+\begin{describe}{fun}
+ {parse-body @<body> \&key :docp :declp
+ @> @<doc-string> @<declarations> @<body-forms>}
+ Parse the @<body> into a @<doc-string>, some @<declaration>s, and a list of
+ @<body-forms>.
+
+ The @<body> is assumed to have the general syntax
+ \begin{prog}
+ @[[ @<doc-string> @! @<declaration>^* @]] \\
+ @<form>^*
+ \end{prog}
+ A @<doc-string> is permitted if and only if @<docp> is non-nil, and
+ declarations are permitted if and only if @<declp> is non-nil; both are
+ true by default.
+
+ Each return value is a list, which is empty if the corresponding part of
+ the input @<body> is missing. Specifically:
+ \begin{itemize}
+ \item @<doc-string> is either nil, or a singleton list containing a string;
+ \item @<declarations> is either nil, or a singleton list containing a
+ @|(declare \dots)| form gathering up all of the individual
+ @<declaration>s within the @<body>; and
+ \item @<body-forms> is a list of the remaining forms in the @<body>.
+ \end{itemize}
+ Thus, the parsed body-parts can conveniently be spliced into a macro
+ expansion using @|,@@|.
+\end{describe}
+
+\begin{describe}{fun}{symbolicate \&rest @<symbols> @> @<symbol>}
+ Return the symbol, interned in the current @|*package*|, whose name is the
+ concatenation of the names of the given @<symbols>.
+\end{describe}
+
+
+\subsection{Locatives}
+
+A \emph{locative} is a value which remembers where another value is stored,
+-- whether it's in a variable, an array element, a structure slot, a hash
+table, etc.\ -- and can modify and retrieve it.
+
+Some Lisp systems have highly efficient locatives which actually keep track
+of the machine addresses of the places to which they refer. Common Lisp does
+not implement true locatives of this kind, but something sufficiently useful
+can be synthesized.
+
+These locatives can't usefully be compared. It should be possible to compare
+true locatives, such that two locatives compare equal if and only if they
+refer to the same place; but that doesn't work for these locatives.
+
+\begin{describe}{cls}{locative}
+ The type of locative objects.
+\end{describe}
+
+\begin{describe}{fun}{locativep @<object> @> @<generalized-boolean>}
+ Return non-nil if and only if @<object> is a locative.