% -*- Mode: TeX -*-

% !!! Moon wonders if "denote" is the right verb for talking about what "designators"
%     refer to.
%
% !!! Moon thinks the bottom header gets too close to the running text in this chapter.
%     It even overstrikes on a few pages (e.g., p26-28 of draft 10.156)
%
% Barmar thinks we should define reference terms for expressions like "left & right".
%
% Moon sez: Most occurrences of "which" in the glossary should be "that" in correct English.
% I should review this later. -kmp
%
% Think about unifying terms: "type lattice", "type hierarchy", "type hierarchy lattice",
% "directed acyclic graph".
% RPG says "hierarchy" or "dag" are ok, but not "lattice".
% Allan Wechsler (ACW@Symbolics.COM) says: 
%  Regarding DAGs vs. lattices: I don't know the basis of Dick Gabriel's
%  objection to the latter term.  I think that it's quite clear
%  mathematically that "lattice" is correct and "directed acyclic graph" is
%  incorrect, but Gabriel's objection may not be mathematical.  Details on
%  request.  I'm using the definitions from the ``Encyclopedic Dictionary of
%  Mathematics.''
%
% Think about these terms, which are commonly used without definition:
%   "qualifier pattern" - something that gets matched against in method comb.
%   "type specifier list" - the list form of a type specifier
%   "default value"
%   "optional parameter", ...
%
% Think about these terms, which are common concepts in search of a name, to cut
% down on wasted verbiage at multiple places in the text.
%   "stringname" - a string or a symbol, which is taken the name of a string.
%                  if a symbol, then then it is treated as if its name had been supplied.
%
% Sometime search for braces immediately followed by an alpha char 
% ("{...}s", "{...}es", "{...}ing", "{...}ed", etc.) because these are often
% clues to needed glossary words.
%
% KMP: Maybe a term "user symbol" being defined as 
%      "a symbol that is not accessible in the common-lisp package".
%    (I find it cumbersome to write a param description that says
%     a symbol that is not in the common-lisp package.
%    This comes up in a number of places.)
% Barmar: That sounds like a reasonable term and definition.
% KMP: Issue--some places might need a restriction on keywords, too, but that should
%    probably not be piggy-backed on the "user symbol" term.

\def\gentry#1{\itemitem{}\b{#1}\idxterm{#1}}
\def\gexample#1{{``#1''}}
\def\indextab#1{\endlist\indextabnote{#1}\beginlist}
\def\firstindextab#1{\indextabnote{#1}\beginlist}
\def\indextabnote#1{\goodbreak\item{\b{#1}}\penalty20000}
 
\def\Noun{\i{n.}}
\def\Verb{\i{v.}}
\def\TransitiveVerb{\i{v.t.}}
\def\Adjective{\i{adj.}}
\def\Adverb{\i{adv.}}

\def\ANSI{\i{ANSI}}
\def\IEEE{\i{IEEE}}
\def\ISO{\i{ISO}}
\def\Traditional{\i{Trad.}}
\def\Mathematics{\i{Math.}}
\def\Idiomatic{\i{Idiom.}}
\def\Computers{\i{Comp.}}

%% Glossary
 
Each entry in this glossary has the following parts:
 
\beginlist
 
\item{\bull} the term being defined, set in boldface.
 
 \item{\bull} optional pronunciation, enclosed in square brackets and
set in boldface, as in the following example:
\pronounced{\Stress{a}\stress{list}}.  The pronunciation key follows
\WebstersDictionary\TypographyCaveats.
 
 \item{\bull} the part or parts of speech, set in italics.  If a term
can be used as several parts of speech, there is a separate definition
for each part of speech.
 
 \item{\bull} one or more definitions, organized as follows:
 
\beginlist
 
 \item{--} an optional number, present if there are several
definitions. Lowercase letters might also be used in cases where subdefinitions of
a numbered definition are necessary.
 
 \item{--} an optional part of speech, set in italics, present if the
term is one of several parts of speech.
 
 \item{--} an optional discipline, set in italics, present if the term
has a standard definition being repeated. For example, ``{\Mathematics}''
 
 \item{--} an optional context, present if this definition is
meaningful only in that context. For example, ``(of a \term{symbol})''.
 
 \item{--} the definition.
 
 \item{--} an optional example sentence. For example,
           \gexample{This is an example of an example.}
 
 \item{--} optional cross references.
%%There are a lot of options, and they are all pretty self-explanatory. -kmp 11-Sep-91
%A cross reference to another word uses the following form: \Seeterm{word}.
%A cross reference to a section uses the following form: \Seesection\Sample.
 
\endlist
\endlist
 
In addition, some terms have idiomatic usage in the Common Lisp
community which is not shared by other communities, or which is not
technically correct.  Definitions labeled ``{\Idiomatic}'' represent
such idiomatic usage; these definitions are sometimes followed by an
explanatory note.
 
Words in \term{this font} are words with entries in the glossary.
%Word in \typeref{this font} are names of data types.
Words in example sentences do not follow this convention.
 
When an ambiguity arises, the longest matching substring has precedence.
For example, ``\term{complex float}'' refers to a single glossary entry 
for ``\term{complex float}'' rather than the combined meaning of the 
glossary terms ``\term{complex}'' and ``\term{float}.''

Subscript notation, as in ``\term{something}\meaning{n}'' means that
the \i{n}th definition of ``\term{something}'' is intended.  This
notation is used only in situations where the context might be insufficient
to disambiguate.

The following are abbreviations used in the glossary:
 
\tabletwo{Abbreviation}{Meaning}{
\entry{\Adjective}{adjective}
\entry{\Adverb}{adverb}
\entry{\ANSI}{compatible with one or more ANSI standards}
\entry{\Computers}{computers}
\entry{\Idiomatic}{idiomatic}
\entry{\IEEE}{compatible with one or more IEEE standards}
\entry{\ISO}{compatible with one or more ISO standards}
\entry{\Mathematics}{mathematics}
\entry{\Traditional}{traditional}
\entry{\Noun}{noun}
\entry{\Verb}{verb}
\entry{\TransitiveVerb}{transitive verb}
}
 
\beginlist

\firstindextab{Non-alphabetic}

\gentry{()} \pronounced{\Stress{nil}}, \Noun\
  an alternative notation for writing the symbol~\nil, used to emphasize
  the use of \term{nil} as an \term{empty list}.

\indextab{A}

\gentry{absolute} \Adjective\
  1. (of a \term{time})
     representing a specific point in time.
  2. (of a \term{pathname})
     representing a specific position in a directory hierarchy.
  \Seeterm{relative}.

\gentry{access} \Noun, \TransitiveVerb\
%\term{variable} removed since generalized reference implies it.
  1. \TransitiveVerb\ (a \term{place}, or \term{array})
     to \term{read}\meaning{1} or \term{write}\meaning{1} the \term{value} of
         the \term{place}
      or an \term{element} of the \term{array}.
  2. \Noun\ (of a \term{place})
     an attempt to \term{access}\meaning{1} the \term{value} of the \term{place}.

% Moon: Useless entry. Adds nothing to normal English usage.
% KMP: Allows usage to be italicized; also, courtesy to non-native 
%      English speakers, who may not be as familiar with all our word forms.
\gentry{accessibility} \Noun\
  the state of being \term{accessible}.

%!!! Moon: accessible[1] and reference[2] don't seem to match up.
\gentry{accessible} \Adjective\ 
  1. (of an \term{object}) capable of being \term{referenced}.
  2. (of \term{shared slots} or \term{local slots} in an \term{instance} of 
     a \term{class}) having been defined by the \term{class} 
     of the \term{instance} or \term{inherited} from a
     \term{superclass} of that \term{class}.
%!!! JonL: this reader thing should be an effect, not the definition.
%          use "present" and "inherited".
  3. (of a \term{symbol} in a \term{package})
     capable of being \term{referenced} without a \term{package prefix} 
     when that \term{package} is current, regardless of whether the
     \term{symbol} is \term{present} in that \term{package} or is \term{inherited}.

\gentry{accessor} \Noun\
  an \term{operator} that performs an \term{access}.
  \Seeterm{reader} and \term{writer}.

\gentry{active} \Adjective\ 
  1. (of a \term{handler}, a \term{restart}, or a \term{catch tag})
     having been \term{established} but not yet \term{disestablished}.
  2. (of an \term{element} of an \term{array})
     having an index that is greater than or equal to zero,
     but less than the \term{fill pointer} (if any).
     For an \term{array} that has no \term{fill pointer},
     all \term{elements} are considered \term{active}.

\gentry{actual adjustability} \Noun\ (of an \term{array})
  a \term{generalized boolean} that is associated with the \term{array}, 
  representing whether the \term{array} is \term{actually adjustable}.
  \SeetermAlso{expressed adjustability} and \funref{adjustable-array-p}.

\gentry{actual argument} \Noun\ \Traditional\ 
  an \term{argument}.

\gentry{actual array element type} \Noun\ (of an \term{array})
  the \term{type} for which the \term{array} is actually specialized,
  which is the \term{upgraded array element type} of 
  the \term{expressed array element type} of the \term{array}.
  \Seefun{array-element-type}.

\gentry{actual complex part type} \Noun\ (of a \term{complex})
  the \term{type} in which the real and imaginary parts of the \term{complex}
  are actually represented, which is the \term{upgraded complex part type} of the
  \term{expressed complex part type} of the \term{complex}.

\gentry{actual parameter} \Noun\ \Traditional\ 
  an \term{argument}.

\gentry{actually adjustable} \Adjective\ (of an \term{array})
  such that \funref{adjust-array} can adjust its characteristics
  by direct modification.
  A \term{conforming program} may depend on
  an \term{array} being \term{actually adjustable}
  only if either that \term{array} is known to have been \term{expressly adjustable}
  or if that \term{array} has been explicitly tested by \funref{adjustable-array-p}.

\gentry{adjustability} \Noun\ (of an \term{array})
  1. \term{expressed adjustability}.
  2. \term{actual adjustability}.

\gentry{adjustable} \Adjective\ (of an \term{array})
  1. \term{expressly adjustable}.
  2. \term{actually adjustable}.

\gentry{after method} \Noun\
  a \term{method} having the \term{qualifier} \kwd{after}.

\gentry{alist} \pronounced{\Stress{\harda}\stress{list}}, \Noun\ 
  an \term{association list}.
 
\gentry{alphabetic} \Noun, \Adjective\
%% 13.2.0 12
  1. \Adjective\ (of a \term{character})
     being one of the \term{standard characters} \f{A} through \f{Z} 
         or \f{a} through \f{z},
      or being any \term{implementation-defined} character that has \term{case},
      or being some other \term{graphic} \term{character}
         defined by the \term{implementation} to be \term{alphabetic}\meaning{1}.
  2. a. \Noun\
        one of several possible \term{constituent traits} of a \term{character}.
        For details, \seesection\ConstituentChars\ and \secref\ReaderAlgorithm.
     b. \Adjective\ (of a \term{character})
        being a \term{character} 
              that has \term{syntax type} \term{constituent} in the \term{current readtable} 
	  and that has the \term{constituent trait} \term{alphabetic}\meaning{2a}.
	\Seefigure\ConstituentTraitsOfStdChars.

\gentry{alphanumeric} \Adjective\ (of a \term{character})
%% 13.2.0 12
  being either an \term{alphabetic}\meaning{1} \term{character}
            or a \term{numeric} {character}.

\gentry{ampersand} \Noun\
  the \term{standard character} that is called ``ampersand'' (\f{\&}).
  \Seefigure\StdCharsThree.

\gentry{anonymous} \Adjective\ 
  1. (of a \term{class} or \term{function}) having no \term{name}
  2. (of a \term{restart}) having a \term{name} of \nil.

\gentry{apparently uninterned} \Adjective\ 
  having a \term{home package} of \nil.  (An \term{apparently uninterned} \term{symbol} 
  might or might not be an \term{uninterned} \term{symbol}.  \term{Uninterned symbols}
  have a \term{home package} of \nil, but \term{symbols} which have been \term{uninterned}
  from their \term{home package} also have a \term{home package} of \nil,
  even though they might still be \term{interned} in some other \term{package}.)

%!!! Moon: Need to reconcile this entry with the following three.
\gentry{applicable} \Adjective\
  1. (of a \term{handler}) being an \term{applicable handler}.
  2. (of a \term{method}) being an \term{applicable method}.
  3. (of a \term{restart}) being an \term{applicable restart}.

\gentry{applicable handler} \Noun\ (for a \term{condition} being \term{signaled})
  an \term{active} \term{handler} for which the associated type contains the
  \term{condition}.

\gentry{applicable method} \Noun\ (of a \term{generic function}
				     called with \term{arguments})
  a \term{method} of the \term{generic function} for which the
  \term{arguments} satisfy the \term{parameter specializers} 
  of that \term{method}.
% and which has not been \term{shadowed}\meaning{2}.
%Moon says: ``applicableness does not take method combination into account
%             and shadowing is a property of method combination.''
  \Seesection\SelApplMeth.

\issue{CONDITION-RESTARTS:PERMIT-ASSOCIATION}
\gentry{applicable restart} \Noun\
  1. (for a \term{condition})
     an \term{active} \term{handler} for which the associated test returns 
     \term{true} when given the \term{condition} as an argument.
  2. (for no particular \term{condition})
     an \term{active} \term{handler} for which the associated test returns 
     \term{true} when given \nil\ as an argument.
\endissue{CONDITION-RESTARTS:PERMIT-ASSOCIATION}

\gentry{apply} \TransitiveVerb\ (a \term{function} to a \term{list})
  to \term{call} the \term{function} with arguments that are the \term{elements}
  of the \term{list}.
  \gexample{Applying the function \funref{+} to a list of integers returns
	    the sum of the elements of that list.} 

\gentry{argument} \Noun\
  1. (of a \term{function}) an \term{object} which is offered as data
     to the \term{function} when it is \term{called}.
%% I wonder if we should say this. -kmp
%    In other literature, but not here, this is sometimes called an ``actual argument.''
%
% 1. (of a \term{function}) an \term{object} which is paired 
%    with a corresponding \term{parameter} in order to provide data
%    flow into the function at the time it is called.
% Moon says:
%   ``Not all arguments have corresponding parameters, when the function accepts
%     keyword or rest arguments.  Consider \kwd{allow-other-keys}.  Thus this definition
%     cannot be exactly correct.  I don't think the definition of arguments should
%     have anything to do with what the function does internally to receive the
%     arguments.''
\issue{FORMAT-STRING-ARGUMENTS:SPECIFY}
  2. (of a \term{format control}) a \term{format argument}.
\endissue{FORMAT-STRING-ARGUMENTS:SPECIFY}

\gentry{argument evaluation order} \Noun\ 
  the order in which \term{arguments} are evaluated in a function call.
  \gexample{The argument evaluation order for Common Lisp is left to right.}
  \Seesection\Evaluation.

\gentry{argument precedence order} \Noun\
  the order in which the \term{arguments} to a \term{generic function} are
  considered when sorting the \term{applicable methods} into precedence order.

\gentry{around method} \Noun\
  a \term{method} having the \term{qualifier} \kwd{around}.

\gentry{array} \Noun\
  an \term{object} \oftype{array}, which serves as a container for other
  \term{objects} arranged in a Cartesian coordinate system.

\gentry{array element type} \Noun\ (of an \term{array})
  1. a \term{type} associated with the \term{array}, 
     and of which all \term{elements} of the \term{array} are 
     constrained to be members.
  2. the \term{actual array element type} of the \term{array}.
  3. the \term{expressed array element type} of the \term{array}.

\gentry{array total size} \Noun\ 
  the total number of \term{elements} in an \term{array}, computed by taking 
  the product of the \term{dimensions} of the \term{array}.
  (The size of a zero-dimensional \term{array} is therefore one.)

\gentry{assign} \TransitiveVerb\ (a \term{variable})
  to change the \term{value} of the \term{variable} in a \term{binding}
  that has already been \term{established}.
  \Seespec{setq}.

\gentry{association list} \Noun\ 
  a \term{list} of \term{conses} representing an association 
  of \term{keys} with \term{values}, where the \term{car} of each
  \term{cons} is the \term{key} and the \term{cdr} is the
  \term{value} associated with that \term{key}.
 
\gentry{asterisk} \Noun\
  the \term{standard character} that is variously called
      ``asterisk''
   or ``star'' (\f{*}).
  \Seefigure\StdCharsThree.

\gentry{at-sign} \Noun\
  the \term{standard character} that is variously called
     ``commercial at''
  or ``at sign'' (\f{@}).
  \Seefigure\StdCharsThree.

\gentry{atom} \Noun\
  any \term{object} that is not a \term{cons}.
  \gexample{A vector is an atom.}

\gentry{atomic} \Adjective\ 
  being an \term{atom}.
  \gexample{The number 3, the symbol \f{foo}, and \nil\ are atomic.}

\gentry{atomic type specifier} \Noun\
  a \term{type specifier} that is \term{atomic}.
  For every \term{atomic type specifier}, \i{x}, there is an equivalent
  \term{compound type specifier} with no arguments supplied, \f{(\i{x})}.

\gentry{attribute} \Noun\ (of a \term{character})
  a program-visible aspect of the \term{character}.
  The only \term{standardized} \term{attribute} of a \term{character}
  is its \term{code}\meaning{2}, but \term{implementations} are permitted to have
  additional \term{implementation-defined} \term{attributes}.
  \Seesection\CharacterAttributes.
  \gexample{An implementation that support fonts
            might make font information an attribute of a character,
            while others might represent font information separately from characters.}

\gentry{aux variable} \Noun\
  a \term{variable} that occurs in the part of a \term{lambda list}
  that was introduced by \keyref{aux}.  Unlike all other \term{variables}
  introduced by a \term{lambda-list}, \term{aux variables} are not 
  \term{parameters}.

\gentry{auxiliary method} \Noun\
  a member of one of two sets of \term{methods} 
  (the set of \term{primary methods} is the other)
  that form an exhaustive partition of the set of \term{methods}
  on the \term{method}'s \term{generic function}.
  How these sets are determined is dependent on the \term{method combination} type;
  \seesection\IntroToMethods.

\indextab{B}
 
\gentry{backquote} \Noun\
  the \term{standard character} that is variously called
       ``grave accent'' 
    or ``backquote'' (\f{`}).
  \Seefigure\StdCharsThree.

\gentry{backslash} \Noun\
  the \term{standard character} that is variously called
       ``reverse solidus'' 
    or ``backslash'' (\f{\\}).
  \Seefigure\StdCharsThree.

\gentry{base character} \Noun\
  a \term{character}
\issue{CHARACTER-VS-CHAR:LESS-INCONSISTENT-SHORT}
  \oftype{base-char}.
\endissue{CHARACTER-VS-CHAR:LESS-INCONSISTENT-SHORT}

\gentry{base string} \Noun\
  a \term{string} \oftype{base-string}.

\gentry{before method} \Noun\
  a \term{method} having the \term{qualifier} \kwd{before}.

\gentry{bidirectional} \Adjective\ (of a \term{stream})
  being both an \term{input} \term{stream} and an \term{output} \term{stream}.

\gentry{binary} \Adjective\ 
  1. (of a \term{stream})
     being a \term{stream} that has an \term{element type} that is a \subtypeof{integer}.
     The most fundamental operation on a \term{binary} \term{input} \term{stream} 
     is \funref{read-byte} and on a \term{binary} \term{output} \term{stream} 
     is \funref{write-byte}.
     \Seeterm{character}.
  2. (of a \term{file})
     having been created by opening a \term{binary} \term{stream}.
     (It is \term{implementation-dependent} whether this is an detectable aspect 
      of the \term{file}, or whether any given \term{character} \term{file} can be
      treated as a \term{binary} \term{file}.)

%!!! JonL: In the iteration chapter, you also use this to mean to 
%          reset the value of a variable.
% KMP: Those references need to be fixed.
\gentry{bind} \TransitiveVerb\ (a \term{variable})
  to establish a \term{binding} for the \term{variable}.

\gentry{binding} \Noun\ 
  an association between a \term{name} and that which the \term{name} 
  denotes.  
  \gexample{A lexical binding is a lexical association between a 
            name and its value.}
 
\gentry{bit} \Noun\ 
  an \term{object} \oftype{bit}; 
  that is, the \term{integer} \f{0} or the \term{integer} \f{1}.

\gentry{bit array} \Noun\
  a specialized \term{array} that is of \term{type} \f{(array bit)},
  and whose elements are \oftype{bit}.

\gentry{bit vector} \Noun\ 
  a specialized \term{vector} that is \oftype{bit-vector},
  and whose elements are \oftype{bit}.

\gentry{bit-wise logical operation specifier} \Noun\ 
  an \term{object} which names one of the sixteen possible bit-wise logical
  operations that can be performed by the \funref{boole} function,
  and which is the \term{value} of exactly one of the
  \term{constant variables} 
  \conref{boole-clr},     \conref{boole-set},
  \conref{boole-1},       \conref{boole-2},
  \conref{boole-c1},      \conref{boole-c2},
  \conref{boole-and},     \conref{boole-ior},
  \conref{boole-xor},     \conref{boole-eqv},
  \conref{boole-nand},    \conref{boole-nor},
  \conref{boole-andc1},   \conref{boole-andc2},
  \conref{boole-orc1}, or \conref{boole-orc2}.

\gentry{block} \Noun\
  a named lexical \term{exit point}, 
  \term{established} explicitly by \specref{block}
  		  or implicitly by \term{operators} 
		       such as \macref{loop}, \macref{do} and \macref{prog},
  to which control and values may be transfered by 
  using a \specref{return-from} \term{form} with the name of the \term{block}.

\gentry{block tag} \Noun\ 
  the \term{symbol} that, within the \term{lexical scope} 
  of a \specref{block} \term{form}, names the \term{block}
  \term{established} by that \specref{block} \term{form}.
  See \macref{return} or \specref{return-from}.

\gentry{boa lambda list} \Noun\
  a \term{lambda list} that is syntactically like an \term{ordinary lambda list},
  but that is processed in ``\b{b}y \b{o}rder of \b{a}rgument'' style.
  \Seesection\BoaLambdaLists.

\gentry{body parameter} \Noun\
  a \term{parameter} available in certain \term{lambda lists}
  which from the point of view of \term{conforming programs}
  is like a \term{rest parameter} in every way except that it is introduced
  by \keyref{body} instead of \keyref{rest}.  (\term{Implementations} are 
  permitted to provide extensions which distinguish \term{body parameters}
  and \term{rest parameters}---\eg the \term{forms} for \term{operators}
  which were defined using a \term{body parameter} might be pretty printed
  slightly differently than \term{forms} for \term{operators} which were 
  defined using \term{rest parameters}.)

\gentry{boolean} \Noun\ 
  an \term{object} \oftype{boolean};
  that is, one of the following \term{objects}: 
       the symbol~\t\   (representing \term{true}),
    or the symbol~\nil\ (representing \term{false}).
  \Seeterm{generalized boolean}.

\gentry{boolean equivalent} \Noun\ (of an \term{object} $O\sub 1$)
  any \term{object} $O\sub 2$ that has the same truth value as $O\sub 1$
  when both $O\sub 1$ and $O\sub 2$ are viewed as \term{generalized booleans}.
 
\gentry{bound} \Adjective, \TransitiveVerb\ 
  1. \Adjective\ having an associated denotation in a \term{binding}.
     \gexample{The variables named by a \specref{let} are bound within
               its body.}
     \Seeterm{unbound}.
  2. \Adjective\ having a local \term{binding} which 
     \term{shadows}\meaning{2} another. 
     \gexample{The variable \varref{*print-escape*} is bound while in
               the \funref{princ} function.}
  3. \TransitiveVerb\ the past tense of \term{bind}.

\gentry{bound declaration} \Noun\ 
  a \term{declaration} that refers to or is associated with a \term{variable}
  or \term{function} and that appears within the \term{special form} 
  that \term{establishes} the \term{variable} or \term{function},
  but before the body of that \term{special form}
% This next parenthetical remark was added because Moon thinks (and I agree)
% that rather than just "within" we need to say "at the head of the body" 
% in order to make it clear that 
%    (let ((a (let ((b 1))
%               (declare (fixnum a))
%               (expt b 100))))
%      (print a))
%    is not accidentally covered.
  (specifically, at the head of that \term{form}'s body).
%!!! Barmar: The following should be replaced by a cross-reference to a
%   	     concept section.
  (If a \term{bound declaration} refers to a \term{function} \term{binding} or
   a \term{lexical variable} \term{binding}, the \term{scope} of
   the \term{declaration} is exactly the \term{scope} of that
   \term{binding}.  If the \term{declaration} refers to a
   \term{dynamic variable} \term{binding}, the \term{scope} of
   the \term{declaration} is what the \term{scope} of the 
   \term{binding} would have been if it were lexical rather than dynamic.)
 
\gentry{bounded} \Adjective\ (of a \term{sequence} $S$,
			      by an ordered pair
			          of \term{bounding indices} $i\sub{start}$ and $i\sub{end}$)
  restricted to a subrange of the \term{elements} of $S$ that includes each \term{element}
  beginning with (and including) the one indexed by $i\sub{start}$ and
  continuing up to (but not including) the one indexed by $i\sub{end}$.

\gentry{bounding index} \Noun\ (of a \term{sequence} with \term{length} $n$)
  either of a conceptual pair of \term{integers}, $i\sub{start}$ and $i\sub{end}$,
  respectively called the ``lower bounding index'' and ``upper bounding index'',
  such that $0 \leq i\sub{start} \leq i\sub{end} \leq n$, and which therefore delimit
  a subrange of the \term{sequence} \term{bounded} by $i\sub{start}$ and $i\sub{end}$.

\gentry{bounding index designator} (for a \term{sequence})
  one of two \term{objects} that, taken together as an ordered pair, 
  behave as a \term{designator} for \term{bounding indices} of the \term{sequence}; 
  that is, they denote \term{bounding indices} of the \term{sequence},
  and are either:
      an \term{integer} (denoting itself) and \nil\ 
       (denoting the \term{length} of the \term{sequence}),
   or two \term{integers} (each denoting themselves).

\gentry{break loop} \Noun\
  A variant of the normal \term{Lisp read-eval-print loop} that is recursively
  entered, usually because the ongoing \term{evaluation} of some other \term{form}
  has been suspended for the purpose of debugging.  Often, a \term{break loop}
  provides the ability to exit in such a way as to continue the suspended computation.
  \Seefun{break}.

\gentry{broadcast stream} \Noun\
  an \term{output} \term{stream} \oftype{broadcast-stream}.

\gentry{built-in class} \Noun\
%"instance" => "generalized instance" per Quinquevirate. -kmp 14-Feb-92
  a \term{class} that is a \term{generalized instance} \ofclass{built-in-class}.

%!!! KMP: This term is confusing and should probably be called something else.
\gentry{built-in type} \Noun\
   one of the \term{types} in \figref\StandardizedAtomicTypeSpecs.

% \gentry{built-in type} \Noun\
%   one of the \term{types} in \thenextfigure.
% 
% Moon: Aren't there a bunch missing, like base-char and simple-vector.
% \displaythree{Built-in types}{
% array&integer&restart\cr
% bit-vector&long-float&sequence\cr
% character&null&short-float\cr
% complex&number&single-float\cr
% condition&package&stream\cr
% cons&pathname&string\cr
% double-float&random-state&symbol\cr
% float&ratio&vector\cr
% function&rational&\cr
% hash-table&readtable&\cr
% }

\gentry{byte} \Noun\
  1. adjacent bits within an \term{integer}.
     (The specific number of bits can vary from point to point in the program;
      \seefun{byte}.)
  2. an integer in a specified range.
% Moon: Below 0 and a power of 2?
% KMP: I'm not so sure.  In the context of OPEN, it seems to mean any integer.
     (The specific range can vary from point to point in the program;
      \seefuns{open} and \funref{write-byte}.)

\gentry{byte specifier} \Noun\
  An \term{object} of \term{implementation-dependent} nature 
  that is returned by \thefunction{byte} and
  that specifies the range of bits in an \term{integer} to be used
  as a \term{byte} by \term{functions} such as \funref{ldb}.

\indextab{C}

\gentry{cadr} \pronounced{\Stress{ka}\stress{d\schwa r}}, \Noun\ (of an \term{object})
  the \term{car} of the \term{cdr} of that \term{object}.

\gentry{call} \TransitiveVerb, \Noun\ 
  1. \TransitiveVerb\ (a \term{function} with \term{arguments})
     to cause the \term{code} represented by that \term{function} to be 
     \term{executed} in an \term{environment} where \term{bindings} for
     the \term{values} of its \term{parameters} have been \term{established}
     based on the \term{arguments}.
     \gexample{Calling the function \funref{+} with the arguments 
               \f{5} and \f{1} yields a value of \f{6}.}
  2. \Noun\ a \term{situation} in which a \term{function} is called.

\gentry{captured initialization form} \Noun\
  an \term{initialization form} along with the \term{lexical environment}
  in which the \term{form} that defined the \term{initialization form}
  was \term{evaluated}.
  \gexample{Each newly added shared slot is set to the result of evaluating
            the captured initialization form for the slot that was specified
            in the \macref{defclass} form for the new class.}

\gentry{car} \Noun\
  1. a. (of a \term{cons}) 
        the component of a \term{cons} corresponding to the first
        \term{argument} to \funref{cons}; the other component is the
        \term{cdr}.
	\gexample{The function \funref{rplaca} modifies the car of a cons.}
     b. (of a \term{list})
        the first \term{element} of the \term{list}, or \nil\ if the
        \term{list} is the \term{empty list}.
  2. the \term{object} that is held in the \term{car}\meaning{1}.
     \gexample{The function \funref{car} returns the car of a cons.}
 
\gentry{case} \Noun\ (of a \term{character})
  the property of being either \term{uppercase} or \term{lowercase}.
  Not all \term{characters} have \term{case}.
  \gexample{The characters \f{\#\\A} and \f{\#\\a} have case,
	    but the character \f{\#\\\$} has no case.}
  \Seesection\CharactersWithCase\ and \thefunction{both-case-p}.

\gentry{case sensitivity mode} \Noun\
  one of the \term{symbols}
  \kwd{upcase}, \kwd{downcase}, \kwd{preserve}, or \kwd{invert}.

\gentry{catch} \Noun\
  an \term{exit point} which is \term{established} by a \specref{catch}
  \term{form} within the \term{dynamic scope} of its body,
  which is named by a \term{catch tag},
  and to which control and \term{values} may be \term{thrown}.

\gentry{catch tag} \Noun\
  an \term{object} which names an \term{active} \term{catch}.
  (If more than one \term{catch} is active with the same \term{catch tag},
   it is only possible to \term{throw} to the innermost such \term{catch}
   because the outer one is \term{shadowed}\meaning{2}.)

\gentry{cddr} \pronounced{\Stress{k\.ud}\schwa \stress{d\schwa r}} or
	      \pronounced{\Stress{k\schwa}\stress{d\.ud\schwa r}}, \Noun\ 
	      (of an \term{object})
  the \term{cdr} of the \term{cdr} of that \term{object}.

\gentry{cdr} \pronounced{\Stress{k\.u}\stress{d\schwa r}}, \Noun\ 
  1. a. (of a \term{cons}) 
        the component of a \term{cons} corresponding to the second \term{argument}
        to \funref{cons}; the other component is the \term{car}.
	\gexample{The function \funref{rplacd} modifies the cdr of a cons.}
     b. (of a \term{list} $L\sub 1$)
        either the \term{list} $L\sub 2$ that contains 
	       the \term{elements} of $L\sub 1$ that follow after the first, 
	or else \nil\ if $L\sub 1$ is the \term{empty list}.
  2. the \term{object} that is held in the \term{cdr}\meaning{1}.
     \gexample{The function \funref{cdr} returns the cdr of a cons.}

\gentry{cell} \Noun\ \Traditional\ (of an \term{object})
  a conceptual \term{slot} of that \term{object}.
  The \term{dynamic variable} and global \term{function} \term{bindings}
  of a \term{symbol} are sometimes referred to as its \term{value cell}
  and \term{function cell}, respectively.

\gentry{character} \Noun, \Adjective\
  1. \Noun\ an \term{object} \oftype{character}; that is,
     an \term{object} that represents a unitary token in an aggregate quantity of text;
     \seesection\CharacterConcepts.
  2. \Adjective\ 
     a. (of a \term{stream})
        having an \term{element type} that is a \subtypeof{character}.
        The most fundamental operation on a \term{character} \term{input} \term{stream} 
        is \funref{read-char} and on a \term{character} \term{output} \term{stream} 
        is \funref{write-char}. \Seeterm{binary}.
     b. (of a \term{file})
        having been created by opening a \term{character} \term{stream}.
        (It is \term{implementation-dependent} whether this is an inspectable aspect 
         of the \term{file}, or whether any given \term{binary} \term{file} can be
         treated as a \term{character} \term{file}.)

%!!! Moon: This never says what it is!
\gentry{character code} \Noun\
  1. one of possibly several \term{attributes} of a \term{character}.
  2. a non-negative \term{integer} less than \thevalueof{char-code-limit}
     that is suitable for use as a \term{character code}\meaning{1}.

\gentry{character designator} \Noun\
  a \term{designator} for a \term{character}; that is,
  an \term{object} that denotes a \term{character} 
  and that is one of:
       a \term{designator} for a \term{string} of \term{length} one
         (denoting the \term{character} that is its only \term{element}),
\issue{CHARACTER-PROPOSAL:2-1-1}
% Integers used to be permitted (a la INT-CHAR), but are now removed.
\endissue{CHARACTER-PROPOSAL:2-1-1}
    or a \term{character} (denoting itself).

\gentry{circular} \Adjective\
  1. (of a \term{list}) a \term{circular list}.
  2. (of an arbitrary \term{object})
     having a \term{component}, \term{element}, \term{constituent}\meaning{2}, 
     or \term{subexpression} (as appropriate to the context) 
     that is the \term{object} itself.

\gentry{circular list} \Noun\ 
  a chain of \term{conses} that has no termination because some
 \term{cons} in the chain is the \term{cdr} of a later \term{cons}.

\gentry{class} \Noun\
  1. an \term{object} that uniquely determines the structure and behavior of 
     a set of other \term{objects} called its \term{direct instances}, 
     that contributes structure and behavior to a set of
     other \term{objects} called its \term{indirect instances},
     and that acts as a \term{type specifier} for a set of objects
     called its \term{generalized instances}.
     \gexample{The class \typeref{integer} is a subclass of the class \typeref{number}.}
     (Note that the phrase ``the \term{class} \f{foo}'' is often substituted for
      the more precise phrase ``the \term{class} named \f{foo}''---in both
      cases, a \term{class} \term{object} (not a \term{symbol}) is denoted.)
  2. (of an \term{object})
     the uniquely determined \term{class} of which the \term{object} is
     a \term{direct instance}.
     \Seefun{class-of}.
     \gexample{The class of the object returned by \funref{gensym} 
 	       is \typeref{symbol}.}
     (Note that with this usage a phrase such as ``its \term{class} is \f{foo}'' 
      is often substituted for the more precise phrase
      ``its \term{class} is the \term{class} named \f{foo}''---in both
      cases, a \term{class} \term{object} (not a \term{symbol}) is denoted.)

\gentry{class designator} \Noun\
  a \term{designator} for a \term{class}; that is,
  an \term{object} that denotes a \term{class} 
  and that is one of:
       a \term{symbol} (denoting the \term{class} named by that \term{symbol};
		        \seefun{find-class})
    or a \term{class} (denoting itself).

\gentry{class precedence list} \Noun\
  a unique total ordering on a \term{class}
  and its \term{superclasses} that is consistent with the
  \term{local precedence orders} for the \term{class} and its
  \term{superclasses}.
  For detailed information, \seesection\DeterminingtheCPL.

\gentry{close} \TransitiveVerb\ (a \term{stream})
  to terminate usage of the \term{stream} as a source or sink of data,
  permitting the \term{implementation} to reclaim its internal data structures,
  and to free any external resources which might have been locked by the
 \term{stream} when it was opened.

\gentry{closed} \Adjective\ (of a \term{stream})
  having been \term{closed} (\seeterm\term{close}).
  Some (but not all) operations that are valid on \term{open} \term{streams} 
  are not valid on \term{closed} \term{streams}.
  \Seesection\OpenAndClosedStreams.

\gentry{closure} \Noun\
  a \term{lexical closure}.
 
%"constant objects" => "literal objects" per Moon #4(first public review) --kmp 5-May-93
\gentry{coalesce} \TransitiveVerb\ (\term{literal objects} that are \term{similar})
  to consolidate the identity of those \term{objects},
  such that they become the \term{same} %was "identical". -kmp 27-Jul-93
  \term{object}.
  \Seesection\CompilationTerms.

\gentry{code} \Noun\
  1. \Traditional\ 
     any representation of actions to be performed, whether conceptual
     or as an actual \term{object}, such as
         \term{forms},
         \term{lambda expressions},
         \term{objects} of \term{type} \term{function}, 
         text in a \term{source file},
      or instruction sequences in a \term{compiled file}.
      This is a generic term;
      the specific nature of the representation depends on its context.
  2. (of a \term{character})
     a \term{character code}.

\gentry{coerce} \TransitiveVerb\ (an \term{object} to a \term{type})
  to produce an \term{object} from the given \term{object},
  without modifying that \term{object},
  by following some set of coercion rules that must be specifically 
  stated for any context in which this term is used.
  The resulting \term{object} is necessarily of the indicated \term{type}, 
  except when that type is a \subtypeof{complex}; in that case,
  if a \term{complex rational} with an imaginary part of zero would result,
  the result is a \term{rational} 
  rather than a \term{complex}---\seesection\RuleOfCanonRepForComplexRationals.

\gentry{colon} \Noun\
  the \term{standard character} that is called ``colon'' (\f{:}).
  \Seefigure\StdCharsThree.

\gentry{comma} \Noun\
  the \term{standard character} that is called ``comma'' (\f{,}).
  \Seefigure\StdCharsThree.

\gentry{compilation} \Noun\
  the process of \term{compiling} \term{code} by the \term{compiler}.

%!!! Needs to acknowledge the interpreter in case of lazy semantic processing.
\gentry{compilation environment} \Noun\ 
  1. An \term{environment} that represents information known by the
     \term{compiler} about a \term{form} that is being \term{compiled}.
     \Seesection\CompilationTerms.
  2. An \term{object} that represents the
     \term{compilation environment}\meaning{1} 
     and that is used as a second argument to a \term{macro function}
     (which supplies a \term{value} for any \keyref{environment} \term{parameter}
      in the \term{macro function}'s definition).

\gentry{compilation unit} \Noun\
  an interval during which a single unit of compilation is occurring.
  \Seemac{with-compilation-unit}.

\gentry{compile} \TransitiveVerb\ 
  1. (\term{code})
     to perform semantic preprocessing of the \term{code}, usually optimizing
     one or more qualities of the code, such as run-time speed of \term{execution}
     or run-time storage usage.  The minimum semantic requirements of compilation are
     that it must remove all macro calls and arrange for all \term{load time values}
     to be resolved prior to run time.
  2. (a \term{function})
     to produce a new \term{object} \oftype{compiled-function}
     which represents the result of \term{compiling} the \term{code} 
     represented by the \term{function}.  \Seefun{compile}.
  3. (a \term{source file})
     to produce a \term{compiled file} from a \term{source file}.
     \Seefun{compile-file}.

\gentry{compile time} \Noun\ 
  the duration of time that the \term{compiler} is processing \term{source code}.

\gentry{compile-time definition} \Noun\
  a definition in the \term{compilation environment}.

\gentry{compiled code} \Noun\
  1. \term{compiled functions}.
  2. \term{code} that represents \term{compiled functions},
     such as the contents of a \term{compiled file}.

\gentry{compiled file} \Noun\
  a \term{file} which represents the results of \term{compiling} the 
  \term{forms} which appeared in a corresponding \term{source file},
  and which can be \term{loaded}.  \Seefun{compile-file}.

\issue{COMPILED-FUNCTION-REQUIREMENTS:TIGHTEN}
\gentry{compiled function} \Noun\
  an \term{object} \oftype{compiled-function}, which is a \term{function}
  that has been \term{compiled}, which contains no references to \term{macros} that
  must be expanded at run time, and which contains no unresolved references 
  to \term{load time values}.
\endissue{COMPILED-FUNCTION-REQUIREMENTS:TIGHTEN}

\gentry{compiler} \Noun\
  a facility that is part of Lisp and that translates \term{code}
  into an \term{implementation-dependent} form
  that might be represented or \term{executed} efficiently.
  The functions \funref{compile} and \funref{compile-file}
  permit programs to invoke the \term{compiler}.

\issue{DEFINE-COMPILER-MACRO:X3J13-NOV89}
\gentry{compiler macro} \Noun\
  an auxiliary macro definition for a globally defined \term{function}
  or \term{macro} which might or might not be called by any given
  \term{conforming implementation} and which must preserve the semantics
  of the globally defined \term{function} or \term{macro} but which might
  perform some additional optimizations.  (Unlike a \term{macro}, 
  a \term{compiler macro} does not extend the syntax of \clisp; rather, it
  provides an alternate implementation strategy for some existing syntax
  or functionality.)

\gentry{compiler macro expansion} \Noun\
  1. the process of translating a \term{form} into another \term{form}
     by a \term{compiler macro}.
  2. the \term{form} resulting from this process.

\gentry{compiler macro form} \Noun\
  a \term{function form} or \term{macro form} whose \term{operator}
  has a definition as a \term{compiler macro}, 
  or a \funref{funcall} \term{form} whose first \term{argument} is a
  \specref{function} \term{form} whose \term{argument} is the \term{name}
  of a \term{function} that has a definition as a \term{compiler macro}.

\gentry{compiler macro function} \Noun\ 
  a \term{function} of two arguments, a \term{form} and an 
  \term{environment}, that implements \term{compiler macro expansion} by
  producing either a \term{form} to be used in place of the original
  argument \term{form} or else \nil, indicating that the original \term{form}
  should not be replaced.  \Seesection\CompilerMacros.
\endissue{DEFINE-COMPILER-MACRO:X3J13-NOV89}

\gentry{complex} \Noun\
  an \term{object} \oftype{complex}.

\gentry{complex float} \Noun\
  an \term{object} \oftype{complex} which has a \term{complex part type}
  that is a \term{subtype} of \typeref{float}.
  A \term{complex float} is a \term{complex},
  but it is not a \term{float}.

\gentry{complex part type} \Noun\ (of a \term{complex})
  1. the \term{type} which is used to represent both the real part 
     and the imaginary part of the \term{complex}.
  2. the \term{actual complex part type} of the \term{complex}.
  3. the \term{expressed complex part type} of the \term{complex}.

\gentry{complex rational} \Noun\
  an \term{object} \oftype{complex} which has a \term{complex part type}
  that is a \term{subtype} of \typeref{rational}.
  A \term{complex rational} is a \term{complex}, but it is not a \term{rational}.  
  No \term{complex rational} has an imaginary part of zero because such a
  number is always represented by \clisp\ as an \term{object} \oftype{rational};
  \seesection\RuleOfCanonRepForComplexRationals.

\gentry{complex single float} \Noun\
  an \term{object} \oftype{complex} which has a \term{complex part type}
  that is a \term{subtype} of \typeref{single-float}.
  A \term{complex single float} is a \term{complex},
  but it is not a \term{single float}.

\gentry{composite stream} \Noun\
  a \term{stream} that is composed of one or more other \term{streams}.
  \gexample{\funref{make-synonym-stream} creates a composite stream.}
 
\gentry{compound form} \Noun\
  a \term{non-empty} \term{list} which is a \term{form}:
  a \term{special form},
  a \term{lambda form},
  a \term{macro form}, 
  or a \term{function form}.

\gentry{compound type specifier} \Noun\
  a \term{type specifier} that is a \term{cons};
  \ie a \term{type specifier} that is not an \term{atomic type specifier}.
  \gexample{\f{(vector single-float)} is a compound type specifier.}

\gentry{concatenated stream} \Noun\
  an \term{input} \term{stream} \oftype{concatenated-stream}.

\gentry{condition} \Noun\
  1. an \term{object} which represents a \term{situation}---usually,
     but not necessarily, during \term{signaling}.
  2. an \term{object} \oftype{condition}.

\gentry{condition designator} \Noun\
  one or more \term{objects} that, taken together, 
  denote either an existing \term{condition} \term{object} 
	     or a \term{condition} \term{object} to be implicitly created.
  For details, \seesection\ConditionDesignators.

\gentry{condition handler} \Noun\
  a \term{function} that might be invoked by the act of \term{signaling},
  that receives the \term{condition} being signaled as its only argument,
  and that is permitted to \term{handle} the \term{condition} 
  or to \term{decline}.  \Seesection\Signaling.

\gentry{condition reporter} \Noun\
  a \term{function} that describes how a \term{condition} is to be printed
  when the \term{Lisp printer} is invoked while \varref{*print-escape*} 
  is \term{false}.  \Seesection\PrintingConditions.

\gentry{conditional newline} \Noun\
  a point in output where a \term{newline} might be inserted at the
  discretion of the \term{pretty printer}.
  There are four kinds of \term{conditional newlines},
  called ``linear-style,''
	 ``fill-style,''
	 ``miser-style,''
     and ``mandatory-style.''
  \Seefun{pprint-newline} and \secref\DynamicControlofOutput.

\gentry{conformance} \Noun\
  a state achieved by proper and complete adherence to the requirements
  of this specification.  \Seesection\Conformance.

\gentry{conforming code} \Noun\
  \term{code} that is all of part of a \term{conforming program}.

\gentry{conforming implementation} \Noun\
  an \term{implementation}, used to emphasize complete and correct
  adherance to all conformance criteria.
  A \term{conforming implementation} is capable of 
      accepting a \term{conforming program} as input,
      preparing that \term{program} for \term{execution},
  and executing the prepared \term{program} in accordance with this specification.
  An \term{implementation} which
  has been extended may still be a \term{conforming implementation} 
  provided that no extension interferes with the correct function of any
  \term{conforming program}.

\gentry{conforming processor} \Noun\ \ANSI\ 
  a \term{conforming implementation}.

\gentry{conforming program} \Noun\
  a \term{program}, used to emphasize the fact that the \term{program}
  depends for its correctness only upon documented aspects of \clisp, and
  can therefore be expected to run correctly in any \term{conforming implementation}.

\gentry{congruent} \Noun\ 
  conforming to the rules of \term{lambda list} congruency, as detailed in 
  \secref\GFMethodLambdaListCongruency.

\gentry{cons} \Noun\Verb\ 
  1. \Noun\ a compound data \term{object} having two components called the
     \term{car} and the \term{cdr}.
  2. \Verb\ to create such an \term{object}.
  3. \Verb\ \Idiomatic\ to create any \term{object}, or to allocate storage.

\gentry{constant} \Noun\
  1. a \term{constant form}.
  2. a \term{constant variable}.
  3. a \term{constant object}.
  4. a \term{self-evaluating object}.

\gentry{constant form} \Noun\
  any \term{form}
   for which \term{evaluation} always \term{yields} the same \term{value},
   that neither affects nor is affected by the \term{environment}
     in which it is \term{evaluated} (except that it is permitted to
     refer to the names of \term{constant variables} 
     defined in the \term{environment}),
   and
   that neither affects nor is affected by the state of any \term{object}
     except those \term{objects} that are \term{otherwise inaccessible parts}
     of \term{objects} created by the \term{form} itself.
  \gexample{A \funref{car} form in which the argument is a
            \specref{quote} form is a constant form.}

\gentry{constant object} \Noun\
  an \term{object} that is constrained (\eg by its context in a \term{program}
  or by the source from which it was obtained) to be \term{immutable}.
  \gexample{A literal object that has been processed by \funref{compile-file}
	    is a constant object.}

\gentry{constant variable} \Noun\
  a \term{variable}, the \term{value} of which can never change;
  that is, a \term{keyword}\meaning{1} or a \term{named constant}.
  \gexample{The symbols \t, \nil, \kwd{direction}, and
            \conref{most-positive-fixnum}\ are constant variables.}

\gentry{constituent} \Noun, \Adjective\
  1. a. \Noun\ the \term{syntax type} of a \term{character} that is part of a \term{token}.
         For details, \seesection\ConstituentChars.
     b. \Adjective\ (of a \term{character})
        having the \term{constituent}\meaning{1a} \term{syntax type}\meaning{2}.
     c. \Noun\ a \term{constituent}\meaning{1b} \term{character}.
  2. \Noun\ (of a \term{composite stream})
     one of possibly several \term{objects} that collectively comprise
     the source or sink of that \term{stream}.

\gentry{constituent trait} \Noun\ (of a \term{character})
  one of several classifications of a \term{constituent} \term{character}
  in a \term{readtable}.  \Seesection\ConstituentChars.

\gentry{constructed stream} \Noun\ 
  a \term{stream} whose source or sink is a Lisp \term{object}.
  Note that since a \term{stream} is another Lisp \term{object},
  \term{composite streams} are considered \term{constructed streams}.
  \gexample{A string stream is a constructed stream.}

\gentry{contagion} \Noun\
  a process whereby operations on \term{objects} of differing \term{types}
  (\eg arithmetic on mixed \term{types} of \term{numbers}) produce a result
  whose \term{type} is controlled by the dominance of one \term{argument}'s
  \term{type} over the \term{types} of the other \term{arguments}.
  \Seesection\NumericContagionRules.

\gentry{continuable} \Noun\ (of an \term{error})
  an \term{error} that is \term{correctable} by the \f{continue} restart.

\gentry{control form} \Noun\
  1. a \term{form} that establishes one or more places to which control
     can be transferred.
  2. a \term{form} that transfers control.
% Moon says he can't think of any form which doesn't match this:
% 3. a \term{form} from which control can be transferred.

\gentry{copy} \Noun\
  1. (of a \term{cons} $C$)
     a \term{fresh} \term{cons} with the \term{same} \term{car} and \term{cdr} as $C$.
  2. (of a \term{list} $L$)
     a \term{fresh} \term{list} with the \term{same} \term{elements} as $L$.  
     (Only the \term{list structure} is \term{fresh};
      the \term{elements} are the \term{same}.)
     \Seefun{copy-list}.
  3. (of an \term{association list} $A$ with \term{elements} $A\sub{i}$)
     a \term{fresh} \term{list} $B$ with \term{elements} $B\sub{i}$, each of which is
     \nil\ if $A\sub i$ is \nil, or else a \term{copy} of the \term{cons} $A\sub i$.
     \Seefun{copy-alist}.
  4. (of a \term{tree} $T$)
     a \term{fresh} \term{tree} with the \term{same} \term{leaves} as $T$.
     \Seefun{copy-tree}.
  5. (of a \term{random state} $R$)
     a \term{fresh} \term{random state} that, if used as an argument to
     to \thefunction{random} would produce the same series of ``random''
     values as $R$ would produce.
\issue{DEFSTRUCT-COPIER:ARGUMENT-TYPE}
  6. (of a \term{structure} $S$)
     a \term{fresh} \term{structure} that has the same \term{type} as $S$,
     and that has slot values, each of which is the \term{same} as the 
     corresponding slot value of $S$.
\endissue{DEFSTRUCT-COPIER:ARGUMENT-TYPE}
%% Proposed:
%   7. (of an \term{array} $A\sub 1$)
%      a \term{fresh} \term{array} $A\sub 2$
%      with the same \term{array element type} as $A\sub 1$
%      and the \term{same} \term{active} \term{elements} as $A\sub 1$.
%   8. (of a \term{readtable} $R\sub 1$)
%      a \term{fresh} \term{readtable} $R\sub 2$
%      that has the same \term{readtable case} as $R\sub 1$
%      and whose associations between \term{macro characters} 
%        			        and their \term{reader macro functions}
%      are distinct from those of $R\sub 1$.
% 
  (Note that since the difference between a \term{cons}, a \term{list}, 
   and a \term{tree} is a matter of ``view'' or ``intention,''  there can
   be no general-purpose \term{function} which, based solely on the \term{type}
   of an \term{object}, can determine which of these distinct meanings is 
   intended.  The distinction rests solely on the basis of the text description
   within this document.  For example, phrases like ``a \term{copy} of the
   given \term{list}'' or ``copy of the \term{list} \param{x}'' imply the
   second definition.)

\gentry{correctable} \Adjective\ (of an \term{error})
  1. (by a \term{restart} other than \misc{abort} 
      that has been associated with the \term{error})
     capable of being corrected by invoking that \term{restart}.
     \gexample{The function \funref{cerror} signals an error 
	       that is correctable by the \misc{continue} \term{restart}.}
\issue{CONDITION-RESTARTS:PERMIT-ASSOCIATION}
     (Note that correctability is not a property of an
      \term{error} \term{object}, but rather a property of the 
      \term{dynamic environment} that is in effect when the
      \term{error} is \term{signaled}.
      Specifically, the \term{restart} is ``associated with'' 
      the \term{error} \term{condition} \term{object}.
      \Seesection\AssocRestartWithCond.)
\endissue{CONDITION-RESTARTS:PERMIT-ASSOCIATION}
  2. (when no specific \term{restart} is mentioned)
     \term{correctable}\meaning{1} by at least one \term{restart}.
     \gexample{\funref{import} signals a correctable error \oftype{package-error}
	       if any of the imported symbols has the same name as
	        some distinct symbol already accessible in the package.}

\gentry{current input base} \Noun\ (in a \term{dynamic environment})
  the \term{radix} that is \thevalueof{*read-base*} in that \term{environment}, 
  and that is the default \term{radix} employed by the \term{Lisp reader}
  and its related \term{functions}.

\gentry{current logical block} \Noun\
  the context of the innermost lexically enclosing use of \macref{pprint-logical-block}.

\gentry{current output base} \Noun\ (in a \term{dynamic environment})
  the \term{radix} that is \thevalueof{*print-base*} in that \term{environment}, 
  and that is the default \term{radix} employed by the \term{Lisp printer}
  and its related \term{functions}.

\gentry{current package} \Noun\ (in a \term{dynamic environment})
  the \term{package} that is \thevalueof{*package*} in that \term{environment}, 
  and that is the default \term{package} employed by the \term{Lisp reader} 
  and \term{Lisp printer}, and their related \term{functions}.

% Added for consistency with other "current xxx" terms. -kmp 27-Aug-93
\gentry{current pprint dispatch table} \Noun\ (in a \term{dynamic environment})
  the \term{pprint dispatch table} that is \thevalueof{*print-pprint-dispatch*}
  in that \term{environment}, and that is the default \term{pprint dispatch table}
  employed by the \term{pretty printer}.

\gentry{current random state} \Noun\ (in a \term{dynamic environment})
  the \term{random state} that is \thevalueof{*random-state*} in that \term{environment}, 
  and that is the default \term{random state} employed by \funref{random}.

\gentry{current readtable} \Noun\ (in a \term{dynamic environment})
  the \term{readtable} that is \thevalueof{*readtable*} in that \term{environment}, 
  and that affects the way in which \term{expressions}\meaning{2} are parsed 
  into \term{objects} by the \term{Lisp reader}.

\indextab{D}

\gentry{data type} \Noun\ \Traditional\ 
  a \term{type}.

\gentry{debug I/O} \Noun\ 
  the \term{bidirectional} \term{stream} 
  that is the \term{value} of \thevariable{*debug-io*}.

\gentry{debugger} \Noun\
  a facility that allows the \term{user} to handle a \term{condition} interactively.
  For example, the \term{debugger} might permit interactive
  selection of a \term{restart} from among the \term{active} \term{restarts},
  and it might perform additional \term{implementation-defined} services
  for the purposes of debugging.

\gentry{declaration} \Noun\
  a \term{global declaration} or \term{local declaration}.

\gentry{declaration identifier} \Noun\
  one of the \term{symbols}
     \declref{declaration},
     \declref{dynamic-extent},
     \declref{ftype},
     \declref{function},
     \declref{ignore}, 
     \declref{inline},  
     \declref{notinline},
     \declref{optimize}, 
     \declref{special}, 
  or \declref{type};
  or a \term{symbol} which is the \term{name} of a \term{type};
  or a \term{symbol} which has been \term{declared}
     to be a \term{declaration identifier} by using a \declref{declaration}
     \term{declaration}.
\issue{SYNTACTIC-ENVIRONMENT-ACCESS:RETRACTED-MAR91}
% or by using \funref{define-declaration}.
\endissue{SYNTACTIC-ENVIRONMENT-ACCESS:RETRACTED-MAR91}

\gentry{declaration specifier} \Noun\
  an \term{expression} that can appear at top level of a \misc{declare} 
  expression or a \macref{declaim} form, or as the argument to \funref{proclaim},
  and which has a \term{car} which is a \term{declaration identifier},
  and which has a \term{cdr} that is data interpreted according to rules
  specific to the \term{declaration identifier}.

\gentry{declare} \Verb\ 
  to \term{establish} a \term{declaration}.
  \Seemisc{declare}, \macref{declaim}, or \funref{proclaim}.

\gentry{decline} \Verb\ (of a \term{handler})
  to return normally without having \term{handled} the \term{condition}
  being \term{signaled}, permitting the signaling process to continue
  as if the \term{handler} had not been present.

\gentry{decoded time} \Noun\
  \term{absolute} \term{time}, represented as an ordered series of
  nine \term{objects} which, taken together, form a description of
  a point in calendar time, accurate to the nearest second (except
  that \term{leap seconds} are ignored).
  \Seesection\DecodedTime.

\gentry{default method} \Noun\
  a \term{method} having no \term{parameter specializers} other than
  \theclass{t}.  Such a \term{method} is always an \term{applicable method}
  but might be \term{shadowed}\meaning{2} by a more specific \term{method}.

\gentry{defaulted initialization argument list} \Noun\
  a \term{list} of alternating initialization argument \term{names} and
  \term{values} in which unsupplied initialization arguments are
  defaulted, used in the protocol for initializing and reinitializing 
  \term{instances} of \term{classes}.

% This is new per Barrett #3 (first public review). -kmp 12-May-93
\gentry{define-method-combination arguments lambda list} \Noun\
  a \term{lambda list} used by the \kwd{arguments} option 
  to \macref{define-method-combination}.
  \Seesection\DefMethCombArgsLambdaLists.

% This is new.  --sjl 5 Mar 92
\gentry{define-modify-macro lambda list} \Noun\
  a \term{lambda list} used by \macref{define-modify-macro}.
  \Seesection\DefineModifyMacroLambdaLists.

\gentry{defined name} \Noun\
  a \term{symbol} the meaning of which is defined by \clisp.

\gentry{defining form} \Noun\
  a \term{form} that has the side-effect of \term{establishing} a definition.
  \gexample{\macref{defun} and \macref{defparameter} are defining forms.}

\gentry{defsetf lambda list} \Noun\
  a \term{lambda list} that is like an \term{ordinary lambda list} 
  except that it does not permit \keyref{aux}
     and that it permits use of \keyref{environment}.
  \Seesection\DefsetfLambdaLists.

\issue{DEFTYPE-KEY:ALLOW}
\issue{DEFTYPE-DESTRUCTURING:YES}
\gentry{deftype lambda list} \Noun\
  a \term{lambda list} that is like a \term{macro lambda list}
  except that the default \term{value} for unsupplied \term{optional parameters}
  and \term{keyword parameters} is the \term{symbol} \misc{*} (rather than \nil).
  \Seesection\DeftypeLambdaLists.
\endissue{DEFTYPE-DESTRUCTURING:YES}
\endissue{DEFTYPE-KEY:ALLOW}

\gentry{denormalized} \Adjective, \ANSI, \IEEE\ (of a \term{float})
  conforming to the description of ``denormalized'' as described by 
  {\IEEEFloatingPoint}.
  For example, in an \term{implementation} where the minimum possible exponent 
  was \f{-7} but where \f{0.001} was a valid mantissa, the number \f{1.0e-10}
  might be representable as \f{0.001e-7} internally even if the \term{normalized}
  representation would call for it to be represented instead as \f{1.0e-10} 
  or \f{0.1e-9}.  By their nature, \term{denormalized} \term{floats} generally
  have less precision than \term{normalized} \term{floats}.

\gentry{derived type} \Noun\
  a \term{type specifier} which is defined in terms of an expansion into another
  \term{type specifier}.  \macref{deftype} defines \term{derived types}, 
  and there may be other \term{implementation-defined} \term{operators}
  which do so as well.

\gentry{derived type specifier} \Noun\
  a \term{type specifier} for a \term{derived type}.

\gentry{designator} \Noun\ 
  an \term{object} that denotes another \term{object}.
  In the dictionary entry for an \term{operator}
  if a \term{parameter} is described as a \term{designator} for a \term{type},
  the description of the \term{operator} is written in a way
  that assumes that appropriate coercion to that \term{type} has already occurred;
  that is, that the \term{parameter} is already of the denoted \term{type}.
  For more detailed information, \seesection\Designators.

\gentry{destructive} \Adjective\ (of an \term{operator})
  capable of modifying some program-visible aspect of one or more
  \term{objects} that are either explicit \term{arguments} to the
  \term{operator} or that can be obtained directly or indirectly 
  from the \term{global environment} by the \term{operator}.

% This is new.  --sjl 5 Mar 92
\gentry{destructuring lambda list} \Noun\
  an \term{extended lambda list} used in \macref{destructuring-bind} and
  nested within \term{macro lambda lists}.  
  \Seesection\DestructuringLambdaLists.

\gentry{different} \Adjective\ 
  not the \term{same}
  \gexample{The strings \f{"FOO"} and \f{"foo"} are different under
	    \funref{equal} but not under \funref{equalp}.}

\gentry{digit} \Noun\ (in a \term{radix})
  a \term{character} that is among the possible digits (\f{0} to \f{9},
  \f{A} to \f{Z}, and \f{a} to \f{z}) and that is defined to have an 
  associated numeric weight as a digit in that \term{radix}.
  \Seesection\Digits.

\gentry{dimension} \Noun\
  1. a non-negative \term{integer} indicating the number of
     \term{objects} an \term{array} can hold along one axis.
     If the \term{array} is a \term{vector} with a \term{fill pointer},
     the \term{fill pointer} is ignored.
     \gexample{The second dimension of that array is 7.}
  2. an axis of an array.
     \gexample{This array has six dimensions.}
 
\gentry{direct instance} \Noun\ (of a \term{class} $C$)
  an \term{object} whose \term{class} is $C$ itself,
  rather than some \term{subclass} of $C$.
  \gexample{The function \funref{make-instance} always returns a 
  	    direct instance of the class which is (or is named by)
	    its first argument.}

\gentry{direct subclass} \Noun\ (of a \term{class} $C\sub{1}$)
  a \term{class} $C\sub{2}$,
  such that $C\sub{1}$ is a \term{direct superclass} of $C\sub{2}$.

\gentry{direct superclass} \Noun\ (of a \term{class} $C\sub{1}$)
  a \term{class} $C\sub{2}$ which was explicitly designated as 
  a \term{superclass} of $C\sub{1}$ in the definition of $C\sub{1}$.

\gentry{disestablish} \TransitiveVerb\ 
  to withdraw the \term{establishment} of 
      an \term{object},
      a  \term{binding},
      an \term{exit point}, 
      a  \term{tag},
      a  \term{handler},
      a  \term{restart}, 
   or an \term{environment}.
 
\gentry{disjoint} \Noun\ (of \term{types})
  having no \term{elements} in common.

\gentry{dispatching macro character} \Noun\ 
  a \term{macro character} that has an associated table that specifies 
  the \term{function} to be called for each \term{character} that is
  seen following the \term{dispatching macro character}.
  \Seefun{make-dispatch-macro-character}.

\gentry{displaced array} \Noun\
%Alternatively (from an old definition of make-array):
% ...an indirect or shared \term{array} that shares its contents...
  an \term{array} which has no storage of its own, but which is instead
  indirected to the storage of another \term{array}, called its
  \term{target}, at a specified offset, in such a way that any attempt
  to \term{access} the \term{displaced array} implicitly references the 
  \term{target} \term{array}.

\gentry{distinct} \Adjective\
  not \term{identical}.

\gentry{documentation string} \Noun\ (in a defining \term{form}) 
  A \term{literal} \term{string} which because of the context in which
  it appears (rather than because of some intrinsically observable 
  aspect of the \term{string}) is taken as documentation.
  In some cases, the \term{documentation string} is saved in such a
  way that it can later be obtained by supplying either an \term{object}, 
  or by supplying a \term{name} and a ``kind'' to \thefunction{documentation}.
  \gexample{The body of code in a \macref{defmacro} form can be preceded 
	    by a documentation string of kind \misc{function}.}

\gentry{dot} \Noun\
  the \term{standard character} that is variously called
     ``full stop,''
     ``period,''
  or ``dot'' (\f{.}).
  \Seefigure\StdCharsThree.

%Maybe separate into adjective so we can say "(possibly dotted) list" etc. -kmp 7-May-91
\gentry{dotted list} \Noun\
  a \term{list} which has a terminating \term{atom} that is not \nil.
  (An \term{atom} by itself is not a \term{dotted list}, however.)

\gentry{dotted pair} \Noun\
  1. a \term{cons} whose \term{cdr} is a \term{non-list}.
  2. any \term{cons}, used to emphasize the use of the \term{cons}
     as a symmetric data pair.
 
\gentry{double float} \Noun\
  an \term{object} \oftype{double-float}.

\gentry{double-quote} \Noun\
  the \term{standard character} that is variously called
      ``quotation mark''
   or ``double quote'' (\f{"}).
  \Seefigure\StdCharsThree.

\gentry{dynamic binding} \Noun\ 
  a \term{binding} in a \term{dynamic environment}.

\gentry{dynamic environment} \Noun\
  that part of an \term{environment} that contains \term{bindings} 
  with \term{dynamic extent}.  A \term{dynamic environment} contains,
%!!! Moon: This phrase ["among other things"] always scares me. Is it necessary?
  among other things:
    \term{exit points} established by \specref{unwind-protect},
  and 
    \term{bindings} of
      \term{dynamic variables},
      \term{exit points} established by \specref{catch},
      \term{condition handlers},
    and
      \term{restarts}.  
 
%%!!! The CLIM folks want to be able to say:
%%      ``the parameter x has dynamic extent''
%%    and have it imply that:
%%      (a) ``the implementation of the indicated function 
%%            may declare the argument to be dynamic extent''
%%    and
%%      (b) ``it is permissible to pass an object which was 
%%            the value of a variable which had been declared dynamic extent''
%%    -kmp 30-Jan-92
\gentry{dynamic extent} \Noun\
  an \term{extent} whose duration is bounded by points of 
  \term{establishment} and \term{disestablishment} within the execution
  of a particular \term{form}.  \Seeterm{indefinite extent}.
  \gexample{Dynamic variable bindings have dynamic extent.}
 
\gentry{dynamic scope} \Noun\
  \term{indefinite scope} along with \term{dynamic extent}.
 
\gentry{dynamic variable} \Noun\
  a \term{variable} the \term{binding} for which is in the \term{dynamic environment}.
  \Seemisc{special}.

\indextab{E}

\gentry{echo stream} \Noun\
  a \term{stream} \oftype{echo-stream}.

\gentry{effective method} \Noun\
  the combination of \term{applicable methods} that are executed
  when a \term{generic function} is invoked with a particular sequence
  of \term{arguments}.
 
\gentry{element} \Noun\
  1. (of a \term{list}) 
     an \term{object} that is the \term{car} of one of the \term{conses}
     that comprise the \term{list}.
  2. (of an \term{array})
     an \term{object} that is stored in the \term{array}.
  3. (of a \term{sequence})
     an \term{object} that is an \term{element} of the \term{list} or \term{array}
     that is the \term{sequence}.
  4. (of a \term{type})
     an \term{object} that is a member of the set of \term{objects}
     designated by the \term{type}.
  5. (of an \term{input} \term{stream})
     a \term{character} or \term{number} (as appropriate to the
     \term{element type} of the \term{stream})
     that is among the ordered series of \term{objects} that can be 
     read from the \term{stream} (using \funref{read-char} or \funref{read-byte},
     as appropriate to the \term{stream}).
  6. (of an \term{output} \term{stream})
     a \term{character} or \term{number} (as appropriate to the
     \term{element type} of the \term{stream})
     that is among the ordered series of \term{objects} that has been
     or will be written to the \term{stream} (using \funref{write-char} 
     or \funref{write-byte}, as appropriate to the \term{stream}).
  7. (of a \term{class}) a \term{generalized instance} of the \term{class}.

\gentry{element type} \Noun\ 
  1. (of an \term{array}) the \term{array element type} of the \term{array}.
  2. (of a \term{stream}) the \term{stream element type} of the \term{stream}.

\gentry{em} \Noun\ \Traditional\ 
  a context-dependent unit of measure commonly used in typesetting,
  equal to the displayed width of of a letter ``M'' in the current font.
  (The letter ``M'' is traditionally chosen because it is typically 
   represented by the widest \term{glyph} in the font, and other characters' 
   widths are typically fractions of an \term{em}.  In implementations providing 
   non-Roman characters with wider characters than ``M,'' it is permissible 
   for another character to be the \term{implementation-defined} reference character
   for this measure, and for ``M'' to be only a fraction of an \term{em}
   wide.)  
  In a fixed width font, a line with \i{n} characters is \i{n} 
  \term{ems} wide; in a variable width font, \i{n} \term{ems} is the
  expected upper bound on the width of such a line.

\gentry{empty list} \Noun\
  the \term{list} containing no \term{elements}. \Seeterm{()}.
 
\gentry{empty type} \Noun\
  the \term{type} that contains no \term{elements}, and that is
  a \term{subtype} of all \term{types} (including itself).
  \Seeterm{nil}.

\gentry{end of file} \Noun\
  1. the point in an \term{input} \term{stream} beyond which there is
     no further data.
     Whether or not there is such a point on an \term{interactive stream} 
     is \term{implementation-defined}.
  2. a \term{situation} that occurs upon an attempt to obtain data from an
     \term{input stream} that is at the \term{end of file}\meaning{1}.

%% This might be handy sometime...
%
% \gentry{end of line} \Noun\
%   the termination of a line of text,
%   whether by a \term{newline} or an \term{end of file}.

\gentry{environment} \Noun\
  1. a set of \term{bindings}. \Seesection\IntroToEnvs.
  2. an \term{environment object}.
     \gexample{\funref{macroexpand} takes an optional environment argument.}

\gentry{environment object} \Noun\
  an \term{object} representing a set of \term{lexical bindings},
     used in the processing of a \term{form} to provide meanings for
     \term{names} within that \term{form}.
     \gexample{\funref{macroexpand} takes an optional environment argument.}
     (The \term{object} \nil\ when used as an \term{environment object}
      denotes the \term{null lexical environment};
      the \term{values} of \term{environment parameters} 
      to \term{macro functions} are \term{objects}
      of \term{implementation-dependent} nature which represent the 
      \term{environment}\meaning{1} in which the corresponding \term{macro form}
      is to be expanded.)
     \Seesection\EnvObjs.

\gentry{environment parameter} \Noun\
  A \term{parameter} in a \term{defining form} $f$ for which there is no corresponding
  \term{argument}; instead, this \term{parameter} receives as its value an
  \term{environment} \term{object} which corresponds to the
  \term{lexical environment} in which the \term{defining form} $f$ appeared.

%!!! Moon: I disagree with 1 and 2, "undefined consequences" /= "defined to signal an error"
\gentry{error} \Noun\
  1. (only in the phrase ``is an error'')
     a \term{situation} in which the semantics of a program are not specified, 
     and in which the consequences are undefined.
  2. a \term{condition} which represents an \term{error} \term{situation}.
     \Seesection\ErrorTerms.
  3. an \term{object} \oftype{error}.

\gentry{error output} \Noun\ 
  the \term{output} \term{stream} which is the \term{value} of the \term{dynamic variable}
  \varref{*error-output*}.

\gentry{escape} \Noun, \Adjective\
  1. \Noun\ a \term{single escape} or a \term{multiple escape}.
  2. \Adjective\ \term{single escape} or \term{multiple escape}.

%!!!! RPG doesn't think this definition is really adequate, 
%     especially for declarations.
\gentry{establish} \TransitiveVerb\ 
  to build or bring into being 
      a  \term{binding},
      a  \term{declaration},
      an \term{exit point},
      a  \term{tag},
      a  \term{handler}, 
      a \term{restart},
   or an \term{environment}. 
  \gexample{\specref{let} establishes lexical bindings.}

%% Experimental definition not installed. -kmp 26-Jan-92
% \gentry{establish} \TransitiveVerb\ 
%   1. (an \term{environment}) to build or bring into being.
%   2. (a  \term{binding},
%       a  \term{declaration},
%       an \term{exit point},
%       a  \term{tag},
%       a  \term{handler}, 
%       a \term{restart})
%      to \term{establish}\meaning{1} an augmented \term{environment}
%      in which that entity is \term{active}, applicable, present, or visible.
%   \gexample{\specref{let} establishes lexical bindings.}

\gentry{evaluate} \TransitiveVerb\ (a \term{form} or an \term{implicit progn})
  to \term{execute} the \term{code} represented by the \term{form}
  (or the series of \term{forms} making up the \term{implicit progn})
  by applying the rules of \term{evaluation},
  returning zero or more values.

\gentry{evaluation} \Noun\
  a model whereby \term{forms} are \term{executed}, returning zero or more values.
  Such execution might be implemented directly in one step by an interpreter
  or in two steps by first \term{compiling} the \term{form} and then
  \term{executing} the \term{compiled} \term{code}; this choice is 
  dependent both on context and the nature of the \term{implementation}, 
  but in any case is not in general detectable by any program.  The evaluation
  model is designed in such a way that a \term{conforming implementation} 
  might legitimately have only a compiler and no interpreter, or vice versa.
  \Seesection\EvaluationModel.
 
\gentry{evaluation environment} \Noun\
  a \term{run-time environment} in which macro expanders 
  and code specified by \specref{eval-when} to be evaluated
  are evaluated.  All evaluations initiated by the \term{compiler} 
  take place in the \term{evaluation environment}.

\gentry{execute} \TransitiveVerb\ \Traditional\ (\term{code})
  to perform the imperative actions represented by the \term{code}.

\gentry{execution time} \Noun\
  the duration of time that \term{compiled code} is being \term{executed}.

\gentry{exhaustive partition} \Noun\ (of a \term{type})
  a set of \term{pairwise} \term{disjoint} \term{types} that form an 
  \term{exhaustive union}.

\gentry{exhaustive union} \Noun\ (of a \term{type})
  a set of \term{subtypes} of the \term{type},
  whose union contains all \term{elements} of that \term{type}.
 
\gentry{exit point} \Noun\
  a point in a \term{control form}
% Moon would remove this first phrase, but I think the phrases refer 
% respectively to BLOCK, UNWIND-PROTECT, and TAGBODY. -kmp 14-Nov-91
       from which (\eg \specref{block}),
       through which (\eg \specref{unwind-protect}),
    or to which (\eg \specref{tagbody})
  control and possibly \term{values} can be transferred both actively by using 
  another \term{control form} and passively through the normal control and
  data flow of \term{evaluation}.
  \gexample{\specref{catch} and \specref{block} establish bindings for
            exit points to which \specref{throw} and \specref{return-from},
	    respectively, can transfer control and values;
	    \specref{tagbody} establishes a binding for an exit point
	    with lexical extent to which \specref{go} can transfer control;
	    and \specref{unwind-protect} establishes an exit point 
	    through which control might be transferred by 
	    operators such as \specref{throw}, \specref{return-from},
            and \specref{go}.}

\gentry{explicit return} \Noun\ 
  the act of transferring control (and possibly \term{values}) 
  to a \term{block} by using \specref{return-from} (or \macref{return}).

\gentry{explicit use} \Noun\ (of a \term{variable} $V$ in a \term{form} $F$)
  a reference to $V$ that is directly apparent in the normal semantics of $F$;
  \ie that does not expose any undocumented details of the
      \term{macro expansion} of the \term{form} itself.
  References to $V$ exposed by expanding \term{subforms} of $F$ are, however,
  considered to be \term{explicit uses} of $V$.

%Barmar prefers "printed representation of" to "textual notation for"
\gentry{exponent marker} \Noun\
  a character that is used in the textual notation for a \term{float}
  to separate the mantissa from the exponent.
  The characters defined as \term{exponent markers} in the \term{standard readtable}
  are shown in \thenextfigure.
  For more information, \seesection\CharacterSyntax.
  \gexample{The exponent marker `d' in `3.0d7' indicates
	    that this number is to be represented as a double float.}

\tablefigtwo{Exponent Markers}{Marker}{Meaning}{
 \f{D} or \f{d} & \typeref{double-float}                                     \cr
 \f{E} or \f{e} & \typeref{float} (see \varref{*read-default-float-format*}) \cr
 \f{F} or \f{f} & \typeref{single-float}                                     \cr
 \f{L} or \f{l} & \typeref{long-float}                                       \cr
 \f{S} or \f{s} & \typeref{short-float}                                      \cr
}

\gentry{export} \TransitiveVerb\ (a \term{symbol} in a \term{package})
  to add the \term{symbol} to the list of \term{external symbols} of the
  \term{package}.

\gentry{exported} \Adjective\ (of a \term{symbol} in a \term{package})
  being an \term{external symbol} of the \term{package}.

\gentry{expressed adjustability} \Noun\ (of an \term{array})
  a \term{generalized boolean} that is conceptually (but not necessarily actually)
  associated with the \term{array}, representing whether the \term{array}
  is \term{expressly adjustable}.
  \SeetermAlso{actual adjustability}.

\gentry{expressed array element type} \Noun\ (of an \term{array})
  the \term{type} which is the \term{array element type}
  implied by a \term{type declaration} for the \term{array}, 
  or which is the requested \term{array element type} at its time 
  of creation, prior to any selection of an \term{upgraded array element type}.
  (\clisp\ does not provide a way of detecting this \term{type}
   directly at run time, but an \term{implementation} is permitted 
   to make assumptions about the \term{array}'s contents and
   the operations which may be performed on the \term{array} when
   this \term{type} is noted during code analysis, even if those 
   assumptions would not be valid in general for the
   \term{upgraded array element type} of the
   \term{expressed array element type}.)
% KMP->Barmar:
%  You remarked that you think you can rely on array-element-type and 
%  upgraded-xxx-type. This is intended to permit a compiler optimizer like:
%      (frob (make-array n :element-type '(unsigned-byte 13)))
%  to turn into
%      (si:frob-internal-signed-byte-13 
%        (make-array n :element-type '(unsigned-byte 13)))
%  even though the implementation knows that (unsigned-byte 16) will really get
%  allocated, let's say.  Moreover, the compiler should be permitted to warn about:
%      (defun foo (n) 
%        (let ((x (make-array n :element-type '(unsigned-byte 2))))
% 	 (setf (aref x 0) 17.) ...))
%  It generally will not warn about:
%      (defun foo (n)
%        (bar (make-array n :element-type '(unsigned-byte 2))))
%      (defun bar (a)
%        (setf (aref x 0) 17.) ...)
%  I agree that it should never warn about:
%      (defun foo (n) 
%        (let ((x (make-array n :element-type '(unsigned-byte 2))))
% 	 (when (type-equivalent-p (array-element-type x) 'fixnum)
% 	    (setf (aref x 0) 17.) ...)))
%  because this is portably guarded even if it behaves differently on the
%  different implementations to which it is ported.
% 
%  This makes it tough to do the optimization I'm referring to, but I don't
%  think that implementations which really properly check that the path is
%  clear between the allocation and the reference should be forbidden from
%  flagging an unconditional non-portability.
%
% Barmar: 
%  You apparently understand the point I was making.  If you can come up
%  with a concise way to phrase it in the definition of "declared XXX
%  type", that's all I was hoping for.  If not, I don't think this is a
%  critical issue.

\gentry{expressed complex part type} \Noun\ (of a \term{complex})
  the \term{type} which is implied as the \term{complex part type}
  by a \term{type declaration} for the \term{complex}, 
  or which is the requested \term{complex part type} at its time of
  creation, prior to any selection of an \term{upgraded complex part type}.
  (\clisp\ does not provide a way of detecting this \term{type}
   directly at run time, but an \term{implementation} is permitted 
   to make assumptions about the operations which may be performed on
   the \term{complex} when this \term{type} is noted during code
   analysis, even if those assumptions would not be valid in general for 
   the \term{upgraded complex part type} of the
   \term{expressed complex part type}.)

\gentry{expression} \Noun\
  1. an \term{object}, often used to emphasize the use 
     of the \term{object} to encode or represent information in a specialized
     format, such as program text.
     \gexample{The second expression in a \specref{let} form is a list
   	       of bindings.}
  2. the textual notation used to notate an \term{object} in a source file.
     \gexample{The expression \f{'sample} is equivalent to \f{(quote sample)}.}

\gentry{expressly adjustable} \Adjective\ (of an \term{array})
  being \term{actually adjustable} by virtue of an explicit request for this
  characteristic having been made at the time of its creation.
  All \term{arrays} that are \term{expressly adjustable} 
  are \term{actually adjustable},
  but not necessarily vice versa.

\gentry{extended character} \Noun\
  a \term{character} 
\issue{CHARACTER-VS-CHAR:LESS-INCONSISTENT-SHORT}
  \oftype{extended-char}:
\endissue{CHARACTER-VS-CHAR:LESS-INCONSISTENT-SHORT}
  a \term{character} that is not a \term{base character}.

\gentry{extended function designator} \Noun\
  a \term{designator} for a \term{function}; that is,
  an \term{object} that denotes a \term{function}
  and that is one of:
      a \term{function name} (denoting the \term{function} it names
                              in the \term{global environment}),
   or a \term{function} (denoting itself).
  The consequences are undefined if 
  a \term{function name} is used as an 
  \term{extended function designator} but
  it does not have a global definition as a \term{function},
  or if it is a \term{symbol} 
     that has a global definition as a \term{macro} or a \term{special form}.
  \SeetermAlso{function designator}.

\gentry{extended lambda list} \Noun\
  a list resembling an \term{ordinary lambda list} in form and purpose, but 
  offering additional syntax or functionality not available in an
  \term{ordinary lambda list}.
  \gexample{\macref{defmacro} uses extended lambda lists.}
 
\gentry{extension} \Noun\
  a facility in an \term{implementation} of \clisp\ 
  that is not specified by this standard.

\gentry{extent} \Noun\
  the interval of time during which a \term{reference} to 
      an \term{object},
      a  \term{binding},
      an \term{exit point},
      a  \term{tag},
      a  \term{handler},
      a  \term{restart},
   or an \term{environment} is defined.
 
\gentry{external file format} \Noun\
  an \term{object} of \term{implementation-dependent} nature which determines
  one of possibly several \term{implementation-dependent} ways in which
  \term{characters} are encoded externally in a \term{character} \term{file}.

\gentry{external file format designator} \Noun\
  a \term{designator} for an \term{external file format}; that is,
  an \term{object} that denotes an \term{external file format}
  and that is one of:
      the \term{symbol} \kwd{default} 
         (denoting an \term{implementation-dependent} default 
          \term{external file format} that can accomodate at least
          the \term{base characters}),
      some other \term{object} defined by the \term{implementation} to be
      an \term{external file format designator}
         (denoting an \term{implementation-defined} \term{external file format}),
   or some other \term{object} defined by the \term{implementation} to be
      an \term{external file format} 
         (denoting itself).

\gentry{external symbol} \Noun\ (of a \term{package})
  a \term{symbol} that is part of the `external interface' to the \term{package}
  and that are \term{inherited}\meaning{3} by any other \term{package}
   that \term{uses} the \term{package}.
  When using the \term{Lisp reader}, 
  if a \term{package prefix} is used,
  the \term{name} of an \term{external symbol} is separated
    from the \term{package} \term{name} by a single \term{package marker}
  while
  the \term{name} of an \term{internal symbol} is separated
    from the \term{package} \term{name} by a double \term{package marker};
  \seesection\SymbolTokens.

\gentry{externalizable object} \Noun\
  an \term{object} that can be used as a \term{literal} \term{object} 
  in \term{code} to be processed by the \term{file compiler}.  

\indextab{F}
 
\gentry{false} \Noun\
  the \term{symbol} \nil,
  used to represent the failure of a \term{predicate} test.

\gentry{fbound} \pronounced{\Stress{ef}\stress{ba\.und}} \Adjective\ 
							 (of a \term{function name})
  \term{bound} in the \term{function} \term{namespace}.
  (The \term{names} of \term{macros} and \term{special operators} are \term{fbound},
   but the nature and \term{type} of the \term{object} which is their \term{value}
   is \term{implementation-dependent}.
\issue{SETF-FUNCTIONS-AGAIN:MINIMAL-CHANGES}
   Further, defining a \term{setf expander} \param{F} does not cause the \term{setf function}
   \f{(setf \param{F})} to become defined; as such, if there is a such a definition
   of a \term{setf expander} \param{F}, the \term{function} \f{(setf \param{F})}
   can be \term{fbound} if and only if, by design or coincidence, a
   function binding for \f{(setf \param{F})} has been independently established.)
\endissue{SETF-FUNCTIONS-AGAIN:MINIMAL-CHANGES}
  \Seefuns{fboundp} and \funref{symbol-function}.

\gentry{feature} \Noun\
  1. an aspect or attribute 
        of \clisp, 
        of the \term{implementation},
     or of the \term{environment}.
  2. a \term{symbol} that names a \term{feature}\meaning{1}.
  \Seesection\Features.
  \gexample{The \kwd{ansi-cl} feature is present in all conforming implementations.}

\gentry{feature expression} \Noun\
  A boolean combination of \term{features} used by the \f{\#+} and \f{\#-} 
  \term{reader macros} in order to direct conditional \term{reading} of
  \term{expressions} by the \term{Lisp reader}.
  \Seesection\FeatureExpressions.

\gentry{features list} \Noun\
  the \term{list} that is \thevalueof{*features*}.

\gentry{file} \Noun\
  a named entry in a \term{file system},
  having an \term{implementation-defined} nature.

\gentry{file compiler} \Noun\
  any \term{compiler} which \term{compiles} \term{source code} contained in a \term{file},
  producing a \term{compiled file} as output.  The \funref{compile-file} 
  function is the only interface to such a \term{compiler} provided by \clisp,
  but there might be other, \term{implementation-defined} mechanisms for 
  invoking the \term{file compiler}.

\gentry{file position} \Noun\ (in a \term{stream})
  a non-negative \term{integer} that represents a position in the \term{stream}.
  Not all \term{streams} are able to represent the notion of \term{file position};
  in the description of any \term{operator} which manipulates \term{file positions}, 
  the behavior for \term{streams} that don't have this notion must be explicitly stated.
  For \term{binary} \term{streams}, the \term{file position} represents the number 
  of preceding \term{bytes} in the \term{stream}.
  For \term{character} \term{streams}, the constraint is more relaxed: 
  \term{file positions} must increase monotonically, the amount of the increase
  between \term{file positions} corresponding to any two successive characters
  in the \term{stream} is \term{implementation-dependent}.

\gentry{file position designator} \Noun\ (in a \term{stream})
  a \term{designator} for a \term{file position} in that \term{stream}; that is,
      the symbol \kwd{start}  
        (denoting \f{0}, the first \term{file position} in that \term{stream}),
      the symbol \kwd{end}
	(denoting the last \term{file position} in that \term{stream};
	 \ie the position following the last \term{element} of the \term{stream}),
   or a \term{file position} (denoting itself).

\gentry{file stream} \Noun\
  an \term{object} \oftype{file-stream}.

\gentry{file system} \Noun\
  a facility which permits aggregations of data to be stored in named
  \term{files} on some medium that is external to the \term{Lisp image}
  and that therefore persists from \term{session} to \term{session}.

\issue{PATHNAME-HOST-PARSING:RECOGNIZE-LOGICAL-HOST-NAMES}
\gentry{filename} \Noun\
%% This term applies some places to logical pathnames and doesn't work very well
%% for them, so I tried to make it more abstract. -kmp 28-Aug-93
%   an \term{implementation-dependent} handle, not necessarily ever directly
%   represented as an \term{object}, that can be used to refer to a \term{file}
%   in a \term{file system}.  \term{Physical pathnames} and 
%   \term{physical pathname} \term{namestrings} are two kinds of \term{objects} 
%   that substitute for \term{filenames} in \clisp.  The specific relationship 
%   between \term{filenames} and \term{physical pathnames}, and between
%   \term{filenames} and \term{namestrings}, is \term{implementation-defined}.
  a handle, not necessarily ever directly represented as an \term{object},
  that can be used to refer to a \term{file} in a \term{file system}.
  \term{Pathnames} and \term{namestrings} are two kinds of \term{objects} 
  that substitute for \term{filenames} in \clisp.  
\endissue{PATHNAME-HOST-PARSING:RECOGNIZE-LOGICAL-HOST-NAMES}

\gentry{fill pointer} \Noun\ (of a \term{vector})
  an \term{integer} associated with a \term{vector} that represents the
  index above which no \term{elements} are \term{active}.
  (A \term{fill pointer} is a non-negative \term{integer} no
   larger than the total number of \term{elements} in the \term{vector}.
   Not all \term{vectors} have \term{fill pointers}.)
 
\gentry{finite} \Adjective\ (of a \term{type})
  having a finite number of \term{elements}.
  \gexample{The type specifier \f{(integer 0 5)} denotes a finite type,
	    but the type specifiers \typeref{integer} and \f{(integer 0)} do not.}

\gentry{fixnum} \Noun\ 
  an \term{integer} \oftype{fixnum}.

\gentry{float} \Noun\
  an \term{object} \oftype{float}.

\issue{IGNORE-USE-TERMINOLOGY:VALUE-ONLY}
\gentry{for-value} \Adjective\ (of a \term{reference} to a \term{binding})
  being a \term{reference} that \term{reads}\meaning{1}
  the \term{value} of the \term{binding}.
\endissue{IGNORE-USE-TERMINOLOGY:VALUE-ONLY}

\gentry{form} \Noun\
  1. any \term{object} meant to be \term{evaluated}.
  2.    a \term{symbol},
        a \term{compound form},
     or a \term{self-evaluating object}.
  3. (for an \term{operator}, as in ``\metavar{operator} \term{form}'')
     a \term{compound form} having that \term{operator} as its first element.
     \gexample{A \specref{quote} form is a constant form.}
 
\gentry{formal argument} \Noun\ \Traditional\ 
  a \term{parameter}.

\gentry{formal parameter} \Noun\ \Traditional\ 
  a \term{parameter}.

\issue{FORMAT-STRING-ARGUMENTS:SPECIFY}
\gentry{format} \TransitiveVerb\ (a \term{format control} and \term{format arguments})
  to perform output as if by \funref{format},
  using the \term{format string} and \term{format arguments}.
\endissue{FORMAT-STRING-ARGUMENTS:SPECIFY}

\issue{FORMAT-STRING-ARGUMENTS:SPECIFY}
\gentry{format argument} \Noun\
  an \term{object} which is used as data by functions such as \funref{format}
  which interpret \term{format controls}.
\endissue{FORMAT-STRING-ARGUMENTS:SPECIFY}

\gentry{format control} \Noun\
     a \term{format string},
  or a \term{function} that obeys the \term{argument} conventions
     for a \term{function} returned by \themacro{formatter}.
  \Seesection\CompilingFormatStrings.

\gentry{format directive} \Noun\
  1. a sequence of \term{characters} in a \term{format string}
     which is introduced by a \term{tilde}, and which is specially 
     interpreted by \term{code} which processes \term{format strings}
     to mean that some special operation should be performed, possibly
     involving data supplied by the \term{format arguments} that 
     accompanied the \term{format string}.  \Seefun{format}.
     \gexample{In \f{"~D base 10 = ~8R"}, the character
     	       sequences `\f{~D}' and `\f{~8R}' are format directives.}
  2. the conceptual category of all \term{format directives}\meaning{1}
     which use the same dispatch character.
     \gexample{Both \f{"~3d"} and \f{"~3,'0D"} are valid uses of the
	       `\f{~D}' format directive.}

\gentry{format string} \Noun\
  a \term{string} which can contain both ordinary text and \term{format directives},
  and which is used in conjunction with \term{format arguments} to describe how 
  text output should be formatted by certain functions, such as \funref{format}.

\gentry{free declaration} \Noun\
  a declaration that is not a \term{bound declaration}.
  \Seemisc{declare}.
 
\gentry{fresh} \Adjective\ 
  1. (of an \term{object} \term{yielded} by a \term{function})
     having been newly-allocated by that \term{function}.
     (The caller of a \term{function} that returns a \term{fresh} \term{object}
      may freely modify the \term{object} without fear that such modification will
      compromise the future correct behavior of that \term{function}.)
  2. (of a \term{binding} for a \term{name})
     newly-allocated; not shared with other \term{bindings} for that \term{name}.

\gentry{freshline} \Noun\
  a conceptual operation on a \term{stream}, implemented by \thefunction{fresh-line}
  and by the \term{format directive} \f{~\&}, which advances the display position
  to the beginning of the next line (as if a \term{newline} had been typed, or 
  \thefunction{terpri} had been called)
  unless the \term{stream} is already known to be positioned at the beginning of a line.
  Unlike \term{newline}, \term{freshline} is not a \term{character}.

\gentry{funbound} \pronounced{\Stress{ef}unba\.und} \Noun\ (of a \term{function name})
  not \term{fbound}.

\gentry{function} \Noun\
  %% 6.2.2 26
  1. an \term{object} representing code,
     which can be \term{called} with zero or more \term{arguments},
     and which produces zero or more \term{values}.
  2. an \term{object} \oftype{function}.

\gentry{function block name} \Noun\ (of a \term{function name})
  The \term{symbol} that would be used as the name of an \term{implicit block}
  which surrounds the body of a \term{function} having that \term{function name}.
  If the \term{function name} is a \term{symbol}, its \term{function block name} is
  the \term{function name} itself.
  If the \term{function name} is a \term{list} whose \term{car} is \misc{setf}
  and whose \term{cadr} is a \term{symbol}, its \term{function block name} is 
  the \term{symbol} that is the \term{cadr} of the \term{function name}.
  An \term{implementation} which supports additional kinds of \term{function names}
  must specify for each how the corresponding \term{function block name} is computed.

\gentry{function cell} \Noun\ \Traditional\ (of a \term{symbol})
  The \term{place} which holds the \term{definition} of the
  global \term{function} \term{binding}, if any, named by that \term{symbol},
  and which is \term{accessed} by \funref{symbol-function}.
  \Seeterm{cell}.

\gentry{function designator} \Noun\
  a \term{designator} for a \term{function}; that is,
  an \term{object} that denotes a \term{function}
  and that is one of:
      a \term{symbol} (denoting the \term{function} named by that \term{symbol}
                       in the \term{global environment}),
   or a \term{function} (denoting itself).
  The consequences are undefined if 
  a \term{symbol} is used as a \term{function designator} but
  it does not have a global definition as a \term{function},
  or it has a global definition as a \term{macro} or a \term{special form}.
  \SeetermAlso{extended function designator}.

\gentry{function form} \Noun\
  a \term{form} that is a \term{list} and that has a first element 
  which is the \term{name} of a \term{function} to be called on
  \term{arguments} which are the result of \term{evaluating} subsequent
  elements of the \term{function form}.
 
\gentry{function name} \Noun\ (in an \term{environment})
  A \term{symbol} or a \term{list} \f{(setf \i{symbol})} 
  that is the \term{name} of a \term{function} in that \term{environment}.
%   \editornote{KMP: I think that in many (but obviously not all) cases where
% 	           `function name' is used, `operator name' might be intended.
% 		   I'll be looking for such cases later, but if readers happen
% 		   to notice any of these, they should feel free to mark them.}%!!!
% !!! Moon: Not always with respect to an environment, see e.g., function block name.
%           Also, can sometimes name a macro or special operator or be fbound.

\gentry{functional evaluation} \Noun\ 
  the process of extracting a \term{functional value} from a \term{function name}
%Added for Moon:
  or a \term{lambda expression}.
  The evaluator performs \term{functional evaluation} 
       implicitly when it encounters a \term{function name} 
%Added for Moon:
 	or a \term{lambda expression}
        in the \term{car} of a \term{compound form}, 
    or explicitly when it encounters a \specref{function} \term{special form}.
  Neither a use of a \term{symbol} as a \term{function designator} nor a
  use of \thefunction{symbol-function} to extract the \term{functional value}
  of a \term{symbol} is considered a \term{functional evaluation}.

\gentry{functional value} \Noun\ 
  1. (of a \term{function name} $N$ in an \term{environment} $E$)
     The \term{value} of the \term{binding} named $N$
     in the \term{function} \term{namespace} for \term{environment} $E$;
%!!! Moon: Wrong.  Function cell only holds global binding.
     that is, the contents of the \term{function cell} named $N$ in 
     \term{environment} $E$.
  2. (of an \term{fbound} \term{symbol} $S$)
     the contents of the \term{symbol}'s \term{function cell}; that is,
     the \term{value} of the \term{binding} named $S$
     in the \term{function} \term{namespace} of the \term{global environment}.
     (A \term{name} that is a \term{macro name} in the \term{global environment}
      or is a \term{special operator} might or might not be \term{fbound}.
%!!! Moon: Isn't this ["might or might not be fbound"] contrary to CLtL?
%          I don't have the book here, so I didn't check.
      But if $S$ is such a \term{name} and is \term{fbound}, the specific
      nature of its \term{functional value} is \term{implementation-dependent};
      in particular, it might or might not be a \term{function}.)

\gentry{further compilation} \Noun\ 
  \term{implementation-dependent} compilation beyond \term{minimal compilation}.
  Further compilation is permitted to take place at \term{run time}.
  \gexample{Block compilation and generation of machine-specific instructions
            are examples of further compilation.}  

\indextab{G}

\gentry{general} \Adjective\ (of an \term{array})
  having \term{element type} \typeref{t},
   and consequently able to have any \term{object} as an \term{element}.

\gentry{generalized boolean} \Noun\ 
  an \term{object} used as a truth value, where the symbol~\nil\ 
  represents \term{false} and all other \term{objects} represent \term{true}.
  \Seeterm{boolean}.

\gentry{generalized instance} \Noun\ (of a \term{class})
  an \term{object} the \term{class} of which is either that \term{class} itself,
  or some subclass of that \term{class}.  (Because of the correspondence between
  types and classes, the term ``generalized instance of $X$''
  implies ``object of type $X$'' and in cases where $X$ is a \term{class} 
  (or \term{class name}) the reverse is also true.
  The former terminology emphasizes the view of $X$ as a \term{class}
  while the latter emphasizes the view of $X$ as a \term{type specifier}.)

\gentry{generalized reference} \Noun\
  a reference to a location storing an \term{object} as if to a \term{variable}.
  (Such a reference can be either to \term{read} or \term{write} the location.)
  \Seesection\GeneralizedReference.  See also \term{place}.

\gentry{generalized synonym stream} \Noun\ (with a \term{synonym stream symbol})
  1. (to a \term{stream}) 
     a \term{synonym stream} to the \term{stream},
     or a \term{composite stream} which has as a target 
     a \term{generalized synonym stream} to the \term{stream}.
  2. (to a \term{symbol})
     a \term{synonym stream} to the \term{symbol},
     or a \term{composite stream} which has as a target 
     a \term{generalized synonym stream} to the \term{symbol}.

\gentry{generic function} \Noun\
  a \term{function} whose behavior depends on the \term{classes} or
  identities of the arguments supplied to it and whose parts include, among
  other things, a set of \term{methods}, a \term{lambda list}, and a
  \term{method combination} type.

\gentry{generic function lambda list} \Noun\
  A \term{lambda list} that is used to describe data flow into a \term{generic function}.
  \Seesection\GFLambdaLists.

\gentry{gensym} \Noun\ \Traditional\ 
  an \term{uninterned} \term{symbol}.
  \Seefun{gensym}.

%!!! Needs work. -kmp 25-Oct-90
\gentry{global declaration} \Noun\ 
  a \term{form} that makes certain kinds of information about 
  code globally available; that is, a \funref{proclaim} \term{form} 
  or a \macref{declaim} \term{form}.

\gentry{global environment} \Noun\ 
  that part of an \term{environment} that contains \term{bindings}
  with \term{indefinite scope} and \term{indefinite extent}.
 
\gentry{global variable} \Noun\
  a \term{dynamic variable} or a \term{constant variable}.%Is this really right?

\gentry{glyph} \Noun\ 
  a visual representation.
  \gexample{Graphic characters have associated glyphs.}

\gentry{go} \Verb\ 
  to transfer control to a \term{go point}.
  \Seespec{go}.

\gentry{go point}
  one of possibly several \term{exit points} that are \term{established} 
  by \specref{tagbody} (or other abstractions, such as \macref{prog}, 
  which are built from \specref{tagbody}).

\gentry{go tag} \Noun\ 
  the \term{symbol} or \term{integer} that, within the \term{lexical scope} 
  of a \specref{tagbody} \term{form}, names an \term{exit point}
  \term{established} by that \specref{tagbody} \term{form}.

\gentry{graphic} \Adjective\ (of a \term{character})
  being a ``printing'' or ``displayable'' \term{character} 
  that has a standard visual representation
  as a single \term{glyph}, such as \f{A} or \f{*} or \f{=}.
  \term{Space} is defined to be \term{graphic}.
  Of the \term{standard characters}, all but \term{newline} are \term{graphic}.
  \Seeterm{non-graphic}.

\indextab{H}

\gentry{handle} \Verb\ (of a \term{condition} being \term{signaled})
  to perform a non-local transfer of control, terminating the ongoing
  \term{signaling} of the \term{condition}.

\gentry{handler} \Noun\ 
  %I'm expecting that we might have a need for other kinds of handlers. -kmp 31-Dec-90
  a \term{condition handler}.

\gentry{hash table} \Noun\ 
  an \term{object} \oftype{hash-table}, 
  which provides a mapping from \term{keys} to \term{values}.

\gentry{home package} \Noun\ (of a \term{symbol})
  the \term{package}, if any, which is contents of the \term{package cell} 
  of the \term{symbol}, and which dictates how the \term{Lisp printer} 
  prints the \term{symbol} when it is not \term{accessible} in the
  \term{current package}. (\term{Symbols} which have \nil\ in their
  \term{package cell} are said to have no \term{home package}, and also
  to be \term{apparently uninterned}.)

\indextab{I}                           

\gentry{I/O customization variable} \Noun\
  one of the \term{stream variables} in \thenextfigure, 
  or some other (\term{implementation-defined}) \term{stream variable}
      that is defined by the \term{implementation} 
      to be an \term{I/O customization variable}.

\showthree{Standardized I/O Customization Variables}{
*debug-io*&*error-io*&query-io*\cr
*standard-input*&*standard-output*&*trace-output*\cr
}

\gentry{identical} \Adjective\ 
  the \term{same} under \funref{eq}.

\gentry{identifier} \Noun\        
  1. a \term{symbol} used to identify or to distinguish \term{names}. 
  2. a \term{string} used the same way.            
 
\gentry{immutable} \Adjective\
  not subject to change, either because no \term{operator} is provided which is
  capable of effecting such change or because some constraint exists which 
  prohibits the use of an \term{operator} that might otherwise be capable of
  effecting such a change.  Except as explicitly indicated otherwise,
  \term{implementations} are not required to detect attempts to modify
  \term{immutable} \term{objects} or \term{cells}; the consequences of attempting
  to make such modification are undefined.
  \gexample{Numbers are immutable.}

\gentry{implementation} \Noun\ 
  a system, mechanism, or body of \term{code} that implements the semantics of \clisp.

\gentry{implementation limit} \Noun\ 
  a restriction imposed by an \term{implementation}.
 
\gentry{implementation-defined} \Adjective\ 
  \term{implementation-dependent}, but required by this specification to be
  defined by each \term{conforming implementation} and to be documented by 
  the corresponding implementor.
%When this was moved to this position from far away, it became redundant. -kmp 14-Nov-91
% %I added this after asking Quinquevirate if they thought I should.
% %No one objected, and RPG thought it was a good idea. -kmp 17-Oct-90
%   A \term{conforming implementation} is required to document its treatment of each 
%   item in this specification which is marked \term{implementation-defined}.
 
\gentry{implementation-dependent} \Adjective\ 
  describing a behavior or aspect of \clisp\ which has been deliberately left
  unspecified, that might be defined in some \term{conforming implementations} 
  but not in others, and whose details may differ between \term{implementations}.
%I added this after asking Quinquevirate if they thought I should.
%No one objected, and RPG thought it was a good idea. -kmp 17-Oct-90
  A \term{conforming implementation} is encouraged (but not required) to 
  document its treatment of each item in this specification which is
  marked \term{implementation-dependent}, although in some cases
  such documentation might simply identify the item as ``undefined.''
  
\gentry{implementation-independent} \Adjective\ 
  used to identify or emphasize a behavior or aspect of \clisp\ which does 
  not vary between \term{conforming implementations}.

\gentry{implicit block} \Noun\ 
 a \term{block} introduced by a \term{macro form} 
 rather than by an explicit \specref{block} \term{form}.

\gentry{implicit compilation} \Noun\ 
 \term{compilation} performed during \term{evaluation}.

\gentry{implicit progn} \Noun\ 
  an ordered set of adjacent \term{forms} appearing in another
  \term{form}, and defined by their context in that \term{form}
  to be executed as if within a \specref{progn}.

\gentry{implicit tagbody} \Noun\ 
  an ordered set of adjacent \term{forms} and/or \term{tags} 
  appearing in another \term{form}, and defined by their context 
  in that \term{form} to be executed as if within a \specref{tagbody}.

\gentry{import} \TransitiveVerb\ (a \term{symbol} into a \term{package})
  to make the \term{symbol} be \term{present} in the \term{package}.

\gentry{improper list} \Noun\ 
  a \term{list} which is not a \term{proper list}:  
  a \term{circular list} or a \term{dotted list}.
 
\gentry{inaccessible} \Adjective\ 
  not \term{accessible}.
 
\gentry{indefinite extent} \Noun\ 
  an \term{extent} whose duration is unlimited.
  \gexample{Most Common Lisp objects have indefinite extent.}
 
\gentry{indefinite scope} \Noun\ 
  \term{scope} that is unlimited.
 
\gentry{indicator} \Noun\ 
  a \term{property indicator}.

\gentry{indirect instance} \Noun\ (of a \term{class} $C\sub 1$)
  an \term{object} of \term{class} $C\sub 2$, 
  where $C\sub 2$ is a \term{subclass} of $C\sub 1$.
  \gexample{An integer is an indirect instance of the class \typeref{number}.}

\gentry{inherit} \TransitiveVerb\ 
  1. to receive or acquire a quality, trait, or characteristic; 
     to gain access to a feature defined elsewhere.
  2. (a \term{class}) to acquire the structure and behavior defined
     by a \term{superclass}.
  3. (a \term{package}) to make \term{symbols} \term{exported} by another
     \term{package} \term{accessible} by using \funref{use-package}.
 
\issue{KMP-COMMENTS-ON-SANDRA-COMMENTS:X3J13-MAR-92}
\gentry{initial pprint dispatch table} \Noun\
  \thevalueof{*print-pprint-dispatch*} at the time the \term{Lisp image} is started.
\endissue{KMP-COMMENTS-ON-SANDRA-COMMENTS:X3J13-MAR-92}

\issue{WITH-STANDARD-IO-SYNTAX-READTABLE:X3J13-MAR-91}
\gentry{initial readtable} \Noun\
  \thevalueof{*readtable*} at the time the \term{Lisp image} is started.
\endissue{WITH-STANDARD-IO-SYNTAX-READTABLE:X3J13-MAR-91}

\issue{PLIST-DUPLICATES:ALLOW}
\gentry{initialization argument list} \Noun\ 
% a \term{proper list} of \term{keyword/value pairs} 
% (of initialization argument \term{names} and \term{values})
  a \term{property list} of initialization argument \term{names} and \term{values}
  used in the protocol for initializing and reinitializing \term{instances} of \term{classes}.
  \Seesection\ObjectCreationAndInit.
\endissue{PLIST-DUPLICATES:ALLOW}
 
\gentry{initialization form} \Noun\ 
  a \term{form} used to supply the initial \term{value} for a \term{slot}
  or \term{variable}.
  \gexample{The initialization form for a slot in a \macref{defclass} form
            is introduced by the keyword \kwd{initform}.}

\gentry{input} \Adjective\ (of a \term{stream})
  supporting input operations (\ie being a ``data source'').
  An \term{input} \term{stream} might also be an \term{output} \term{stream},
  in which case it is sometimes called a \term{bidirectional} \term{stream}.
  \Seefun{input-stream-p}.

\gentry{instance} \Noun\ 
  1. a \term{direct instance}.
  2. a \term{generalized instance}.
  3. an \term{indirect instance}.

\gentry{integer} \Noun\ 
  an \term{object} \oftype{integer}, which represents a mathematical integer.

\gentry{interactive stream} \Noun\ 
  a \term{stream} on which it makes sense to perform interactive querying.
  \Seesection\InteractiveStreams.

%!!! The usage "interning a symbol" is used but not described here.
%     e.g., see the type entry for KEYWORD.
\gentry{intern} \TransitiveVerb\ 
  1. (a \term{string} in a \term{package})
     to look up the \term{string} in the \term{package}, 
     returning either a \term{symbol} with that \term{name}
     which was already \term{accessible} in the \term{package}
     or a newly created \term{internal symbol} of the \term{package} 
     with that \term{name}.
  2. \Idiomatic\ generally, to observe a protocol whereby objects which 
     are equivalent or have equivalent names under some predicate defined
     by the protocol are mapped to a single canonical object.

\gentry{internal symbol} \Noun\ (of a \term{package})
  a symbol which is \term{accessible} in the \term{package},
  but which is not an \term{external symbol} of the \term{package}.

\gentry{internal time} \Noun\
  \term{time}, represented as an \term{integer} number of \term{internal time units}.
  \term{Absolute} \term{internal time} is measured as an offset 
  from an arbitrarily chosen, \term{implementation-dependent} base.
  \Seesection\InternalTime.

%% 25.4.1 21
\gentry{internal time unit} \Noun\ 
  a unit of time equal to $1/n$ of a second, 
  for some \term{implementation-defined} \term{integer} value of $n$.
  \Seevar{internal-time-units-per-second}.

\gentry{interned} \Adjective\ \Traditional\ 
  1. (of a \term{symbol}) \term{accessible}\meaning{3} in
     any \term{package}.
  2. (of a \term{symbol} in a specific \term{package}) 
     \term{present} in that \term{package}.

\gentry{interpreted function} \Noun\ 
  a \term{function} that is not a \term{compiled function}.
  (It is possible for there to be a \term{conforming implementation} which
   has no \term{interpreted functions}, but a \term{conforming program}
   must not assume that all \term{functions} are \term{compiled functions}.)

\gentry{interpreted implementation} \Noun\
  an \term{implementation} that uses an execution strategy for 
  \term{interpreted functions} that does not involve a one-time semantic
  analysis pre-pass, and instead uses ``lazy'' (and sometimes repetitious)
  semantic analysis of \term{forms} as they are encountered during execution.

\gentry{interval designator} \Noun\ (of \term{type} $T$)
  an ordered pair of \term{objects} that describe a \term{subtype} of $T$
  by delimiting an interval on the real number line.
  \Seesection\IntervalDesignators.

\gentry{invalid} \Noun, \Adjective\
  1. \Noun\
     a possible \term{constituent trait} of a \term{character}
     which if present signifies that the \term{character} 
     cannot ever appear in a \term{token} 
     except under the control of a \term{single escape} \term{character}.
     For details, \seesection\ConstituentChars.
  2. \Adjective\ (of a \term{character})
     being a \term{character} that has \term{syntax type} \term{constituent}
     in the \term{current readtable} and that has the 
     \term{constituent trait} \term{invalid}\meaning{1}.
     \Seefigure\ConstituentTraitsOfStdChars.

\issue{DOTIMES-IGNORE:X3J13-MAR91}
\gentry{iteration form} \Noun\
  a \term{compound form} whose \term{operator} is named in \thenextfigure,
  or a \term{compound form} that has an \term{implementation-defined} \term{operator}
     and that is defined by the \term{implementation} to be an \term{iteration form}.

\displaythree{Standardized Iteration Forms}{
do&do-external-symbols&dotimes\cr
do*&do-symbols&loop\cr
do-all-symbols&dolist&\cr
}

% Moon: Is this correct? I think WITH variables in LOOP are not iteration variables.
% KMP: Looks right to me. See issue DOTIMES-IGNORE.
\gentry{iteration variable} \Noun\
  a \term{variable} $V$, the \term{binding} for which was created by an
  \term{explicit use} of $V$ in an \term{iteration form}.
\endissue{DOTIMES-IGNORE:X3J13-MAR91}

\indextab{K}

\gentry{key} \Noun\ 
  an \term{object} used for selection during retrieval. 
  \Seeterm{association list}, \term{property list}, and \term{hash table}.
  Also, \seesection\SequenceConcepts.
 
\gentry{keyword} \Noun\ 
  1. a \term{symbol} the \term{home package} of which is \thepackage{keyword}.
  2. any \term{symbol}, usually but not necessarily in \thepackage{keyword},
     that is used as an identifying marker in keyword-style argument passing.
     \Seemisc{lambda}.
  3. \Idiomatic\ a \term{lambda list keyword}.

\gentry{keyword parameter} \Noun\
  A \term{parameter} for which a corresponding keyword \term{argument}
  is optional.  (There is no such thing as a required keyword \term{argument}.)
  If the \term{argument} is not supplied, a default value is used.
  \SeetermAlso{supplied-p parameter}.

\issue{PLIST-DUPLICATES:ALLOW}
\gentry{keyword/value pair} \Noun\ 
  two successive \term{elements} (a \term{keyword} and a \term{value}, 
  respectively) of a \term{property list}.
\endissue{PLIST-DUPLICATES:ALLOW}
 
\indextab{L}
 
\gentry{lambda combination} \Noun\ \Traditional\ 
  a \term{lambda form}.

\gentry{lambda expression} \Noun\ 
  a \term{list} which can be used in place of a \term{function name} in 
  certain contexts to denote a \term{function} by directly describing its
  behavior rather than indirectly by referring to the name of an
  \term{established} \term{function}; its name derives from the fact that its
  first element is the \term{symbol} \f{lambda}.
  \Seemisc{lambda}.
 
\gentry{lambda form} \Noun\ 
  a \term{form} that is a \term{list} and that has a first element
  which is a \term{lambda expression} representing a \term{function}
  to be called on \term{arguments} which are the result of \term{evaluating}
  subsequent elements of the \term{lambda form}.

\gentry{lambda list} \Noun\ 
  a \term{list} that specifies a set of \term{parameters} 
  (sometimes called \term{lambda variables})
  and a protocol for receiving \term{values} for those \term{parameters};
  that is,
  an \term{ordinary lambda list},
  an \term{extended lambda list},
  or a \term{modified lambda list}.

\gentry{lambda list keyword} \Noun\ 
  a \term{symbol} whose \term{name} begins with \term{ampersand}
  and that is specially recognized in a \term{lambda list}.
  Note that no \term{standardized} \term{lambda list keyword} 
  is in \thepackage{keyword}.
 
\gentry{lambda variable} \Noun\ 
  a \term{formal parameter}, used to emphasize the \term{variable}'s
  relation to the \term{lambda list} that \term{established} it.
 
\gentry{leaf} \Noun\ 
  1. an \term{atom} in a \term{tree}\meaning{1}.
  2. a terminal node of a \term{tree}\meaning{2}.
 
\gentry{leap seconds} \Noun\
  additional one-second intervals of time that are occasionally inserted 
  into the true calendar by official timekeepers as a correction similar 
  to ``leap years.''  All \clisp\ \term{time} representations ignore 
  \term{leap seconds}; every day is assumed to be exactly 86400 seconds 
  long.

\gentry{left-parenthesis} \Noun\
  the \term{standard character} ``\f{(}'',
  that is variously called
      ``left parenthesis''
   or ``open parenthesis''
  \Seefigure\StdCharsThree.

\gentry{length} \Noun\ (of a \term{sequence})
  the number of \term{elements} in the \term{sequence}.
  (Note that if the \term{sequence} is a \term{vector} with a 
   \term{fill pointer}, its \term{length} is the same as the 
   \term{fill pointer} even though the total allocated size of
   the \term{vector} might be larger.)

\gentry{lexical binding} \Noun\ 
  a \term{binding} in a \term{lexical environment}.

\gentry{lexical closure} \Noun\ 
  a \term{function} that, when invoked on \term{arguments}, executes
  the body of a \term{lambda expression} in the \term{lexical environment} 
  that was captured at the time of the creation of the \term{lexical closure},
  augmented by \term{bindings} of the \term{function}'s \term{parameters}
  to the corresponding \term{arguments}.
 
\gentry{lexical environment} \Noun\ 
  that part of the \term{environment} that contains \term{bindings}
  whose names have \term{lexical scope}. A \term{lexical environment} 
  contains, among other things:
%!!! Moon: [re "among other things"] scary!
     ordinary \term{bindings} of \term{variable} \term{names} to \term{values},
     lexically \term{established} \term{bindings} of \term{function names}
        to \term{functions},
     \term{macros},
     \term{symbol macros},
     \term{blocks},
     \term{tags},
  and
     \term{local declarations} (\seemisc{declare}).

\gentry{lexical scope} \Noun\ 
  \term{scope} that is limited to a spatial or textual region within the
  establishing \term{form}.
%!!! Moon: [re "names" in this example] "bindings"?
  \gexample{The names of parameters to a function normally are lexically scoped.}

\gentry{lexical variable} \Noun\ 
  a \term{variable} the \term{binding} for which is in the
  \term{lexical environment}.

%!!! KMP wonders if the "Lisp xxx" terms shouldn't be renamed to not require 
%    the use of the prefix "Lisp".

%!!! Moon: Too long?
%    KMP: Maybe I'll separate out into a concept section.
\gentry{Lisp image} \Noun\
  a running instantiation of a \clisp\ \term{implementation}.
  A \term{Lisp image} is characterized by a single address space in which any
  \term{object} can directly refer to any another in conformance with this specification,
  and by a single, common, \term{global environment}.
  (External operating systems sometimes call this a 
       ``core image,''
       ``fork,''
       ``incarnation,'' 
       ``job,''
    or ``process.''  Note however, that the issue of a ``process'' in such 
    an operating system is technically orthogonal to the issue of a \term{Lisp image}
    being defined here.  Depending on the operating system, a single ``process'' 
    might have multiple \term{Lisp images}, and multiple ``processes'' might reside
    in a single \term{Lisp image}.  Hence, it is the idea of a fully shared address
    space for direct reference among all \term{objects} which is the defining
    characteristic.  Note, too, that two ``processes'' which have a communication 
    area that permits the sharing of some but not all \term{objects} are considered
    to be distinct \term{Lisp images}.)

\gentry{Lisp printer} \Noun\ \Traditional\ 
  the procedure that prints the character representation of an
  \term{object} onto a \term{stream}. (This procedure is implemented
  by \thefunction{write}.)
 
\gentry{Lisp read-eval-print loop} \Noun\ \Traditional\ 
  an endless loop that \term{reads}\meaning{2} a \term{form},
  \term{evaluates} it,
  and prints (\ie \term{writes}\meaning{2}) the results.
  In many \term{implementations},
  the default mode of interaction with \clisp\ during program development
  is through such a loop.

\gentry{Lisp reader} \Noun\ \Traditional\ 
  the procedure that parses character representations of \term{objects}
  from a \term{stream}, producing \term{objects}.
  (This procedure is implemented by \thefunction{read}.)
  %!!! KMP wants more words about the readtable here.
 
\gentry{list} \Noun\ 
  1. a chain of \term{conses} in which the \term{car} of each
     \term{cons} is an \term{element} of the \term{list}, 
     and the \term{cdr} of each \term{cons} is either the next
     link in the chain or a terminating \term{atom}.  
     \SeetermAlso{proper list},
	    \term{dotted list}, 
         or \term{circular list}.
  2. the \term{type} that is the union of \typeref{null} and \typeref{cons}.

\gentry{list designator} \Noun\
  a \term{designator} for a \term{list} of \term{objects}; that is,
  an \term{object} that denotes a \term{list} 
  and that is one of:
       a \term{non-nil} \term{atom} 
         (denoting a \term{singleton} \term{list} 
          whose \term{element} is that \term{non-nil} \term{atom})
       or a \term{proper list} (denoting itself).

\gentry{list structure} \Noun\ (of a \term{list})
  the set of \term{conses} that make up the \term{list}.
  Note that while the \term{car}\meaning{1b} component of each such \term{cons}
  is part of the \term{list structure}, 
  the \term{objects} that are \term{elements} of the \term{list}
  (\ie the \term{objects} that are the \term{cars}\meaning{2} of each \term{cons}
   in the \term{list})
  are not themselves part of its \term{list structure}, 
  even if they are \term{conses},
  except in the (\term{circular}\meaning{2})
  case where the \term{list} 
  actually contains one of its \term{tails} as an \term{element}.
  (The \term{list structure} of a \term{list} is sometimes redundantly 
   referred to as its ``top-level list structure'' in order to emphasize
   that any \term{conses} that are \term{elements} of the \term{list} 
   are not involved.)

\gentry{literal} \Adjective\ (of an \term{object})
  referenced directly in a program rather than being computed by the program;
  that is,
  appearing as data in a \specref{quote} \term{form}, 
  or, if the \term{object} is a \term{self-evaluating object},
  appearing as unquoted data.
  \gexample{In the form \f{(cons "one" '("two"))}, 
            the expressions \f{"one"}, \f{("two")}, and \f{"two"}
            are literal objects.}

\gentry{load} \TransitiveVerb\ (a \term{file})
  to cause the \term{code} contained in the \term{file} to be \term{executed}.
  \Seefun{load}.

\gentry{load time} \Noun\
  the duration of time that the loader is \term{loading} \term{compiled code}.

\gentry{load time value} \Noun\ 
  an \term{object} referred to in \term{code} by a \specref{load-time-value} 
  \term{form}.  The \term{value} of such a \term{form} is some specific
  \term{object} which can only be computed in the run-time \term{environment}.
  In the case of \term{file} \term{compilation}, the \term{value} is
  computed once as part of the process of \term{loading} the \term{compiled file},
  and not again.  \Seespec{load-time-value}.

\gentry{loader} \Noun\
  a facility that is part of Lisp and that \term{loads} a \term{file}.
  \Seefun{load}.

\gentry{local declaration} \Noun\ 
  an \term{expression} which may appear only in specially designated
  positions of certain \term{forms}, and which provides information about
  the code contained within the containing \term{form}; 
  that is, a \misc{declare} \term{expression}.

\gentry{local precedence order} \Noun\ (of a \term{class})
  a \term{list} consisting of the \term{class} followed by its
  \term{direct superclasses} in the order mentioned in the defining
  \term{form} for the \term{class}.
 
\gentry{local slot} \Noun\ (of a \term{class})
  a \term{slot} \term{accessible} in only one \term{instance}, 
  namely the \term{instance} in which the \term{slot} is allocated.

% Or maybe... {Request for comment sent to Moon. -kmp 28-Feb-91}
%
% \gentry{local slot} \Noun\ 
%   1. (of an \term{instance}) a \term{slot} which is allocated in and \term{accessible}
%      to just that \term{instance}.
%   2. (of a \term{class}) a \term{slot} which is allocated anew for each 
%      \term{generalized instance} of the \term{class}.

\gentry{logical block} \Noun\
  a conceptual grouping of related output used by the \term{pretty printer}.
  \Seemac{pprint-logical-block} and \secref\DynamicControlofOutput.

\gentry{logical host} \Noun\
  an \term{object} of \term{implementation-dependent} nature 
  that is used as the representation of a ``host'' in a \term{logical pathname},
  and that has an associated set of translation rules for converting
  \term{logical pathnames} belonging to that host into \term{physical pathnames}.
  \Seesection\LogicalPathnames.

\gentry{logical host designator} \Noun\
  a \term{designator} for a \term{logical host}; that is,
  an \term{object} that denotes a \term{logical host} 
  and that is one of:
       a \term{string} (denoting the \term{logical host} that it names),
    or a \term{logical host} (denoting itself).
  (Note that because the representation of a \term{logical host} 
   is \term{implementation-dependent},
   it is possible that an \term{implementation} might represent 
   a \term{logical host} as the \term{string} that names it.)

\gentry{logical pathname} \Noun\ 
  an \term{object} \oftype{logical-pathname}.

\gentry{long float} \Noun\ 
  an \term{object} \oftype{long-float}.

\gentry{loop keyword} \Noun\ \Traditional\
  a symbol that is a specially recognized part of the syntax of 
  an extended \macref{loop} \term{form}.  Such symbols are recognized by their
  \term{name} (using \funref{string=}), not by their identity; as such, they
  may be in any package.  A \term{loop keyword} is not a \term{keyword}.

\gentry{lowercase} \Adjective\ (of a \term{character})
     being among \term{standard characters} corresponding to
     the small letters \f{a} through \f{z},
  or being some other \term{implementation-defined} \term{character}
      that is defined by the \term{implementation} to be \term{lowercase}.
  \Seesection\CharactersWithCase.

\indextab{M}
 
\gentry{macro} \Noun\ 
  1. a \term{macro form}
  2. a \term{macro function}.
  3. a \term{macro name}.
 
\gentry{macro character} \Noun\ 
  a \term{character} which, when encountered by the \term{Lisp reader} 
  in its main dispatch loop, introduces a \term{reader macro}\meaning{1}.
  (\term{Macro characters} have nothing to do with \term{macros}.)

\gentry{macro expansion} \Noun\ 
  1. the process of translating a \term{macro form} into another
     \term{form}.
  2. the \term{form} resulting from this process.
 
\gentry{macro form} \Noun\ 
%!!! JonL thinks "stands for" is "shaky"
  a \term{form} that stands for another \term{form} 
  (\eg for the purposes of abstraction, information hiding, 
       or syntactic convenience);
  that is, 
    either a \term{compound form} whose first element is a \term{macro name}, 
    or     a \term{form} that is a \term{symbol} that names a 
             \term{symbol macro}.

\gentry{macro function} \Noun\ 
  a \term{function} of two arguments, a \term{form} and an 
  \term{environment}, that implements \term{macro expansion} by
  producing a \term{form} to be evaluated in place of the original
  argument \term{form}.
 
\gentry{macro lambda list} \Noun\
  an \term{extended lambda list} used in \term{forms} that \term{establish}
  \term{macro} definitions, such as \macref{defmacro} and \macref{macrolet}.
  \Seesection\MacroLambdaLists.

\gentry{macro name} \Noun\ 
  a \term{name} for which \funref{macro-function} returns \term{true}
  and which when used as the first element of a \term{compound form}
  identifies that \term{form} as a \term{macro form}.
 
\gentry{macroexpand hook} \Noun\
  the \term{function} that is \thevalueof{*macroexpand-hook*}.

\gentry{mapping} \Noun\ 
  1. a type of iteration in which a \term{function} is successively 
     applied to \term{objects} taken from corresponding entries in
     collections such as \term{sequences} or \term{hash tables}.
  2. \Mathematics\ a relation between two sets in which each element of the
     first set (the ``domain'') is assigned one element of the second
     set (the ``range'').

\gentry{metaclass} \Noun\ 
  1. a \term{class} whose instances are \term{classes}.
  2. (of an \term{object}) the \term{class} of the \term{class} of the \term{object}.
 
\gentry{Metaobject Protocol} \Noun\
  one of many possible descriptions of how a \term{conforming implementation}
  might implement various aspects of the \CLOS.  This description is beyond
  the scope of this document, and no \term{conforming implementation} is
  required to adhere to it except as noted explicitly in this specification.
  Nevertheless, its existence helps to establish normative practice, 
  and implementors with no reason to diverge from it are encouraged to
  consider making their \term{implementation} adhere to it where possible.
  It is described in detail in \MetaObjectProtocol.

\gentry{method} \Noun\ 
  an \term{object} that is part of a \term{generic function} and which
  provides information about how that \term{generic function} should 
  behave when its \term{arguments} are \term{objects} of certain
  \term{classes} or with certain identities.
 
\gentry{method combination} \Noun\ 
  1. generally, the composition of a set of \term{methods} to produce an
     \term{effective method} for a \term{generic function}.
  2. an object \oftype{method-combination}, which represents the details
     of how the \term{method combination}\meaning{1} for one or more 
     specific \term{generic functions} is to be performed.
 
\gentry{method-defining form} \Noun\ 
  a \term{form} that defines a \term{method} for a \term{generic function},
  whether explicitly or implicitly.  
  \Seesection\IntroToGFs.

\gentry{method-defining operator} \Noun\
  an \term{operator} corresponding to a \term{method-defining} \term{form}.
  \Seefigure\StdMethDefOps.

\gentry{minimal compilation} \Noun\
  actions the \term{compiler} must take at compile time. 
  \Seesection\CompilationSemantics.

\gentry{modified lambda list} \Noun\ 
  a list resembling an \term{ordinary lambda list} in form and purpose, 
  but which deviates in syntax or functionality from the definition of an 
  \term{ordinary lambda list}.
  \Seeterm{ordinary lambda list}.
  \gexample{\macref{deftype} uses a modified lambda list.}

\gentry{most recent} \Adjective\
  innermost;
  that is, having been \term{established} (and not yet \term{disestablished})
%!!! Moon: This next line looks out of order.  Maybe reorganize this description.
%          Put it before the parens? No. Hmm...
  more recently than any other of its kind.

\gentry{multiple escape} \Noun, \Adjective\
  1. \Noun\ the \term{syntax type} of a \term{character} 
     that is used in pairs  to indicate that the enclosed \term{characters}
     are to be treated as \term{alphabetic}\meaning{2} \term{characters}
     with their \term{case} preserved.
     For details, \seesection\MultipleEscapeChar.
  2. \Adjective\ (of a \term{character}) 
     having the \term{multiple escape} \term{syntax type}.
  3. \Noun\ a \term{multiple escape}\meaning{2} \term{character}.
     (In the \term{standard readtable},
      \term{vertical-bar} is a \term{multiple escape} \term{character}.)

\gentry{multiple values} \Noun\ 
  1. more than one \term{value}.
     \gexample{The function \funref{truncate} returns multiple values.}
  2. a variable number of \term{values}, possibly including zero or one.
     \gexample{The function \funref{values} returns multiple values.}
  3. a fixed number of values other than one.
     \gexample{The macro \macref{multiple-value-bind} is among the few
	       operators in \clisp\ which can detect and manipulate
 	       multiple values.}

\indextab{N}
 
%!!! Moon: also, of a keyword argument or initarg.
\gentry{name} \Noun, \TransitiveVerb\ 
  1. \Noun\ an \term{identifier} by which an \term{object},
     a \term{binding}, or an \term{exit point}
%or "tag"
     is referred to by association using a \term{binding}.
  2. \TransitiveVerb\ to give a \term{name} to.
  3. \Noun\ (of an \term{object} having a name component) 
     the \term{object} which is that component.  
     \gexample{The string which is a symbol's name is returned
	       by \funref{symbol-name}.}
  4. \Noun\ (of a \term{pathname})
     a. the name component, returned by \funref{pathname-name}.
     b. the entire namestring, returned by \funref{namestring}.
  5. \Noun\ (of a \term{character})
     a \term{string} that names the \term{character}
     and that has \term{length} greater than one.
     (All \term{non-graphic} \term{characters} are required to have \term{names}
      unless they have some \term{implementation-defined} \term{attribute}
      which is not \term{null}.  Whether or not other \term{characters}
      have \term{names} is \term{implementation-dependent}.)

\gentry{named constant} \Noun\ 
  a \term{variable} that is defined by \clisp,
				    by the \term{implementation},
  				 or by user code (\seemac{defconstant})
  to always \term{yield} the same \term{value} when \term{evaluated}.
  \gexample{The value of a named constant may not be changed
            by assignment or by binding.}

%!!! Moon: "kind" is not defined, but I thin kthis is wrong.  Especially if "kind"
%          is similar to "type".  Also, should relate to "environment" and section 3.1.
\gentry{namespace} \Noun\ 
  1. \term{bindings} whose denotations are restricted to a particular kind.
     \gexample{The bindings of names to tags is the tag namespace.}
  2. any \term{mapping} whose domain is a set of \term{names}.
     \gexample{A package defines a namespace.}
 
\issue{PATHNAME-HOST-PARSING:RECOGNIZE-LOGICAL-HOST-NAMES}
\gentry{namestring} \Noun\ 
  a \term{string} that represents a \term{filename}
  using either the \term{standardized} notation for naming \term{logical pathnames}
         described in \secref\LogPathNamestrings,
     or some \term{implementation-defined} notation for naming a \term{physical pathname}.
\endissue{PATHNAME-HOST-PARSING:RECOGNIZE-LOGICAL-HOST-NAMES}

\gentry{newline} \Noun\
  the \term{standard character} \NewlineChar,
  notated for the \term{Lisp reader} as \f{\#\\Newline}.

\gentry{next method} \Noun\ 
  the next \term{method} to be invoked with respect to a given
  \term{method} for a particular set of arguments or argument
  \term{classes}.  
%JonL thinks we should add "under standardized method combinations"?
%Moon thinks maybe not.  He says this is about as good as we should expect to get
% given the space in the glossary.
  \Seesection\ApplyMethCombToSortedMethods.
 
\gentry{nickname} \Noun\ (of a \term{package})
  one of possibly several \term{names} that can be used to refer to
  the \term{package} but that is not the primary \term{name} 
  of the \term{package}.

\gentry{nil} \Noun\ 
  the \term{object} that is at once
        the \term{symbol} named \f{"NIL"} in \thepackage{common-lisp},
        the \term{empty list},
        the \term{boolean} (or \term{generalized boolean}) representing \term{false},
    and the \term{name} of the \term{empty type}.
%!!! Should other things be here like use of NIL to represent 
%    null lexical environment (should there be a term "environment designator"?),
%    use of NIL as an input/output stream designator, etc.?
 
\gentry{non-atomic} \Adjective\ 
  being other than an \term{atom}; \ie being a \term{cons}.

\gentry{non-constant variable} \Noun\
  a \term{variable} that is not a \term{constant variable}.

\gentry{non-correctable} \Adjective\ (of an \term{error})
  not intentionally \term{correctable}.
  (Because of the dynamic nature of \term{restarts},
   it is neither possible nor generally useful to completely prohibit
   an \term{error} from being \term{correctable}.
   This term is used in order to express an intent that no special effort
   should be made by \term{code} signaling an \term{error} to make
   that \term{error} \term{correctable}; 
   however, there is no actual requirement on \term{conforming programs}
   or \term{conforming implementations} imposed by this term.)

\gentry{non-empty} \Adjective\
  having at least one \term{element}.

% Replaced by "distinct"
% \gentry{non-eq} \Adjective\
%   not \term{eq}.

\gentry{non-generic function} \Noun\ 
  a \term{function} that is not a \term{generic function}.

\gentry{non-graphic} \Adjective\ (of a \term{character})
  not \term{graphic}.
  \Seesection\GraphicChars.

\gentry{non-list} \Noun, \Adjective\ 
  other than a \term{list}; \ie a \term{non-nil} \term{atom}.

\gentry{non-local exit} \Noun\ 
  a transfer of control (and sometimes \term{values}) to 
  an \term{exit point} for reasons other than a \term{normal return}.
  \gexample{The operators \specref{go}, \specref{throw}, 
	    and \specref{return-from} cause a non-local exit.}

\gentry{non-nil} \Noun, \Adjective\ 
  not \nil.  Technically, any \term{object} which is not \nil\ can be
  referred to as \term{true}, but that would tend to imply a unique view
  of the \term{object} as a \term{generalized boolean}.
  Referring to such an \term{object} as \term{non-nil} avoids this implication.

%!!! Moon: Is this right? Is it a non-empty environment, 
%          or any environment other than NIL?  Where is this term used?
\gentry{non-null lexical environment} \Noun\ 
  a \term{lexical environment} that has additional information not present in
  the \term{global environment}, such as one or more \term{bindings}.

\gentry{non-simple} \Adjective\
  not \term{simple}.

%!!! Make a glossary term for "constituent character"?
%!!! What about "extended token"?
\gentry{non-terminating} \Adjective\ (of a \term{macro character})
  being such that it is treated as a constituent \term{character}
  when it appears in the middle of an extended token.
  \Seesection\ReaderAlgorithm.

\gentry{non-top-level form} \Noun\ 
  a \term{form} that, by virtue of its position as a \term{subform}
  of another \term{form}, is not a \term{top level form}.
  \Seesection\TopLevelForms.

\gentry{normal return} \Noun\ 
  the natural transfer of control and \term{values} which occurs after
  the complete \term{execution} of a \term{form}.

\gentry{normalized} \Adjective, \ANSI, \IEEE\ (of a \term{float})
  conforming to the description of ``normalized'' as described by {\IEEEFloatingPoint}.
  \Seeterm{denormalized}.

\gentry{null} \Adjective, \Noun\ 
  1. \Adjective\ 
     a. (of a \term{list}) having no \term{elements}: empty.  \Seeterm{empty list}.
     b. (of a \term{string}) having a \term{length} of zero.
	(It is common, both within this document and in observed spoken behavior,
         to refer to an empty string by an apparent definite reference,
         as in ``the \term{null} \term{string}'' even though no attempt is made to
	 \term{intern}\meaning{2} null strings.  The phrase 
         ``a \term{null} \term{string}'' is technically more correct, 
	 but is generally considered awkward by most Lisp programmers.  
	 As such, the phrase ``the \term{null} \term{string}'' 
         should be treated as an indefinite reference in all cases 
	 except for anaphoric references.)
      c. (of an \term{implementation-defined} \term{attribute} of a \term{character})
	 An \term{object} to which the value of that \term{attribute} defaults 
	 if no specific value was requested.
  2. \Noun\ an \term{object} \oftype{null} (the only such \term{object} being \nil).

%!!! Moon: Is this correct?  has global bindings.  what about declarations?
\gentry{null lexical environment} \Noun\ 
  the \term{lexical environment} which has no \term{bindings}.

\gentry{number} \Noun\
  an \term{object} \oftype{number}.

\gentry{numeric} \Adjective\ (of a \term{character})
     being one of the \term{standard characters} \f{0} through \term{9},
  or being some other \term{graphic} \term{character}
     defined by the \term{implementation} to be \term{numeric}.

\indextab{O}

\gentry{object} \Noun\ 
  1. any Lisp datum. 
     \gexample{The function \funref{cons} creates an object which refers
               to two other objects.}
  2. (immediately following the name of a \term{type})
     an \term{object} which is of that \term{type}, used to emphasize that the
     \term{object} is not just a \term{name} for an object of that \term{type}
     but really an \term{element} of the \term{type} in cases where \term{objects}
     of that \term{type} (such as \typeref{function} or \typeref{class}) are commonly
     referred to by \term{name}.
     \gexample{The function \funref{symbol-function} takes a function name 
	       and returns a function object.}

\gentry{object-traversing} \Adjective\ 
  operating in succession on components of an \term{object}.
  \gexample{The operators \funref{mapcar}, \funref{maphash}, 
	    \macref{with-package-iterator} and \funref{count}
 	    perform object-traversing operations.}

\gentry{open} \Adjective, \TransitiveVerb\ (a \term{file})
  1. \TransitiveVerb\ to create and return a \term{stream} to the \term{file}.
  2. \Adjective\ (of a \term{stream})
     having been \term{opened}\meaning{1}, but not yet \term{closed}.

\gentry{operator} \Noun\ 
  1. a \term{function}, \term{macro}, or \term{special operator}.
  2. a \term{symbol} that names
     such a \term{function}, \term{macro}, or \term{special operator}.
  3. (in a \specref{function} \term{special form})
     the \term{cadr} of the \specref{function} \term{special form}, which 
     might be either an \term{operator}\meaning{2} or a \term{lambda expression}.
%Barmar thinks that since operator(2) says "symbol" this last is unnecessary and confusing.
%KMP disagrees because "lambda expression" is added here.
  4. (of a \term{compound form})
     the \term{car} of the \term{compound form}, which might be 
     either an \term{operator}\meaning{2}
%Moon asked whether this was permitted to include function objects,
%but I don't think so.  Barmar and Barrett also expressed that sentiment
%in mail to Quinquevirate (subject line "#'#.#'car").  
%No one took the alternate viewpoint. -kmp 14-Nov-91
     or a \term{lambda expression}, and which is never \f{(setf \term{symbol})}.

\gentry{optimize quality} \Noun\ 
  one of several aspects of a program that might be optimizable by
  certain compilers.  Since optimizing one such quality
  might conflict with optimizing another, relative priorities for
  qualities can be established in an \declref{optimize} \term{declaration}.
  The \term{standardized} \term{optimize qualities} are
    \f{compilation-speed} (speed of the compilation process), 
\issue{OPTIMIZE-DEBUG-INFO:NEW-QUALITY}
    \f{debug} (ease of debugging),
\endissue{OPTIMIZE-DEBUG-INFO:NEW-QUALITY}%
    \f{safety} (run-time error checking),
    \f{space} (both code size and run-time space),
  and
    \f{speed} (of the object code).
  \term{Implementations} may define additional \term{optimize qualities}.

\gentry{optional parameter} \Noun\
  A \term{parameter} for which a corresponding positional \term{argument}
  is optional.  If the \term{argument} is not supplied, a default value
  is used.  \SeetermAlso{supplied-p parameter}.

\gentry{ordinary function} \Noun\ 
  a \term{function} that is not a \term{generic function}.

\gentry{ordinary lambda list} \Noun\ 
  the kind of \term{lambda list} used by \misc{lambda}.
  \Seeterm{modified lambda list} and \term{extended lambda list}.
  \gexample{\macref{defun} uses an ordinary lambda list.}

\gentry{otherwise inaccessible part} \Noun\ (of an \term{object}, $O\sub{1}$)
  an \term{object}, $O\sub{2}$, which would be made \term{inaccessible} if 
  $O\sub{1}$ were made \term{inaccessible}.  (Every \term{object} is an
  \term{otherwise inaccessible part} of itself.)

\gentry{output} \Adjective\ (of a \term{stream})
  supporting output operations (\ie being a ``data sink'').
  An \term{output} \term{stream} might also be an \term{input} \term{stream},
  in which case it is sometimes called a \term{bidirectional} \term{stream}.
  \Seefun{output-stream-p}.

\indextab{P}
 
\gentry{package} \Noun\ 
  an \term{object} \oftype{package}.

%!!! Moon: "interned" means "accessible" according to the glossary, but I thought
%          a symbol was supposed to be "present" in its home package.  Maybe I'm wrong.
\gentry{package cell} \Noun\ \Traditional\ (of a \term{symbol})
  The \term{place} in a \term{symbol} that holds one of
  possibly several \term{packages} in which the \term{symbol} is 
  \term{interned}, called the \term{home package}, or which holds
  \nil\ if no such \term{package} exists or is known.
  \Seefun{symbol-package}.

\gentry{package designator} \Noun\
  a \term{designator} for a \term{package}; that is,
  an \term{object} that denotes a \term{package}
  and that is one of:
      a \term{\packagenamedesignator} 
		      (denoting the \term{package} that has the \term{string}
		       that it designates as its \term{name} 
		       or as one of its \term{nicknames}),
   or a \term{package} (denoting itself).

\gentry{package marker} \Noun\ 
  a character which is used in the textual notation for a symbol 
  to separate the package name from the symbol name, and which
  is \term{colon} in the \term{standard readtable}.
  \Seesection\CharacterSyntax.

% \gentry{package name designator} \Noun\
%   a \term{designator} for the \term{name} of a \term{package}; that is,
%   an \term{object} that denotes a \term{string} 
%   and that is one of:
%        a \term{character} (denoting a \term{singleton} \term{string}
% 			   that has the \term{character} as its only \term{element}),
%        a \term{symbol} (denoting the \term{string} that is its \term{name}),
%     or a \term{string} (denoting itself).

\gentry{package prefix} \Noun\ 
  a notation preceding the \term{name} of a \term{symbol} in text that is
  processed by the \term{Lisp reader}, which uses a \term{package} \term{name}
  followed by one or more \term{package markers}, and which indicates that
  the symbol is looked up in the indicated \term{package}.

%!!! Moon: Is DO-ALL-SYMBOLS really -required- not to find symbols in unregistered packages?
\gentry{package registry} \Noun\
  A mapping of \term{names} to \term{package} \term{objects}.
  It is possible for there to be a \term{package} \term{object} which is not
  in this mapping; such a \term{package} is called an \term{unregistered package}.
  \term{Operators} such as \funref{find-package} consult this mapping in order
  to find a \term{package} from its \term{name}.
  \term{Operators} such as \macref{do-all-symbols}, \funref{find-all-symbols}, 
  and \funref{list-all-packages} operate only on \term{packages} that exist
  in the \term{package registry}.

\gentry{pairwise} \Adverb\ (of an adjective on a set)
  applying individually to all possible pairings of elements of the set.
  \gexample{The types $A$, $B$, and $C$ are pairwise disjoint if 
            $A$ and $B$ are disjoint,
            $B$ and $C$ are disjoint, and
            $A$ and $C$ are disjoint.}

%!!! This needs work but should be better than nothing for now. -kmp 13-Feb-92
\gentry{parallel} \Adjective\ \Traditional\ (of \term{binding} or \term{assignment})
  done in the style of \macref{psetq}, \macref{let}, or \macref{do};
  that is, first evaluating all of the \term{forms} that produce \term{values},
  and only then \term{assigning} or \term{binding} the \term{variables} (or \term{places}).
  Note that this does not imply traditional computational ``parallelism'' 
  since the \term{forms} that produce \term{values} are evaluated \term{sequentially}.
  \Seeterm{sequential}.

\gentry{parameter} \Noun\ 
  1. (of a \term{function})
     a \term{variable} in the definition of a \term{function}
       which takes on the \term{value} of a corresponding \term{argument}
       (or of a \term{list} of corresponding arguments)
       to that \term{function} when it is called,
     or
       which in some cases is given a default value because there
       is no corresponding \term{argument}.
  2. (of a \term{format directive})
%Moon thinks "as data flow" is awkward.  I don't know what to substitute. -kmp 15-Nov-91
     an \term{object} received as data flow by a \term{format directive}
     due to a prefix notation within the \term{format string} at the 
     \term{format directive}'s point of use.
     \Seesection\FormattedOutput.
     \gexample{In \f{"~3,'0D"}, the number \f{3} and the character
	       \f{\#\\0} are parameters to the \f{~D} format directive.}

\gentry{parameter specializer} \Noun\ 
  1. (of a \term{method}) an \term{expression} which constrains the
     \term{method} to be applicable only to \term{argument} sequences
     in which the corresponding \term{argument} matches the
     \term{parameter specializer}.
  2. a \term{class},
     or a \term{list} \f{(eql \term{object})}.

\gentry{parameter specializer name} \Noun\ 
  1. (of a \term{method} definition) an expression used in code to
     name a \term{parameter specializer}. 
     \Seesection\IntroToMethods.
  2. a \term{class},
\issue{CLASS-OBJECT-SPECIALIZER:AFFIRM}
     a \term{symbol} naming a \term{class},
\endissue{CLASS-OBJECT-SPECIALIZER:AFFIRM}
     or a \term{list} \f{(eql \term{form})}.

\gentry{pathname} \Noun\ 
  an \term{object} \oftype{pathname}, which is a structured representation 
  of the name of a \term{file}.  A \term{pathname} has six components:
    a ``host,''
    a ``device,''
    a ``directory,''
    a ``name,''
    a ``type,'' and
    a ``version.''

\gentry{pathname designator} \Noun\
  a \term{designator} for a \term{pathname}; that is,
  an \term{object} that denotes a \term{pathname}
  and that is one of:
\issue{PATHNAME-LOGICAL:ADD}
       a \term{pathname} \term{namestring} 
\issue{PATHNAME-HOST-PARSING:RECOGNIZE-LOGICAL-HOST-NAMES}
%          (denoting the corresponding \term{pathname};
% 	  unless explicitly specified otherwise,
%           only a \term{physical pathname} \term{namestring} is required
%           to be recognized by an \term{implementation} as 
%           a \term{pathname designator}---whether
%           or not a \term{logical pathname} \term{namestring} is
%           permitted as a \term{pathname designator} is 
%           \term{implementation-defined}),
           (denoting the corresponding \term{pathname}),
\endissue{PATHNAME-HOST-PARSING:RECOGNIZE-LOGICAL-HOST-NAMES}
\endissue{PATHNAME-LOGICAL:ADD}
       a \term{stream associated with a file} 
%% 23.1.2 32
         (denoting the \term{pathname} used to open the \term{file};
	  this may be, but is not required to be, the actual name of the \term{file}),
    or a \term{pathname} (denoting itself).
  \Seesection\OpenAndClosedStreams.

% \editornote{KMP: `Pervasive' is still used, but isn't it supposed to be getting phased out?}
% 
% \gentry{pervasive} \Noun\
%   ... needs a definition...

\gentry{physical pathname} \Noun\
  a \term{pathname} that is not a \term{logical pathname}.

\editornote{KMP: Still need to reconcile some confusion in the uses of ``generalized
		 reference'' and ``place.'' I think one was supposed to refer to the
	         abstract concept, and the other to an object (a form), but the usages
		 have become blurred.}
%Moon: I have no opinion.

\gentry{place} \Noun\ 
  1. a \term{form} which is suitable for use as a \term{generalized reference}.
  2. the conceptual location referred to by such a \term{place}\meaning{1}.

\gentry{plist} \pronounced{\Stress{p\harde}\stress{list}} \Noun\ 
  a \term{property list}.

\gentry{portable} \Adjective\ (of \term{code})
  required to produce equivalent results and observable side effects
  in all \term{conforming implementations}.

\gentry{potential copy} \Noun\ (of an \term{object} $O\sub 1$ subject to constriants)
  an \term{object} $O\sub 2$ that if the specified constraints are satisfied
  by $O\sub 1$ without any modification might or might not be \term{identical}
  to $O\sub 1$, or else that must be a \term{fresh} \term{object} that
  resembles a \term{copy} of $O\sub 1$ except that it has been modified as
  necessary to satisfy the constraints.

\gentry{potential number} \Noun\ 
  A textual notation that might be parsed by the \term{Lisp reader} 
  in some \term{conforming implementation} as a \term{number} 
  but is not required to be parsed as a \term{number}.
  No \term{object} is a \term{potential number}---either an \term{object} is
  a \term{number} or it is not.
  \Seesection\PotentialNumbersAsTokens.

\gentry{pprint dispatch table} \Noun\ 
  an \term{object} that can be \thevalueof{*print-pprint-dispatch*} 
  and hence can control how \term{objects} are printed when
  \varref{*print-pretty*} is \term{true}.
  \Seesection\PPrintDispatchTables.

\gentry{predicate} \Noun\ 
  a \term{function} that returns a \term{generalized boolean}
  as its first value.

\gentry{present} \Noun\
  1. (of a \term{feature} in a \term{Lisp image})
     a state of being that is in effect if and only if the \term{symbol} 
     naming the \term{feature} is an \term{element} of the \term{features list}.
  2. (of a \term{symbol} in a \term{package})
     being accessible in that \term{package} directly,
     rather than being inherited from another \term{package}.

\gentry{pretty print} \TransitiveVerb\ (an \term{object})
  to invoke the \term{pretty printer} on the \term{object}.

% Waters observes:
%  In most places the text talks about the pretty printer either being used or not.
%  However, it is not all that clear what the pretty printer per se is.  In the
%  description of *print-pprint-dispatch* I think that it makes it pretty clear that
%  what pretty printer means is that printing is controled by *print-pprint-dispatch*.
%  And in fact I believe that this is in fact all it means.  You can put a value in
%  *print-pprint-dispatch* that makes pretty printing look exactly like 
%  non-pretty-printing after all.  Therefore, I think it would be an overall
%  clarification to say more often that setting *print-pretty* to true means having
%  *print-pprint-dispatch* control printing---nothing more and nothing less.
\gentry{pretty printer} \Noun\ 
  the procedure that prints the character representation of an
  \term{object} onto a \term{stream} when the \term{value} of
  \varref{*print-pretty*} is \term{true}, 
  and that uses layout techniques (\eg indentation) that
  tend to highlight the structure of the \term{object} in a way that
  makes it easier for human readers to parse visually.
  \Seevar{*print-pprint-dispatch*} and \secref\PPrinter.

\gentry{pretty printing stream} \Noun\ 
  a \term{stream} that does pretty printing.  Such streams are created by
  \thefunction{pprint-logical-block} as a link between the output stream 
  and the logical block.

\gentry{primary method} \Noun\ 
  a member of one of two sets of \term{methods} 
  (the set of \term{auxiliary methods} is the other)
  that form an exhaustive partition of the set of \term{methods}
  on the \term{method}'s \term{generic function}.
  How these sets are determined is dependent on the \term{method combination} type;
  \seesection\IntroToMethods.

\gentry{primary value} \Noun\ (of \term{values} resulting from the
				   \term{evaluation} of a \term{form})
  the first \term{value}, if any, or else \nil\ if there are no \term{values}.
  \gexample{The primary value returned by \funref{truncate} is an
            integer quotient, truncated toward zero.}

\gentry{principal} \Adjective\ (of a value returned by a \clisp\ \term{function} that
			        implements a mathematically irrational or transcendental 
		                function defined in the complex domain)
  of possibly many (sometimes an infinite number of) correct values for the
  mathematical function, being the particular \term{value} which the corresponding
  \clisp\ \term{function} has been defined to return.

\gentry{print name} \Noun\ \Traditional\ (usually of a \term{symbol})
  a \term{name}\meaning{3}.

\gentry{printer control variable} \Noun\ 
  a \term{variable} whose specific purpose is to control some action
  of the \term{Lisp printer}; that is, one of the \term{variables}
  in \figref\StdPrinterControlVars,
  or else some \term{implementation-defined} \term{variable} which is
     defined by the \term{implementation} to be a \term{printer control variable}.

\issue{PRINT-READABLY-BEHAVIOR:CLARIFY}
\gentry{printer escaping} \Noun\
  The combined state of the \term{printer control variables}
  \varref{*print-escape*} and \varref{*print-readably*}.
  If the value of either \varref{*print-readably*} or \varref{*print-escape*} is \term{true}, 
  then \newterm{printer escaping} is ``enabled'';
  otherwise (if the values of both \varref{*print-readably*} and \varref{*print-escape*}
	     are \term{false}), 
  then \term{printer escaping} is ``disabled''.
\endissue{PRINT-READABLY-BEHAVIOR:CLARIFY}

\gentry{printing} \Adjective\ (of a \term{character})
  being a \term{graphic} \term{character} other than \term{space}.

\gentry{process} \TransitiveVerb\ (a \term{form} by the \term{compiler})
  to perform \term{minimal compilation}, determining the time of 
  evaluation for a \term{form}, and possibly \term{evaluating} that
  \term{form} (if required).

\gentry{processor} \Noun, \ANSI\
  an \term{implementation}.

\gentry{proclaim} \TransitiveVerb\ (a \term{proclamation})
  to \term{establish} that \term{proclamation}.

\gentry{proclamation} \Noun\ 
  a \term{global declaration}.

\gentry{prog tag} \Noun\ \Traditional\ 
  a \term{go tag}.

\gentry{program} \Noun\ \Traditional\ 
  \clisp\ \term{code}.

\gentry{programmer} \Noun\
  an active entity, typically a human, that writes a \term{program},
  and that might or might not also be a \term{user} of the \term{program}.

\gentry{programmer code} \Noun\ 
  \term{code} that is supplied by the programmer;
  that is, \term{code} that is not \term{system code}.

\gentry{proper list} \Noun\ 
  A \term{list} terminated by the \term{empty list}.
  (The \term{empty list} is a \term{proper list}.)
  \Seeterm{improper list}.

\gentry{proper name} \Noun\ (of a \term{class})
  a \term{symbol} that \term{names} the \term{class} whose \term{name}
  is that \term{symbol}. 
  \Seefuns{class-name} and \funref{find-class}.
 
\gentry{proper sequence} \Noun\ 
  a \term{sequence} which is not an \term{improper list}; 
  that is, a \term{vector} or a \term{proper list}.
 
% Moon: proper subtype -- I don't understand the parenthesized phrase, perhaps not
%  only because I believe types have members, not elements.
\gentry{proper subtype} \Noun\ (of a \term{type})
  a \term{subtype} of the \term{type} which is not the \term{same} \term{type}
  as the \term{type} (\ie its \term{elements} are a ``proper subset'' of the 
  \term{type}).
 
\gentry{property} \Noun\ (of a \term{property list})
  1. a conceptual pairing of a \term{property indicator} and its
     associated \term{property value} on a \term{property list}.
  2. a \term{property value}.
%%Barmar says he's never heard this usage. -kmp -11-Dec-90
% 3. a \term{property indicator}.

\gentry{property indicator} \Noun\ (of a \term{property list}) 
  the \term{name} part of a \term{property}, used as a \term{key}
  when looking up a \term{property value} on a \term{property list}. 
 
\gentry{property list} \Noun\ 
\issue{PLIST-DUPLICATES:ALLOW}
  1.  a \term{list} containing an even number of \term{elements} that are
      alternating \term{names}  (sometimes called \term{indicators} 
      or \term{keys}) and \term{values} (sometimes called \term{properties}).
      When there is more than one \term{name} and \term{value} pair with
      the \term{identical} \term{name} in a \term{property list},
      the first such pair determines the \term{property}.
\endissue{PLIST-DUPLICATES:ALLOW}
  2. (of a \term{symbol})
     the component of the \term{symbol} containing a \term{property list}.

\issue{PLIST-DUPLICATES:ALLOW}
% \gentry{property list format} \Noun\ 
%   the form of a property list, having an even number of \term{elements}
%   that are alternating \term{names} and \term{values}, but without the
%   implied restriction that no \term{keys} be duplicated.
%   \gexample{When \keyref{key} is used in a lambda list, the corresponding keyword
% 	    arguments are specified in property list format.}
\endissue{PLIST-DUPLICATES:ALLOW}

\gentry{property value} \Noun\ (of a \term{property indicator} on 
				  a \term{property list})
  the \term{object} associated with the \term{property indicator}
  on the \term{property list}.

\gentry{purports to conform} \Verb\
  makes a good-faith claim of conformance.  
  This term expresses intention to conform, regardless of whether the
  goal of that intention is realized in practice.  
  For example, language implementations have been known to have bugs,
  and while an \term{implementation} of this specification with bugs
  might not be a \term{conforming implementation}, it can still
  \term{purport to conform}.  This is an important distinction in
  certain specific cases; \eg \seevar{*features*}.

\indextab{Q}

\gentry{qualified method} \Noun\ 
  a \term{method} that has one or more \term{qualifiers}.

%Maybe this should be called a method qualifier? -kmp
\gentry{qualifier} \Noun\ (of a \term{method} for a \term{generic function})
  one of possibly several \term{objects} used to annotate the \term{method} 
  in a way that identifies its role in the \term{method combination}.  
  The \term{method combination} \term{type} determines 
   how many \term{qualifiers} are permitted for each \term{method}, 
   which \term{qualifiers} are permitted,
  and
   the semantics of those \term{qualifiers}.

%qualifier list?

\gentry{query I/O} \Noun\ 
  the \term{bidirectional} \term{stream}
  that is the \term{value} of \thevariable{*query-io*}.

\gentry{quoted object} \Noun\ 
  an \term{object} which is the second element of a
  \specref{quote} \term{form}.

\indextab{R}
 
\gentry{radix} \Noun\
  an \term{integer} between 2 and 36, inclusive, which can be used 
  to designate a base with respect to which certain kinds of numeric
  input or output are performed.  
%% 13.2.0 20
  (There are $n$ valid digit characters for any given \term{radix} $n$,
   and those digits are the first $n$ digits in the sequence
   \f{0}, \f{1}, $\ldots$, \f{9}, \f{A}, \f{B}, $\ldots$, \f{Z},
   which have the weights   
   \f{0}, \f{1}, $\ldots$, \f{9}, \f{10}, \f{11}, $\ldots$, \f{35},
   respectively.
   Case is not significant in parsing numbers of radix greater
   than \f{10}, so ``9b8a'' and ``9B8A'' denote the same \term{radix}
   \f{16} number.)

\gentry{random state} \Noun\ 
  an \term{object} \oftype{random-state}.

\gentry{rank} \Noun\ 
  a non-negative \term{integer} indicating the number of
  \term{dimensions} of an \term{array}.
 
\gentry{ratio} \Noun\ 
  an \term{object} \oftype{ratio}.

\gentry{ratio marker} \Noun\ 
  a character which is used in the textual notation for a \term{ratio}
  to separate the numerator from the denominator, and which
  is \term{slash} in the \term{standard readtable}.
  \Seesection\CharacterSyntax.

\gentry{rational} \Noun\ 
  an \term{object} \oftype{rational}.
 
\gentry{read} \TransitiveVerb\ 
\issue{IGNORE-USE-TERMINOLOGY:VALUE-ONLY}
  1. (a \term{binding} or \term{slot} or component)
     to obtain the \term{value} of the \term{binding} or \term{slot}.
\endissue{IGNORE-USE-TERMINOLOGY:VALUE-ONLY}
  2. (an \term{object} from a \term{stream})
     to parse an \term{object} from its representation on the \term{stream}.

%% There were no actual uses of this. -kmp 18-Jan-92
% \gentry{read macro} \Noun\ \Traditional\
%   a \term{reader macro}.

%% KMP: Maybe...
% \gentry{readable} \Adjective\ (of the printed representation of an \term{object})
%   printed \term{readably}.

\gentry{readably} \Adverb\ (of a manner of printing an \term{object} $O\sub 1$)
  in such a way as to permit the \term{Lisp Reader} to later \term{parse}
  the printed output into an \term{object} $O\sub 2$ that is \term{similar} to $O\sub 1$.

\gentry{reader} \Noun\
  1. a \term{function} that \term{reads}\meaning{1} a \term{variable} or \term{slot}.
  2. the \term{Lisp reader}.

\gentry{reader macro} \Noun\
  1. a textual notation introduced by dispatch on one or two \term{characters} 
     that defines special-purpose syntax for use by the \term{Lisp reader},
     and that is implemented by a \term{reader macro function}.
     \Seesection\ReaderAlgorithm.
  2. the \term{character} or \term{characters} that introduce
     a \term{reader macro}\meaning{1}; that is,
        a \term{macro character}
     or the conceptual pairing of a \term{dispatching macro character} and the
          \term{character} that follows it.
  (A \term{reader macro} is not a kind of \term{macro}.)

\gentry{reader macro function} \Noun\
  a \term{function} \term{designator} that denotes a \term{function}
  that implements a \term{reader macro}\meaning{2}.
  \Seefuns{set-macro-character} and \funref{set-dispatch-macro-character}.

\gentry{readtable} \Noun\
  an \term{object} \oftype{readtable}.

\gentry{readtable case} \Noun\
  an attribute of a \term{readtable}
  whose value is a \term{case sensitivity mode},
  and that selects the manner in which \term{characters}
       in a \term{symbol}'s \term{name} are to be treated by
            the \term{Lisp reader}
        and the \term{Lisp printer}.
  \Seesection\ReadtableCaseReadEffect\ and \secref\ReadtableCasePrintEffect.

\gentry{readtable designator} \Noun\
  a \term{designator} for a \term{readtable}; that is,
  an \term{object} that denotes a \term{readtable}
  and that is one of:
       \nil\ (denoting the \term{standard readtable}),
    or a \term{readtable} (denoting itself).

\gentry{recognizable subtype} \Noun\ (of a \term{type})
  a \term{subtype} of the \term{type} which can be reliably detected 
  to be such by the \term{implementation}.
  \Seefun{subtypep}.

\gentry{reference} \Noun, \TransitiveVerb\ 
  1. \Noun\ an act or occurrence of referring to an \term{object},
     a \term{binding}, an \term{exit point}, a \term{tag}, 
     or an \term{environment}.
%But what does "refer" mean?
  2. \TransitiveVerb\ to refer to an \term{object}, a \term{binding}, an
     \term{exit point}, a \term{tag}, or an \term{environment},
     usually by \term{name}.

\gentry{registered package} \Noun\
  a \term{package} \term{object} that is installed in the \term{package registry}.
  (Every \term{registered package} has a \term{name} that is a \term{string},
   as well as zero or more \term{string} nicknames.
   All \term{packages} that are initially specified by \clisp\ 
   or created by \funref{make-package} or \macref{defpackage}
   are \term{registered packages}.  \term{Registered packages} can be turned into
   \term{unregistered packages} by \funref{delete-package}.)

\gentry{relative} \Adjective\
  1. (of a \term{time})
     representing an offset from an \term{absolute} \term{time}
     in the units appropriate to that time.
     For example, 
     a \term{relative} \term{internal time} is the difference between
     two \term{absolute} \term{internal times}, and is measured in
     \term{internal time units}.
  2. (of a \term{pathname})
     representing a position in a directory hierarchy by motion 
     from a position other than the root, which might therefore vary.
     \gexample{The notation \f{\#P"../foo.text"} denotes a relative
	       pathname if the host file system is Unix.}
  \Seeterm{absolute}.

\gentry{repertoire} \Noun, \ISO\
  a \term{subtype} of \typeref{character}.  \Seesection\CharRepertoires.

\gentry{report} \Noun\ (of a \term{condition})
  to \term{call} \thefunction{print-object} on the \term{condition} 
  in an \term{environment} where \thevalueof{*print-escape*} is \term{false}.

\gentry{report message} \Noun\
  the text that is output by a \term{condition reporter}.

\gentry{required parameter} \Noun\
  A \term{parameter} for which a corresponding positional \term{argument}
  must be supplied when \term{calling} the \term{function}.

\gentry{rest list} \Noun\ (of a \term{function} having a \term{rest parameter})
  The \term{list} to which the \term{rest parameter} is \term{bound} on some
  particular \term{call} to the \term{function}.

\gentry{rest parameter} \Noun\
  A \term{parameter} which was introduced by \keyref{rest}.

\gentry{restart} \Noun\ 
  an \term{object} \oftype{restart}.

\gentry{restart designator} \Noun\
  a \term{designator} for a \term{restart}; that is,
  an \term{object} that denotes a \term{restart}
  and that is one of:
       a \term{non-nil} \term{symbol} 
	 (denoting the most recently established \term{active}
	  \term{restart} whose \term{name} is that \term{symbol}),
    or a \term{restart} (denoting itself).

\gentry{restart function} \Noun\
  a \term{function} that invokes a \term{restart}, as if by \funref{invoke-restart}.
  The primary purpose of a \term{restart function} is to provide an alternate
  interface. By convention, a \term{restart function} usually has the same name 
  as the \term{restart} which it invokes. \Thenextfigure\ shows a list of the
  \term{standardized} \term{restart functions}.

\displaythree{Standardized Restart Functions}{
abort&muffle-warning&use-value\cr
continue&store-value&\cr
}

\gentry{return} \TransitiveVerb\ (of \term{values})
  1. (from a \term{block}) to transfer control and \term{values} from the \term{block};
     that is, to cause the \term{block} to \term{yield} the \term{values} immediately
     without doing any further evaluation of the \term{forms} in its body.
  2. (from a \term{form}) to \term{yield} the \term{values}.

\gentry{return value} \Noun\ \Traditional\ 
  a \term{value}\meaning{1}

\gentry{right-parenthesis} \Noun\
  the \term{standard character} ``\f{)}'',
  that is variously called
      ``right parenthesis''
   or ``close parenthesis''
  \Seefigure\StdCharsThree.

%% No longer needed as a glossary term. \Seesection\RuleOfCanonRepForComplexRationals.
%%   -kmp
%
% %Moon says:
% % rule of canonical representation for complex rationals -- you forgot to say the
% % real part has to be rational.  Compare CLtL2 p.291.
% \gentry{rule of canonical representation for complex rationals} \Noun\ 
%   a requirement by \clisp\ on \term{conforming implementations} that all 
%   numbers representing mathematical complex numbers with an imaginary part 
%   of rational zero be represented by \clisp\ as \term{objects} \oftype{rational}
%   rather than as \term{objects} \oftype{complex}.

\gentry{run time} \Noun\
  1. \term{load time}
  2. \term{execution time}

\gentry{run-time compiler} \Noun\
  refers to the \funref{compile} function or to \term{implicit compilation}, 
  for which the compilation and run-time \term{environments} are maintained 
  in the same \term{Lisp image}.

\gentry{run-time definition} \Noun\
  a definition in the \term{run-time environment}.

\gentry{run-time environment} \Noun\
  the \term{environment} in which a program is \term{executed}.

\indextab{S}
 
\gentry{safe} \Adjective\ 
  1. (of \term{code})
     processed in a \term{lexical environment} where the the highest
     \declref{safety} level (\f{3}) was in effect. 
     \Seemisc{optimize}.
  2. (of a \term{call}) a \term{safe call}.

\gentry{safe call} \Noun\
  a \term{call} in which 
        the \term{call},
        the \term{function} being \term{called},
    and the point of \term{functional evaluation}
  are all \term{safe}\meaning{1} \term{code}.
  For more detailed information, \seesection\SafeAndUnsafeCalls.

\gentry{same} \Adjective\ 
  1. (of \term{objects} under a specified \term{predicate}) 
     indistinguishable by that \term{predicate}.
     \gexample{The symbol \f{car}, the string \f{"car"}, and the string \f{"CAR"}
	       are the \f{same} under \funref{string-equal}}.
  2. (of \term{objects} if no predicate is implied by context)
     indistinguishable by \funref{eql}.
     Note that \funref{eq} might be capable of distinguishing some 
     \term{numbers} and \term{characters} which \funref{eql} cannot 
     distinguish, but the nature of such, if any, 
     is \term{implementation-dependent}.
     Since \funref{eq} is used only rarely in this specification,
     \funref{eql} is the default predicate when none is mentioned explicitly.
     \gexample{The conses returned by two successive calls to \funref{cons}
	       are never the same.}
  3. (of \term{types}) having the same set of \term{elements};
     that is, each \term{type} is a \term{subtype} of the others.
     \gexample{The types specified by \f{(integer 0 1)},
				      \f{(unsigned-byte 1)},
				  and \f{bit} are the same.}

\gentry{satisfy the test} \Verb\ 
       (of an \term{object} being considered by a \term{sequence function})
  1. (for a one \term{argument} test)
     to be in a state such that the \term{function} which is the
     \param{predicate} \term{argument} to the \term{sequence function}
     returns \term{true} when given a single \term{argument} that is the
     result of calling the \term{sequence function}'s \param{key} \term{argument}
     on the \term{object} being considered.  
     \Seesection\SatisfyingTheOneArgTest.
%!!! Moon: Shouldn't the test-not predicate return false to satisfy the test?
%          Also, sometimes both arguments are run through the key,
%          e.g., search, mismatch; you're perhaps being too specific.
  2. (for a two \term{argument} test)
     to be in a state such that the two-place \term{predicate} 
     which is the \term{sequence function}'s 
     \param{test} \term{argument}
     returns \term{true} when given a first \term{argument} that 
     is
%     the result of calling the \term{sequence function}'s 
%     \param{key} \term{argument} on
     the \term{object} being considered, 
     and when given a second \term{argument}
     that is the result of calling the \term{sequence function}'s 
     \param{key} \term{argument} on an \term{element} of the
     \term{sequence function}'s \param{sequence} \term{argument} 
     which is being tested for equality;
     or to be in a state such that the \param{test-not} \term{function}
     returns \term{false} given the same \term{arguments}.
     \Seesection\SatisfyingTheTwoArgTest.

%!!! Moon: Can scope ever apply to anything but a name?
%    I think objects and environments have extent but not scope.
\gentry{scope} \Noun\ 
  the structural or textual region of code in which \term{references} 
  to an \term{object}, a \term{binding}, an \term{exit point}, 
  a \term{tag}, or an \term{environment} (usually by \term{name}) 
  can occur.

\gentry{script} \Noun\ \ISO\
  one of possibly several sets that form an \term{exhaustive partition}
  of the type \typeref{character}.  \Seesection\CharScripts.

\gentry{secondary value} \Noun\ (of \term{values} resulting from the
				   \term{evaluation} of a \term{form})
  the second \term{value}, if any, 
  or else \nil\ if there are fewer than two \term{values}.
  \gexample{The secondary value returned by \funref{truncate} is a remainder.}

\gentry{section} \Noun\
  a partitioning of output by a \term{conditional newline} on a \term{pretty printing stream}.
  \Seesection\DynamicControlofOutput.

\gentry{self-evaluating object} \Noun\
  an \term{object} that is neither a \term{symbol} nor a
% \term{compound form} => \term{cons} because Moon pointed out that
% this wrongly seemed to permit things which were conses but not valid forms.
  \term{cons}.
  If a \term{self-evaluating object} is \term{evaluated},
  it \term{yields} itself as its only \term{value}.
  \gexample{Strings are self-evaluating objects.}

\gentry{semi-standard} \Adjective\ (of a language feature)
  not required to be implemented by any \term{conforming implementation},
  but nevertheless recommended as the canonical approach in situations where
  an \term{implementation} does plan to support such a feature.
  The presence of \term{semi-standard} aspects in the language is intended
  to lessen portability problems and reduce the risk of gratuitous divergence
  among \term{implementations} that might stand in the way of future 
  standardization.

\gentry{semicolon} \Noun\
  the \term{standard character} that is called ``semicolon'' (\f{;}).
  \Seefigure\StdCharsThree.

\gentry{sequence} \Noun\ 
  1. an ordered collection of elements
  2. a \term{vector} or a \term{list}.

\gentry{sequence function} \Noun\
  one of the \term{functions} in \figref\SequenceFunctions,
  or an \term{implementation-defined} \term{function} 
     that operates on one or more \term{sequences}.
     and that is defined by the \term{implementation} to be a \term{sequence function}.

%!!! This needs work but should be better than nothing for now. -kmp 13-Feb-92
\gentry{sequential} \Adjective\ \Traditional\ (of \term{binding} or \term{assignment})
  done in the style of \macref{setq}, \macref{let*}, or \macref{do*};
  that is, interleaving the evaluation of the \term{forms} that produce \term{values}
  with the \term{assignments} or \term{bindings} of the \term{variables} (or \term{places}).
  \Seeterm{parallel}.

\gentry{sequentially} \Adverb\
  in a \term{sequential} way.

\gentry{serious condition} \Noun\ 
  a \term{condition} \oftype{serious-condition}, 
  which represents a \term{situation} that is generally sufficiently 
  severe that entry into the \term{debugger} should be expected if 
  the \term{condition} is \term{signaled} but not \term{handled}.

\gentry{session} \Noun\
  the conceptual aggregation of events in a \term{Lisp image} from the time
  it is started to the time it is terminated.

\gentry{set} \TransitiveVerb\ \Traditional\ (any \term{variable}
				     or a \term{symbol} that 
				        is the \term{name} of a \term{dynamic variable})
  to \term{assign} the \term{variable}.

\issue{SETF-METHOD-VS-SETF-METHOD:RENAME-OLD-TERMS}
\gentry{setf expander} \Noun\ 
  a function used by \macref{setf} to compute the \term{setf expansion}
  of a \term{place}.
\endissue{SETF-METHOD-VS-SETF-METHOD:RENAME-OLD-TERMS}

\issue{SETF-METHOD-VS-SETF-METHOD:RENAME-OLD-TERMS}
\gentry{setf expansion} \Noun\ 
  a set of five \term{expressions}\meaning{1} that, taken together, describe 
       how to store into a \term{place} 
   and which \term{subforms} of the macro call associated with the
       \term{place} are evaluated.
  \Seesection\SetfExpansions.
\endissue{SETF-METHOD-VS-SETF-METHOD:RENAME-OLD-TERMS}
 
\gentry{setf function} \Noun\
  a \term{function} whose \term{name} is \f{(setf \term{symbol})}.

\issue{LISP-SYMBOL-REDEFINITION-AGAIN:MORE-FIXES}
\gentry{setf function name} \Noun\ (of a \term{symbol} \param{S})
  the \term{list} \f{(setf \param{S})}.
\endissue{LISP-SYMBOL-REDEFINITION-AGAIN:MORE-FIXES}

\gentry{shadow} \TransitiveVerb\ 
  1. to override the meaning of.
     \gexample{That binding of \f{X} shadows an outer one.} 
  2. to hide the presence of.
     \gexample{That \specref{macrolet} of \f{F} shadows the
               outer \specref{flet} of \f{F}.}
  3. to replace.
     \gexample{That package shadows the symbol \f{cl:car} with
               its own symbol \f{car}.}

\gentry{shadowing symbol} \Noun\ (in a \term{package})
  an \term{element} of the \term{package}'s \term{shadowing symbols list}.

\gentry{shadowing symbols list} \Noun\ (of a \term{package})
  a \term{list}, associated with the \term{package}, 
  of \term{symbols} that are to be exempted from `symbol conflict errors'
  detected when packages are \term{used}.
  \Seefun{package-shadowing-symbols}.

\gentry{shared slot} \Noun\ (of a \term{class}) 
  a \term{slot} \term{accessible} in more than one \term{instance} 
  of a \term{class}; specifically, such a \term{slot} is \term{accessible}
  in all \term{direct instances} of the \term{class} and in those 
  \term{indirect instances} whose \term{class} does not 
  \term{shadow}\meaning{1} the \term{slot}.
 
\gentry{sharpsign} \Noun\
  the \term{standard character} that is variously called ``number sign,'' ``sharp,''
  or ``sharp sign'' (\f{\#}).
  \Seefigure\StdCharsThree.

\gentry{short float} \Noun\ 
  an \term{object} \oftype{short-float}.

\gentry{sign} \Noun\ 
  one of the \term{standard characters} ``\f{+}'' or ``\f{-}''.

\gentry{signal} \Verb\ 
  to announce, using a standard protocol, that a particular situation,
  represented by a \term{condition}, has been detected.  
  \Seesection\ConditionSystemConcepts.

\gentry{signature} \Noun\ (of a \term{method})
  a description of the \term{parameters} and
  \term{parameter specializers} for the \term{method} which 
  determines the \term{method}'s applicability for a given set of
  required \term{arguments}, and which also describes the
  \term{argument} conventions for its other, non-required 
  \term{arguments}.

\gentry{similar} \Adjective\ (of two \term{objects})
  defined to be equivalent under the \term{similarity} relationship.

\gentry{similarity} \Noun\
  a two-place conceptual equivalence predicate, 
  which is independent of the \term{Lisp image} 
  so that two \term{objects} in different \term{Lisp images} 
  can be understood to be equivalent under this predicate.
  \Seesection\LiteralsInCompiledFiles.

\gentry{simple} \Adjective\
  1. (of an \term{array}) being \oftype{simple-array}.
  2. (of a \term{character})
     having no \term{implementation-defined} \term{attributes},
     or else having \term{implementation-defined} \term{attributes}
      each of which has the \term{null} value for that \term{attribute}.

\gentry{simple array} \Noun\ 
  an \term{array} \oftype{simple-array}.

\gentry{simple bit array} \Noun\
  a \term{bit array} that is a \term{simple array};
  that is, an \term{object} of \term{type} \f{(simple-array bit)}.

\gentry{simple bit vector} \Noun\ 
  a \term{bit vector} \oftype{simple-bit-vector}.

\gentry{simple condition} \Noun\ 
  a \term{condition} \oftype{simple-condition}.

\gentry{simple general vector} \Noun\ 
  a \term{simple vector}.

\gentry{simple string} \Noun\ 
  a \term{string} \oftype{simple-string}.

%!!! Moon: "not the same as a one-dimensional simple array.
% Does the addition of the "Not all ..." thing fix that?  (Mail sent to Moon.) -kmp 14-Jan-92
\gentry{simple vector} \Noun\
  a \term{vector} \oftype{simple-vector},
  sometimes called a ``\term{simple general vector}.''
  Not all \term{vectors} that are \term{simple} are \term{simple vectors}---only
  those that have \term{element type} \typeref{t}.

\gentry{single escape} \Noun, \Adjective\
  1. \Noun\ the \term{syntax type} of a \term{character} 
     that indicates that the next \term{character} is 
     to be treated as an \term{alphabetic}\meaning{2} \term{character}
     with its \term{case} preserved.
     For details, \seesection\SingleEscapeChar.
  2. \Adjective\ (of a \term{character})
     having the \term{single escape} \term{syntax type}.
  3. \Noun\ a \term{single escape}\meaning{2} \term{character}.
     (In the \term{standard readtable},
      \term{slash} is the only \term{single escape}.)

\gentry{single float} \Noun\ 
  an \term{object} \oftype{single-float}.

\gentry{single-quote} \Noun\
  the \term{standard character} that is variously called
      ``apostrophe,''
      ``acute accent,''
      ``quote,''
   or ``single quote'' (\f{'}).
  \Seefigure\StdCharsThree.

\gentry{singleton} \Adjective\ (of a \term{sequence})
  having only one \term{element}.
  \gexample{\f{(list 'hello)} returns a singleton list.}

\gentry{situation} \Noun\ 
  the \term{evaluation} of a \term{form} in a specific \term{environment}.

\gentry{slash} \Noun\
  the \term{standard character} that is variously called
       ``solidus'' 
    or ``slash'' (\f{/}).
  \Seefigure\StdCharsThree.

%!!! Moon: too general--limit to CLOS slots. "a named component"?
\gentry{slot} \Noun\ 
  a component of an \term{object} that can store a \term{value}.

% slot option?

% Per X3J13 -kmp 5-Oct-93
\gentry{slot specifier} \Noun\
  a representation of a \term{slot} 
  that includes the \term{name} of the \term{slot} and zero or more \term{slot} options.
  A \term{slot} option pertains only to a single \term{slot}.

\gentry{source code} \Noun\ 
  \term{code} representing \term{objects} suitable for \term{evaluation}
  (\eg \term{objects} created by \funref{read}, 
       by \term{macro expansion}, 
\issue{DEFINE-COMPILER-MACRO:X3J13-NOV89}
    or by \term{compiler macro expansion}).
\endissue{DEFINE-COMPILER-MACRO:X3J13-NOV89}

\gentry{source file} \Noun\ 
  a \term{file} which contains a textual representation of \term{source code},
  that can be edited, \term{loaded}, or \term{compiled}.

\gentry{space} \Noun\
  the \term{standard character} \SpaceChar,
  notated for the \term{Lisp reader} as \f{\#\\Space}.

\gentry{special form} \Noun\ 
  a \term{list}, other than a \term{macro form}, which is a
  \term{form} with special syntax or special \term{evaluation} 
  rules or both, possibly manipulating the \term{evaluation} 
  \term{environment} or control flow or both.  The first element of
  a \term{special form} is a \term{special operator}.

\gentry{special operator} \Noun\ 
  one of a fixed set of \term{symbols}, 
  enumerated in \figref\CLSpecialOps,
  that may appear in the \term{car} of
  a \term{form} in order to identify the \term{form} as a \term{special form}.

\gentry{special variable} \Noun\ \Traditional\
  a \term{dynamic variable}.

\gentry{specialize} \TransitiveVerb\ (a \term{generic function})
  to define a \term{method} for the \term{generic function}, or in other words,
  to refine the behavior of the \term{generic function} by giving it a specific
  meaning for a particular set of \term{classes} or \term{arguments}. 
     
\gentry{specialized} \Adjective\ 
  1. (of a \term{generic function})
     having \term{methods} which \term{specialize} the \term{generic function}.
  2. (of an \term{array})
     having an \term{actual array element type}
     that is a \term{proper subtype} of \thetype{t};
     \seesection\ArrayElements.
     \gexample{\f{(make-array 5 :element-type 'bit)} makes an array of length
	       five that is specialized for bits.}

\gentry{specialized lambda list} \Noun\
  an \term{extended lambda list} used in \term{forms} that \term{establish}
  \term{method} definitions, such as \macref{defmethod}.
  \Seesection\SpecializedLambdaLists.

\gentry{spreadable argument list designator} \Noun\
  a \term{designator} for a \term{list} of \term{objects}; that is,
  an \term{object} that denotes a \term{list} 
  and that is a \term{non-null} \term{list} $L1$ of length $n$,
  whose last element is a \term{list} $L2$ of length $m$
  (denoting a list $L3$ of length $m+n-1$ whose \term{elements} are
   $L1\sub i$ for $i < n-1$ followed by $L2\sub j$ for $j < m$).
  \gexample{The list (1 2 (3 4 5)) is a spreadable argument list designator for
	    the list (1 2 3 4 5).}

\gentry{stack allocate} \TransitiveVerb\ \Traditional\ 
  to allocate in a non-permanent way, such as on a stack.  Stack-allocation
  is an optimization technique used in some \term{implementations} for
  allocating certain kinds of \term{objects} that have \term{dynamic extent}.
  Such \term{objects} are allocated on the stack rather than in the heap
  so that their storage can be freed as part of unwinding the stack rather
  than taking up space in the heap until the next garbage collection.
  What \term{types} (if any) can have \term{dynamic extent} can vary
  from \term{implementation} to \term{implementation}.  No
  \term{implementation} is ever required to perform stack-allocation.

%!!! Moon thinks this is too circular.
\gentry{stack-allocated} \Adjective\ \Traditional\ 
  having been \term{stack allocated}.

\gentry{standard character} \Noun\ 
  a \term{character} \oftype{standard-char}, which is one of a fixed set of 96
  such \term{characters} required to be present in all \term{conforming implementations}.
  \Seesection\StandardChars.

% Definitions of terms "standard function", "standard macro", and "standard special form"
% removed since they were not used anywhere, and since they were yucky anyway.
%  -kmp 15-Oct-91

%Moon: "direct instance" or "generalized instance". I think it's "direct" 
%      but don't know for sure.
%After some discussion (with subject line "standard class, standard generic function"),
%Moon and KMP think this is a technical issue which requires X3J13 vote to proceed on.
%Leaving it unchanged for now. -kmp 15-Nov-91
%Changing it to "generalized instance" on advice from Quinquevirate. -kmp 14-Feb-92
\gentry{standard class} \Noun\ 
  a \term{class} that is a \term{generalized instance} \ofclass{standard-class}.

%Moon: Same comment as for "standard class".
\gentry{standard generic function}
  a \term{function} \oftype{standard-generic-function}.

\gentry{standard input} \Noun\ 
  the \term{input} \term{stream} which is the \term{value} of the \term{dynamic variable}
  \varref{*standard-input*}.

\gentry{standard method combination} \Noun\ 
  the \term{method combination} named \typeref{standard}.

\gentry{standard object} \Noun\ 
  an \term{object} that is 
%This phrase added per Moon:
  a \term{generalized instance} 
  \ofclass{standard-object}.

\gentry{standard output} \Noun\ 
  the \term{output} \term{stream} which is the \term{value} of the \term{dynamic variable}
  \varref{*standard-output*}.

\issue{KMP-COMMENTS-ON-SANDRA-COMMENTS:X3J13-MAR-92}
\gentry{standard pprint dispatch table} \Noun\
  A \term{pprint dispatch table} that is \term{different} from 
  the \term{initial pprint dispatch table},
  that implements \term{pretty printing} as described in this specification,
  and that, unlike other \term{pprint dispatch tables},
  must never be modified by any program.
  (Although the definite reference ``the \term{standard pprint dispatch table}''
   is generally used
   within this document, it is actually \term{implementation-dependent} whether a
   single \term{object} fills the role of the \term{standard pprint dispatch table},
   or whether there might be multiple such objects, any one of which could be used on any
   given occasion where ``the \term{standard pprint dispatch table}'' is called for.
   As such, this phrase should be seen as an indefinite reference 
   in all cases except for anaphoric references.)
\endissue{KMP-COMMENTS-ON-SANDRA-COMMENTS:X3J13-MAR-92}

\issue{WITH-STANDARD-IO-SYNTAX-READTABLE:X3J13-MAR-91}
\gentry{standard readtable} \Noun\
  A \term{readtable} that is \term{different} from the \term{initial readtable},
  that implements the \term{expression} syntax defined in this specification,
  and that, unlike other \term{readtables}, must never be modified by any program.
  (Although the definite reference ``the \term{standard readtable}'' is generally used
   within this document, it is actually \term{implementation-dependent} whether a
   single \term{object} fills the role of the \term{standard readtable},
   or whether there might be multiple such objects, any one of which could be used on any
   given occasion where ``the \term{standard readtable}'' is called for.
   As such, this phrase should be seen as an indefinite reference 
   in all cases except for anaphoric references.)
\endissue{WITH-STANDARD-IO-SYNTAX-READTABLE:X3J13-MAR-91}

\gentry{standard syntax} \Noun\
  the syntax represented by the \term{standard readtable} 
  and used as a reference syntax throughout this document.
  \Seesection\TheStandardSyntax.

\gentry{standardized} \Adjective\ (of a \term{name}, \term{object}, or definition)
  having been defined by \clisp.
  \gexample{All standardized variables that are required to 
	    hold bidirectional streams have ``\f{-io*}'' in their name.}

\gentry{startup environment} \Noun\
  the \term{global environment} of the running \term{Lisp image} 
  from which the \term{compiler} was invoked.

\gentry{step} \TransitiveVerb, \Noun\ 
  1. \TransitiveVerb\ (an iteration \term{variable}) to \term{assign} the \term{variable}
     a new \term{value} at the end of an iteration, in preparation for a new iteration.
  2. \Noun\ the \term{code} that identifies how the next value in an iteration
     is to be computed.
  3. \TransitiveVerb\ (\term{code}) to specially execute the \term{code}, pausing at
     intervals to allow user confirmation or intervention, usually for debugging.

\gentry{stream} \Noun\ 
  an \term{object} that can be used with an input or output function to
  identify an appropriate source or sink of \term{characters} or 
  \term{bytes} for that operation.

\issue{CLOSED-STREAM-FUNCTIONS:ALLOW-INQUIRY}
\issue{PATHNAME-STREAM:FILES-OR-SYNONYM}
\gentry{stream associated with a file} \Noun\ 
  a \term{file stream}, or a \term{synonym stream} the \term{target} 
  of which is a \term{stream associated with a file}.
%!!! I wonder if this really needs to be said...
  Such a \term{stream} cannot be created with
      \funref{make-two-way-stream}, 
      \funref{make-echo-stream},
      \funref{make-broadcast-stream}, 
      \funref{make-concatenated-stream},
      \funref{make-string-input-stream},
   or \funref{make-string-output-stream}.
\endissue{PATHNAME-STREAM:FILES-OR-SYNONYM}
\endissue{CLOSED-STREAM-FUNCTIONS:ALLOW-INQUIRY}

\gentry{stream designator} \Noun\
  a \term{designator} for a \term{stream}; that is,
  an \term{object} that denotes a \term{stream} 
  and that is one of:
      \t\ (denoting \thevalueof{*terminal-io*}), 
      \nil\ (denoting \thevalueof{*standard-input*}
             for \term{input} \term{stream designators}
             or denoting \thevalueof{*standard-output*}
             for \term{output} \term{stream designators}),
   or a \term{stream} (denoting itself).

\gentry{stream element type} \Noun\ (of a \term{stream})
  the \term{type} of data for which the \term{stream} is specialized.
%KMP: Is there a notion of upgraded element type in this situation?
%Moon: Surely!  But there is no way for a portable program to detect it.

\gentry{stream variable} \Noun\
  a \term{variable} whose \term{value} must be a \term{stream}.

\gentry{stream variable designator} \Noun\
  a \term{designator} for a \term{stream variable}; that is,
  a \term{symbol} that denotes a \term{stream variable} 
  and that is one of:
      \t\ (denoting \varref{*terminal-io*}), 
      \nil\ (denoting \varref{*standard-input*}
             for \term{input} \term{stream variable designators}
             or denoting \varref{*standard-output*}
             for \term{output} \term{stream variable designators}),
   or some other \term{symbol} (denoting itself).

\gentry{string} \Noun\ 
  a specialized \term{vector} that is \oftype{string},
  and whose elements are \oftypes{character}.

\gentry{string designator} \Noun\
  a \term{designator} for a \term{string}; that is,
  an \term{object} that denotes a \term{string} 
  and that is one of:
       a \term{character} (denoting a \term{singleton} \term{string}
			   that has the \term{character} as its only \term{element}),
       a \term{symbol} (denoting the \term{string} that is its \term{name}),
    or a \term{string} (denoting itself).
\issue{STRING-COERCION:MAKE-CONSISTENT}
  The intent is that this term be consistent with the behavior of \funref{string};
  \term{implementations} that extend \funref{string} must extend the meaning of 
  this term in a compatible way.
\endissue{STRING-COERCION:MAKE-CONSISTENT}

\gentry{string equal} \Adjective\ 
  the \term{same} under \funref{string-equal}.

\gentry{string stream} \Noun\ 
  a \term{stream} \oftype{string-stream}.

\gentry{structure} \Noun\ 
  an \term{object} \oftype{structure-object}.
% It's really pathetic that the type structure-object 
% is not just called structure. -kmp 2-Jan-91

\gentry{structure class} \Noun\ 
%Moon: See comment for standard class.
%"instance" => "generalized instance" per Quinquevirate. -kmp 14-Feb-92
  a \term{class} that is a \term{generalized instance} \ofclass{structure-class}.

\gentry{structure name} \Noun\
  a \term{name} defined with \macref{defstruct}.
  Usually, such a \term{type} is also a \term{structure class},
%!!! Really? Must they be implementation-dependent?
  but there may be \term{implementation-dependent} situations 
  in which this is not so, if the \kwd{type} option to \macref{defstruct} is used.

\gentry{style warning} \Noun\
  a \term{condition} \oftype{style-warning}.

\gentry{subclass} \Noun\ 
  a \term{class} that \term{inherits} from another \term{class}, 
  called a \term{superclass}.
  (No \term{class} is a \term{subclass} of itself.)
 
\gentry{subexpression} \Noun\ (of an \term{expression})
  an \term{expression} that is contained within the \term{expression}. 
  (In fact, the state of being a \term{subexpression} is not an attribute 
   of the \term{subexpression}, but really an attribute of the containing
   \term{expression} since the \term{same} \term{object} can at once be
   a \term{subexpression} in one context, and not in another.)

\gentry{subform} \Noun\ (of a \term{form})
  an \term{expression} that is a \term{subexpression} of the \term{form},
  and which by virtue of its position in that \term{form} is also a
  \term{form}.
  \gexample{\f{(f x)} and \f{x}, but not \f{exit}, are subforms of
	    \f{(return-from exit (f x))}.}

\gentry{subrepertoire} \Noun\ 
  a subset of a \term{repertoire}.

\gentry{subtype} \Noun\ 
  a \term{type} whose membership is the same as or a proper subset of the
  membership of another \term{type}, called a \term{supertype}.
  (Every \term{type} is a \term{subtype} of itself.)
 
\gentry{superclass} \Noun\ 
  a \term{class} from which another \term{class} 
  (called a \term{subclass}) \term{inherits}.
  (No \term{class} is a \term{superclass} of itself.)
  \Seeterm{subclass}.
 
\gentry{supertype} \Noun\ 
  a \term{type} whose membership is the same as or a proper superset
  of the membership of another \term{type}, called a \term{subtype}.
  (Every \term{type} is a \term{supertype} of itself.)
  \Seeterm{subtype}.
 
\gentry{supplied-p parameter} \Noun\
  a \term{parameter} which recieves its \term{generalized boolean} value
  implicitly due to the presence or absence of an \term{argument} 
  corresponding to another \term{parameter} 
  (such as an \term{optional parameter} or a \term{rest parameter}).
  \Seesection\OrdinaryLambdaLists.

\gentry{symbol} \Noun\ 
  an \term{object} \oftype{symbol}.

\gentry{symbol macro} \Noun\ 
  a \term{symbol} that stands for another \term{form}.
  \Seemac{symbol-macrolet}.

% \gentry{symbol name designator} \Noun\
%   a \term{designator} for the \term{name} of a \term{symbol}; that is,
%   an \term{object} that denotes a \term{symbol} 
%   and that is one of:
%        a \term{character} (denoting a \term{singleton} \term{string}
% 			   that has the \term{character} as its only \term{element}),
%        a \term{symbol} (denoting the \term{string} that is its \term{name}),
%     or a \term{string} (denoting itself).

\gentry{synonym stream} \Noun\ 
  1. a \term{stream} \oftype{synonym-stream}, 
     which is consequently a \term{stream} that is an alias for another \term{stream},
     which is the \term{value} of a \term{dynamic variable}
     whose \term{name} is the \term{synonym stream symbol} of the \term{synonym stream}.
     \Seefun{make-synonym-stream}.
  2. (to a \term{stream})
     a \term{synonym stream} which has the \term{stream} as the \term{value}
     of its \term{synonym stream symbol}.
  3. (to a \term{symbol})
     a \term{synonym stream} which has the \term{symbol} as its
     \term{synonym stream symbol}.

\gentry{synonym stream symbol} \Noun\ (of a \term{synonym stream})
  the \term{symbol} which names the \term{dynamic variable} which has as its
  \term{value} another \term{stream} for which the \term{synonym stream}
  is an alias.

\gentry{syntax type} \Noun\ (of a \term{character})
  one of several classifications, enumerated in \figref\PossibleSyntaxTypes,
  that are used for dispatch during parsing by the \term{Lisp reader}.
  \Seesection\CharacterSyntaxTypes.

\gentry{system class} \Noun\ 
  a \term{class} that may be \oftype{built-in-class} in a \term{conforming implementation}
  and hence cannot be inherited by \term{classes} defined by \term{conforming programs}.

\gentry{system code} \Noun\ 
  \term{code} supplied by the \term{implementation} to implement this specification
  (\eg the definition of \funref{mapcar})
  or generated automatically in support of this specification
  (\eg during method combination);
  that is, \term{code} that is not \term{programmer code}.

% %!!! Now that there's this term "standarized", this term could probably go away.
% %    -kmp 24-Jan-92
% \gentry{system stream variable} \Noun\
%   a \term{standardized} \term{stream variable}.
%   \Seesection\StreamConcepts.

\indextab{T}

\gentry{t} \Noun\ 
  1. a. the \term{boolean} representing true.
     b. the canonical \term{generalized boolean} representing true.
        (Although any \term{object} other than \nil\ is considered \term{true} 
	 as a \term{generalized boolean},
         \f{t} is generally used when there is no special reason to prefer one 
         such \term{object} over another.)
  2. the \term{name} of the \term{type} to which all \term{objects} belong---the
     \term{supertype} of all \term{types} (including itself).
  3. the \term{name} of the \term{superclass} of all \term{classes} except itself.
 
\gentry{tag} \Noun\ 
  1. a \term{catch tag}.
  2. a \term{go tag}.

\issue{TAILP-NIL:T}
\gentry{tail} \Noun\ (of a \term{list})
  an \term{object} that is the \term{same} as either some \term{cons}
  which makes up that \term{list} or the \term{atom} (if any) which terminates
  the \term{list}.
  \gexample{The empty list is a tail of every proper list.}
\endissue{TAILP-NIL:T}

\gentry{target} \Noun\ 
  1. (of a \term{constructed stream}) 
     a \term{constituent} of the \term{constructed stream}.
     \gexample{The target of a synonym stream is 
	       the value of its synonym stream symbol.}
  2. (of a \term{displaced array})
     the \term{array} to which the \term{displaced array} is displaced.
  (In the case of a chain of \term{constructed streams} or \term{displaced arrays},
   the unqualified term ``\term{target}'' always refers to the immediate 
   \term{target} of the first item in the chain, not the immediate target
   of the last item.)
%!!! Do we want a term "eventual target" to talk about the last item?

\gentry{terminal I/O} \Noun\ 
  the \term{bidirectional} \term{stream}
  that is the \term{value} of \thevariable{*terminal-io*}.

\gentry{terminating} \Noun\ (of a \term{macro character})
  being such that, if it appears while parsing a token, it terminates that token.
  \Seesection\ReaderAlgorithm.

\gentry{tertiary value} \Noun\ (of \term{values} resulting from the
				   \term{evaluation} of a \term{form})
  the third \term{value}, if any,
  or else \nil\ if there are fewer than three \term{values}.

\gentry{throw} \Verb\ 
  to transfer control and \term{values} to a \term{catch}.
  \Seespec{throw}.

\gentry{tilde} \Noun\
  the \term{standard character} that is called ``tilde'' (\f{~}).
  \Seefigure\StdCharsThree.

%!!! Moon: What's a "time line"?
\gentry{time}
  a representation of a point (\term{absolute} \term{time}) 
		   or an interval (\term{relative} \term{time})
  on a time line.
  \Seeterm{decoded time}, \term{internal time}, and \term{universal time}.

\issue{TIME-ZONE-NON-INTEGER:ALLOW}
\gentry{time zone} \Noun\
  a \term{rational} multiple of \f{1/3600} between \f{-24} (inclusive)
  and \f{24} (inclusive) that represents a time zone as a number of hours
  offset from Greenwich Mean Time.  Time zone values increase with motion to the west,
  so   Massachusetts, U.S.A. is in time zone \f{5},
       California, U.S.A. is time zone \f{8},
   and Moscow, Russia is time zone \term{-3}.
%   (In regions where ``daylight savings time'' might apply,
%    the time zone does not depend on whether daylight savings time
%    is in effect---such information is represented separately.)
%% Moon didn't like that, and prefers the following:
   (When ``daylight savings time'' is separately represented
    as an \term{argument} or \term{return value}, the \term{time zone}
    that accompanies it does not depend on whether daylight savings time
    is in effect.)
\endissue{TIME-ZONE-NON-INTEGER:ALLOW}

\gentry{token} \Noun\
  a textual representation for a \term{number} or a \term{symbol}.
  \Seesection\InterpOfTokens.

\gentry{top level form} \Noun\ 
% The old definition is contradicted by item (4) in the description of how
% EVAL-WHEN works. --sjl 3 Mar 92
%  a \term{form} which, because it is not a \term{subform} of some \term{form}
%  that \term{establishes} a new \term{lexical environment}, is to be executed
%  in the \term{null lexical environment}.
  a \term{form} which is processed specially by \funref{compile-file} for
  the purposes of enabling \term{compile time} \term{evaluation} of that
  \term{form}.  
  \term{Top level forms} include those \term{forms} which 
  are not \term{subforms} of any other \term{form},
  and certain other cases.  \Seesection\TopLevelForms.
 
\gentry{trace output} \Noun\ 
  the \term{output} \term{stream} which is the \term{value} of the \term{dynamic variable}
  \varref{*trace-output*}.

\gentry{tree} \Noun\ 
  1. a binary recursive data structure made up of \term{conses} and
     \term{atoms}:  the \term{conses} are themselves also \term{trees}
     (sometimes called ``subtrees'' or ``branches''), and the \term{atoms}
     are terminal nodes (sometimes called \term{leaves}). Typically,
     the \term{leaves} represent data while the branches establish some 
     relationship among that data.
% Moon wondered if "acyclic" should be here.  I think that's fine for math
% but not for computer science. so i'm leaving it out.  I think it's
% useful to talk about a tree that is circular, but "circular tree" would
% be an oxymoron under so rigorous a definition.  as with a list, one
% often doesn't descend a tree in order to prove it's well-formed before
% manipulating it with tree primitives, and you'd still like to be able to
% say it was a tree.   tree is more of a view on the process of
% destructuring than a kind of object.  after all, all objects are trees.
% -kmp 15-Nov-91
  2. in general, any recursive data structure that has some notion of
     ``branches'' and \term{leaves}.
 
\gentry{tree structure} \Noun\ (of a \term{tree}\meaning{1})
  the set of \term{conses} that make up the \term{tree}.
  Note that while the \term{car}\meaning{1b} component of each such \term{cons}
  is part of the \term{tree structure}, 
  the \term{objects} that are the \term{cars}\meaning{2} of each \term{cons}
  in the \term{tree}
  are not themselves part of its \term{tree structure} 
  unless they are also \term{conses}.

\gentry{true} \Noun\ 
  any \term{object} 
      that is not \term{false}
  and that is used to represent the success of a \term{predicate} test.
  \Seeterm{t}\meaning{1}.

\gentry{truename} \Noun\ 
  1. the canonical \term{filename} of a \term{file} in the \term{file system}.
     \Seesection\Truenames.
  2. a \term{pathname} representing a \term{truename}\meaning{1}.

\gentry{two-way stream} \Noun\ 
  a \term{stream} \oftype{two-way-stream},
  which is a \term{bidirectional} \term{composite stream} that 
       receives its input  from an associated \term{input}  \term{stream} 
   and sends    its output to   an associated \term{output} \term{stream}.

\gentry{type} \Noun\ 
  1. a set of \term{objects}, usually with common structure, behavior, or purpose.
     (Note that the expression ``\i{X} is of type \param{S$\sub{a}$}'' 
      naturally implies that ``\i{X} is of type \param{S$\sub{b}$}'' if 
      \param{S$\sub{a}$} is a \term{subtype} of \param{S$\sub{b}$}.)
  2. (immediately following the name of a \term{type})
     a \term{subtype} of that \term{type}.
     \gexample{The type \typeref{vector} is an array type.}

\gentry{type declaration} \Noun\ 
  a \term{declaration} that asserts that every reference to a 
  specified \term{binding} within the scope of the \term{declaration}
  results in some \term{object} of the specified \term{type}.

\gentry{type equivalent} \Adjective\ (of two \term{types} $X$ and $Y$)
  having the same \term{elements};
  that is, $X$ is a \term{subtype} of $Y$ 
       and $Y$ is a \term{subtype} of $X$.

\gentry{type expand} \Noun\
  to fully expand a \term{type specifier}, removing any references to
  \term{derived types}.  (\clisp\ provides no program interface to cause
  this to occur, but the semantics of \clisp\ are such that every
  \term{implementation} must be able to do this internally, and some
  situations involving \term{type specifiers} are most easily described
  in terms of a fully expanded \term{type specifier}.)

\gentry{type specifier} \Noun\ 
  an \term{expression} that denotes a \term{type}.
  \gexample{The symbol \f{random-state}, the list \f{(integer 3 5)},
            the list \f{(and list (not null))}, and the class named
            \f{standard-class} are type specifiers.}

\indextab{U}
 
\gentry{unbound} \Adjective\ 
  not having an associated denotation in a \term{binding}.
  \Seeterm{bound}.
 
\gentry{unbound variable} \Noun\
  a \term{name} that is syntactically plausible as the name of a
  \term{variable} but which is not \term{bound} 
  in the \term{variable} \term{namespace}.

\gentry{undefined function} \Noun\
  a \term{name} that is syntactically plausible as the name of a
  \term{function} but which is not \term{bound}
  in the \term{function} \term{namespace}.

\gentry{unintern} \TransitiveVerb\ (a \term{symbol} in a \term{package})
  to make the \term{symbol} not be \term{present} in that \term{package}.
  (The \term{symbol} might continue to be \term{accessible} by inheritance.)

\gentry{uninterned} \Adjective\ (of a \term{symbol}) 
  not \term{accessible} in any \term{package}; \ie not \term{interned}\meaning{1}.

\gentry{universal time} \Noun\
  \term{time}, represented as a non-negative \term{integer} number of seconds.
%!!! Moon: Universal time is -always- absolute!
  \term{Absolute} \term{universal time} is measured as an offset
  from the beginning of the year 1900 (ignoring \term{leap seconds}).
  \Seesection\UniversalTime.

\gentry{unqualified method} \Noun\ 
  a \term{method} with no \term{qualifiers}.

\gentry{unregistered package} \Noun\
  a \term{package} \term{object} that is not present in the \term{package registry}.
  An \term{unregistered package} has no \term{name}; \ie its \term{name} is \nil.
  \Seefun{delete-package}.

\gentry{unsafe} \Adjective\ (of \term{code})
  not \term{safe}.  (Note that, unless explicitly specified otherwise,
  if a particular kind of error checking is
  guaranteed only in a \term{safe} context, the same checking might or might not occur
  in that context if it were \term{unsafe}; describing a context as \term{unsafe}
  means that certain kinds of error checking are not reliably enabled
  but does not guarantee that error checking is definitely disabled.)

\gentry{unsafe call} \Noun\
  a \term{call} that is not a \term{safe call}.
  For more detailed information, \seesection\SafeAndUnsafeCalls.

\gentry{upgrade} \TransitiveVerb\ (a declared \term{type} to an actual \term{type})
  1. (when creating an \term{array})
     to substitute an \term{actual array element type} 
     for an \term{expressed array element type}
     when choosing an appropriately \term{specialized} \term{array} representation.
     \Seefun{upgraded-array-element-type}.
  2. (when creating a \term{complex})
     to substitute an \term{actual complex part type} 
     for an \term{expressed complex part type}
     when choosing an appropriately \term{specialized} \term{complex} representation.
     \Seefun{upgraded-complex-part-type}.

\gentry{upgraded array element type} \Noun\ (of a \term{type})
  a \term{type} that is a \term{supertype} of the \term{type}
  and that is used instead of the \term{type} whenever the
  \term{type} is used as an \term{array element type} 
  for object creation or type discrimination.
  \Seesection\ArrayUpgrading.

\gentry{upgraded complex part type} \Noun\ (of a \term{type})
  a \term{type} that is a \term{supertype} of the \term{type}
  and that is used instead of the \term{type} whenever the
  \term{type} is used as a \term{complex part type} 
  for object creation or type discrimination.
  \Seefun{upgraded-complex-part-type}.

\gentry{uppercase} \Adjective\ (of a \term{character})
     being among \term{standard characters} corresponding to
     the capital letters \f{A} through \f{Z},
  or being some other \term{implementation-defined} \term{character}
      that is defined by the \term{implementation} to be \term{uppercase}.
  \Seesection\CharactersWithCase.

\gentry{use} \TransitiveVerb\ (a \term{package} $P\sub 1$)
  to \term{inherit} the \term{external symbols} of $P\sub 1$.
  (If a package $P\sub 2$ uses $P\sub 1$,
   the \term{external symbols} of $P\sub 1$
   become \term{internal symbols} of $P\sub 2$ 
   unless they are explicitly \term{exported}.)
  \gexample{The package \packref{cl-user} uses the package \packref{cl}.}

\gentry{use list} \Noun\ (of a \term{package})
  a (possibly empty) \term{list} associated with each \term{package}
  which determines what other \term{packages} are currently being
  \term{used} by that \term{package}.

\gentry{user} \Noun\ 
  an active entity, typically a human, that invokes or interacts with a
  \term{program} at run time, but that is not necessarily a \term{programmer}.

\indextab{V}
 
\issue{ARRAY-DIMENSION-LIMIT-IMPLICATIONS:ALL-FIXNUM}
\gentry{valid array dimension} \Noun\ 
  a \term{fixnum} suitable for use as an \term{array} \term{dimension}.
  Such a \term{fixnum} must be greater than or equal to zero, 
  and less than the \term{value} of \conref{array-dimension-limit}.
  When multiple \term{array} \term{dimensions} are to be used together to specify a 
  multi-dimensional \term{array}, there is also an implied constraint 
  that the product of all of the \term{dimensions} be less than the \term{value} of 
  \conref{array-total-size-limit}.
\endissue{ARRAY-DIMENSION-LIMIT-IMPLICATIONS:ALL-FIXNUM}

\issue{ARRAY-DIMENSION-LIMIT-IMPLICATIONS:ALL-FIXNUM}
\gentry{valid array index} \Noun\ (of an \term{array})
  a \term{fixnum} suitable for use as one of possibly several indices needed
  to name an \term{element} of the \term{array} according to a multi-dimensional
  Cartesian coordinate system. Such a \term{fixnum} must
  be greater than or equal to zero,
  and must be less than the corresponding \term{dimension}\meaning{1}
  of the \term{array}.
  (Unless otherwise explicitly specified, 
   the phrase ``a \term{list} of \term{valid array indices}'' further implies
   that the \term{length} of the \term{list} must be the same as the
   \term{rank} of the \term{array}.)
  \gexample{For a \f{2} by~\f{3} array,
	    valid array indices for the first  dimension are \f{0} and~\f{1}, and
	    valid array indices for the second dimension are \f{0}, \f{1} and~\f{2}.}
\endissue{ARRAY-DIMENSION-LIMIT-IMPLICATIONS:ALL-FIXNUM}

\issue{ARRAY-DIMENSION-LIMIT-IMPLICATIONS:ALL-FIXNUM}
\gentry{valid array row-major index} \Noun\ (of an \term{array},
					     which might have any number 
					     of \term{dimensions}\meaning{2})
  a single \term{fixnum} suitable for use in naming any \term{element}
  of the \term{array}, by viewing the array's storage as a linear
  series of \term{elements} in row-major order.
  Such a \term{fixnum} must be greater than or equal to zero,
  and less than the \term{array total size} of the \term{array}.
\endissue{ARRAY-DIMENSION-LIMIT-IMPLICATIONS:ALL-FIXNUM}

\issue{ARRAY-DIMENSION-LIMIT-IMPLICATIONS:ALL-FIXNUM}
\gentry{valid fill pointer} \Noun\ (of an \term{array})
  a \term{fixnum} suitable for use as a \term{fill pointer} for the \term{array}.
  Such a \term{fixnum} must be greater than or equal to zero, 
  and less than or equal to the \term{array total size} of the \term{array}.
\endissue{ARRAY-DIMENSION-LIMIT-IMPLICATIONS:ALL-FIXNUM}

\editornote{KMP: The ``valid pathname xxx'' definitions were taken from 
		 text found in make-pathname, but look wrong to me.
		 I'll fix them later.}%!!!

\issue{PATHNAME-UNSPECIFIC-COMPONENT:NEW-TOKEN}

\gentry{valid logical pathname host} \Noun\
  a \term{string} that has been defined as the name of a \term{logical host}.
  \Seefun{load-logical-pathname-translations}.

\gentry{valid pathname device} \Noun\
     a \term{string},
     \nil,
     \kwd{unspecific}, 
  or some other \term{object} defined by the \term{implementation} 
      to be a \term{valid pathname device}.

\gentry{valid pathname directory} \Noun\
     a \term{string},
     a \term{list} of \term{strings},
     \nil,
\issue{PATHNAME-SUBDIRECTORY-LIST:NEW-REPRESENTATION}
     \kwd{wild},
\endissue{PATHNAME-SUBDIRECTORY-LIST:NEW-REPRESENTATION}
     \kwd{unspecific},
  or some other \term{object} defined by the \term{implementation} 
      to be a \term{valid directory component}.

\gentry{valid pathname host} \Noun\
     a \term{valid physical pathname host}
  or a \term{valid logical pathname host}.

\gentry{valid pathname name} \Noun\
     a \term{string},
     \nil,
     \kwd{wild},
     \kwd{unspecific},
  or some other \term{object} defined by the \term{implementation} 
     to be a \term{valid pathname name}.

\gentry{valid pathname type} \Noun\
     a \term{string},
     \nil,
     \kwd{wild},
     \kwd{unspecific}.
%!!! Moon: "... or some other ..."

\gentry{valid pathname version} \Noun\
     a non-negative \term{integer},
     or one of \kwd{wild},
               \kwd{newest},
 	       \kwd{unspecific},
   	    or \nil.
%!!! KMP: "... or some other ..."
%!!! What to do about this?
 The symbols \kwd{oldest}, \kwd{previous}, and \kwd{installed} are
 \term{semi-standard} special version symbols.

\gentry{valid physical pathname host} \Noun\
   any of
     a \term{string},
     a \term{list} of \term{strings},
     or the symbol \kwd{unspecific},
   that is recognized by the implementation as the name of a host.

\endissue{PATHNAME-UNSPECIFIC-COMPONENT:NEW-TOKEN}

\gentry{valid sequence index} \Noun\ (of a \term{sequence})
  an \term{integer} suitable for use to name an \term{element} 
  of the \term{sequence}.  Such an \term{integer} must 
  be greater than or equal to zero,
  and must be less than the \term{length} of the \term{sequence}.
\issue{ARRAY-DIMENSION-LIMIT-IMPLICATIONS:ALL-FIXNUM}
  (If the \term{sequence} is an \term{array},
   the \term{valid sequence index} is further constrained to be a \term{fixnum}.)
\endissue{ARRAY-DIMENSION-LIMIT-IMPLICATIONS:ALL-FIXNUM}

\gentry{value} \Noun\ 
  1. a. one of possibly several \term{objects} that are the result of
        an \term{evaluation}.
     b. (in a situation where exactly one value is expected from the
	 \term{evaluation} of a \term{form})
        the \term{primary value} returned by the \term{form}.
     c. (of \term{forms} in an \term{implicit progn}) one of possibly
        several \term{objects} that result from the \term{evaluation}
        of the last \term{form}, or \nil\ if there are no \term{forms}.
  2. an \term{object} associated with a \term{name} in a \term{binding}.
  3. (of a \term{symbol}) the \term{value} of the \term{dynamic variable}
     named by that symbol.
  4. an \term{object} associated with a \term{key} 
     in an \term{association list}, 
	a  \term{property list},
     or a  \term{hash table}.

\gentry{value cell} \Noun\ \Traditional\ (of a \term{symbol})
  The \term{place} which holds the \term{value}, if any, of the
  \term{dynamic variable} named by that \term{symbol},
  and which is \term{accessed} by \funref{symbol-value}.
  \Seeterm{cell}.

%!!! Moon: This is certainly no valid definition, especially when contrasting
%          the variable namespace with the function namespace.
\gentry{variable} \Noun\ 
  a \term{binding} in which a \term{symbol} is the \term{name}
  used to refer to an \term{object}.
 
\gentry{vector} \Noun\ 
  a one-dimensional \term{array}.

\gentry{vertical-bar} \Noun\
  the \term{standard character} that is called ``vertical bar'' (\f{|}).
  \Seefigure\StdCharsThree.

\indextab{W}
 
%"cursor" => "print position" because Barmar didn't like "cursor".
\gentry{whitespace} \Noun\ 
  1. one or more \term{characters} that are
      either the \term{graphic} \term{character} \f{\#\\Space}
          or else \term{non-graphic} characters such as \f{\#\\Newline} 
                  that only move the print position.
  2. a. \Noun\ the \term{syntax type} of a \term{character} 
         that is a \term{token} separator.
         For details, \seesection\WhitespaceChars.
     b. \Adjective\ (of a \term{character})
        having the \term{whitespace}\meaning{2a} \term{syntax type}\meaning{2}.
     c. \Noun\ a \term{whitespace}\meaning{2b} \term{character}.

\gentry{wild} \Adjective\
  1. (of a \term{namestring}) using an \term{implementation-defined}
     syntax for naming files, which might ``match'' any of possibly several
     possible \term{filenames}, and which can therefore be used to refer to 
     the aggregate of the \term{files} named by those \term{filenames}.
  2. (of a \term{pathname}) a structured representation of a name which
     might ``match'' any of possibly several \term{pathnames}, and which can
     therefore be used to refer to the aggregate of the \term{files} named by those
     \term{pathnames}.  The set of \term{wild} \term{pathnames} includes, but
     is not restricted to, \term{pathnames} which have a component which is
     \kwd{wild}, or which have a directory component which contains \kwd{wild} 
     or \kwd{wild-inferors}.
     \Seefun{wild-pathname-p}.
%!!! Need to fix this.  Some places use wild to refer to components instead of full pathnames.
%   3. (of a \term{pathname} component)
%      a component of a \term{pathname} that might ``match'' any of possibly 
%      several values for that component, and which can
%      therefore be used to refer to the aggregate of the \term{files} named by those
%      \term{pathnames}.  The set of \term{wild} \term{pathnames} includes, but
%      is not restricted to, \term{pathnames} which have a component which is
%      \kwd{wild}, or which have a directory component which contains \kwd{wild} 
%      or \kwd{wild-inferors}.
%      \Seefun{wild-pathname-p}.

\gentry{write} \TransitiveVerb\ 
\issue{IGNORE-USE-TERMINOLOGY:VALUE-ONLY}
  1. (a \term{binding} or \term{slot} or component)
     to change the \term{value} of the \term{binding} or \term{slot}.
\endissue{IGNORE-USE-TERMINOLOGY:VALUE-ONLY}
  2. (an \term{object} to a \term{stream})
     to output a representation of the \term{object} to the \term{stream}.


\gentry{writer} \Noun\
  a \term{function} that \term{writes}\meaning{1} a \term{variable} or \term{slot}.

\indextab{Y}
 
\gentry{yield} \TransitiveVerb\ (\term{values})
  to produce the \term{values} as the result of \term{evaluation}.
  \gexample{The form \f{(+ 2 3)} yields \f{5}.}

\endlist
\endlist
