chap-26.texi

@node Glossary
@chapter Glossary
@menu
* Glossary Notation::
* Non-alphabetic::
* A::
* B::
* C::
* D::
* E::
* F::
* G::
* H::
* I::
* K::
* L::
* M::
* N::
* O::
* P::
* Q::
* R::
* S::
* T::
* U::
* V::
* W::
* Y::
@end menu

@node Glossary Notation
@section Glossary Notation




Each entry in this glossary has the following parts:


@itemize @bullet{}

@item the term being defined, set in boldface.

@item 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 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 one or more definitions, organized as follows:


@itemize --

@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.
@end itemize
@end itemize


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 @i{this font} are words with entries in the glossary.
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 ``@i{something}[n]'' means that
the @i{n}th definition of ``@i{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:


@multitable @columnfractions 0.25 0.7

@headitem Abbreviation@tab Meaning

@item @Adjective{} @tab adjective
@item @Adverb{} @tab adverb
@item @ANSI{} @tab compatible with one or more ANSI standards
@item @Computers{} @tab computers
@item @Idiomatic{} @tab idiomatic
@item @IEEE{} @tab compatible with one or more IEEE standards
@item @ISO{} @tab compatible with one or more ISO standards
@item @Mathematics{} @tab mathematics
@item @Traditional{} @tab traditional
@item @Noun{} @tab noun
@item @Verb{} @tab verb
@item @TransitiveVerb{} @tab transitive verb
@end multitable



@node Non-alphabetic
@unnumberedsec Non-alphabetic
@table @asis

@item @bglos{()}
 @pronounced{@Stress{nil}}, @Noun{}
an alternative notation for writing the symbol@tie{}@nil{}, used to emphasize
the use of @term{nil} as an @term{empty list}.


@end table
@node A
@unnumberedsec A
@table @asis

@item @bglos{absolute} @anchor{glos-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.
See @ref{glos-relative, relative}.

@item @bglos{access}  @Noun{}, @TransitiveVerb{} @anchor{glos-Accesses}
1. @TransitiveVerb{}@spc{}(a @term{place}, or @term{array})
to @term{read}@sub{1} or @term{write}@sub{1} the @term{value} of
the @term{place}
or an @term{element} of the @term{array}.
2. @Noun{}@spc{}(of a @term{place})
an attempt to @term{access}@sub{1} the @term{value} of the @term{place}.

@item @bglos{accessibility}  @Noun{}
the state of being @term{accessible}.

@item @bglos{accessible}  @Adjective{}@spc{} @anchor{glos-Accessible}
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}.
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}.

@item @bglos{accessor}  @Noun{}
an @term{operator} that performs an @term{access}.
See @ref{glos-reader, reader} and @term{writer}.

@item @bglos{active}  @Adjective{}@spc{} @anchor{glos-Active}
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}.

@item @bglos{actual adjustability}
 @Noun{}@spc{}(of an @term{array})
a @term{generalized boolean} that is associated with the @term{array},
representing whether the @term{array} is @term{actually adjustable}.
See also @ref{glos-expressed adjustability, expressed adjustability} and @symbolref{adjustable-array-p, SYM}.

@item @bglos{actual argument}  @Noun{}@spc{}@Traditional{}@spc{}
an @term{argument}.

@item @bglos{actual array element type}  @Noun{}@spc{}(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}.
See the @term{function} @ref{array-element-type}.

@item @bglos{actual complex part type}  @Noun{}@spc{}(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}.

@item @bglos{actual parameter}  @Noun{}@spc{}@Traditional{}@spc{}
an @term{argument}.

@item @bglos{actually adjustable}  @Adjective{}@spc{}(of an @term{array})
such that @symbolref{adjust-array, SYM} 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 @symbolref{adjustable-array-p, SYM}.

@item @bglos{adjustability}  @Noun{}@spc{}(of an @term{array})
1. @term{expressed adjustability}.
2. @term{actual adjustability}.

@item @bglos{adjustable}  @Adjective{}@spc{}(of an @term{array})
1. @term{expressly adjustable}.
2. @term{actually adjustable}.

@item @bglos{after method}  @Noun{}
a @term{method} having the @term{qualifier} @kwd{after}.

@item @bglos{alist}  @pronounced{@Stress{@harda{}}@stress{list}}, @Noun{}@spc{}
an @term{association list}.

@item @bglos{alphabetic}  @Noun{}, @Adjective{} @anchor{glos-Alphabetic}
1. @Adjective{}@spc{}(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}@sub{1}.
2. a. @Noun{}
one of several possible @term{constituent traits} of a @term{character}.
For details, see @ref{Constituent Characters}@spc{}and @ref{Reader Algorithm}.
b. @Adjective{}@spc{}(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}[2a].
See @ref{ConstituentTraitsOfStdChars, Figure 2.8}.

@item @bglos{alphanumeric}  @Adjective{}@spc{}(of a @term{character})
being either an @term{alphabetic}@sub{1} @term{character}
or a @term{numeric} character.

@item @bglos{ampersand}  @Noun{}
the @term{standard character} that is called ``ampersand'' (@f{@ampers{}}).
See @ref{StdCharsThree, Figure 2.5}.

@item @bglos{anonymous}  @Adjective{}@spc{}
1. (of a @term{class} or @term{function}) having no @term{name}
2. (of a @term{restart}) having a @term{name} of @nil{}.

@item @bglos{apparently uninterned}  @Adjective{}@spc{}
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} @term{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}.)

@item @bglos{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}.

@item @bglos{applicable handler}  @Noun{}@spc{}(for a @term{condition} being @term{signaled})
an @term{active} @term{handler} for which the associated type contains the
@term{condition}.

@item @bglos{applicable method}  @Noun{}@spc{}(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}.
See @ref{Selecting the Applicable Methods}.

@item @bglos{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{}@spc{}as an argument.

@item @bglos{apply}  @TransitiveVerb{}@spc{}(a @term{function} to a @term{list}) @anchor{glos-Applies}
to @term{call} the @term{function} with arguments that are the @term{elements}
of the @term{list}.
@gexample{Applying the function @symbolref{+, F} to a list of integers returns
the sum of the elements of that list.}

@item @bglos{argument}  @Noun{}
1. (of a @term{function}) an @term{object} which is offered as data
to the @term{function} when it is @term{called}.
2. (of a @term{format control}) a @term{format argument}.

@item @bglos{argument evaluation order}  @Noun{}@spc{}
the order in which @term{arguments} are evaluated in a function call.
@gexample{The argument evaluation order for Common Lisp is left to right.}
See @ref{Evaluation}.

@item @bglos{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.

@item @bglos{around method}  @Noun{}
a @term{method} having the @term{qualifier} @kwd{around}.

@item @bglos{array}  @Noun{} @anchor{glos-Array} @anchor{glos-Arrays}
an @term{object} @oftype{array}, which serves as a container for other
@term{objects} arranged in a Cartesian coordinate system.

@item @bglos{array element type}  @Noun{}@spc{}(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}.

@item @bglos{array total size}  @Noun{}@spc{}
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.)

@item @bglos{assign}  @TransitiveVerb{}@spc{}(a @term{variable})
to change the @term{value} of the @term{variable} in a @term{binding}
that has already been @term{established}.
See the @term{special operator} @ref{setq}.

@item @bglos{association list}
 @Noun{}@spc{}
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}.

@item @bglos{asterisk}  @Noun{}
the @term{standard character} that is variously called
``asterisk''
or ``star'' (@f{*}).
See @ref{StdCharsThree, Figure 2.5}.

@item @bglos{at-sign}  @Noun{}
the @term{standard character} that is variously called
``commercial at''
or ``at sign'' (@f{@@}).
See @ref{StdCharsThree, Figure 2.5}.

@item @bglos{atom}  @Noun{}
any @term{object} that is not a @term{cons}.
@gexample{A vector is an atom.}

@item @bglos{atomic}  @Adjective{}@spc{}
being an @term{atom}.
@gexample{The number 3, the symbol @f{foo}, and @nil{}@spc{}are atomic.}

@item @bglos{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})}.

@item @bglos{attribute}  @Noun{}@spc{}(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}@sub{2}, but @term{implementations} are permitted to have
additional @term{implementation-defined} @term{attributes}.
See @ref{Character Attributes}.
@gexample{An implementation that support fonts
might make font information an attribute of a character,
while others might represent font information separately from characters.}

@item @bglos{aux variable}  @Noun{}  @anchor{glos-Aux variables}
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}.

@item @bglos{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;
see @ref{Introduction to Methods}.


@end table
@node B
@unnumberedsec B
@table @asis

@item @bglos{backquote}  @Noun{}
the @term{standard character} that is variously called
``grave accent''
or ``backquote'' (@f{`}).
See @ref{StdCharsThree, Figure 2.5}.

@item @bglos{backslash}  @Noun{} @anchor{glos-Backslash}
the @term{standard character} that is variously called
``reverse solidus''
or ``backslash'' (@f{@bsl{}}).
See @ref{StdCharsThree, Figure 2.5}.

@item @bglos{base character}  @Noun{}  @anchor{glos-Base characters}
a @term{character}
@oftype{base-char}.

@item @bglos{base string}  @Noun{}
a @term{string} @oftype{base-string}.

@item @bglos{before method}  @Noun{}
a @term{method} having the @term{qualifier} @kwd{before}.

@item @bglos{bidirectional}  @Adjective{}@spc{}(of a @term{stream})
being both an @term{input} @term{stream} and an @term{output} @term{stream}.

@item @bglos{binary}
 @Adjective{}@spc{}
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 @symbolref{read-byte, SYM} and on a @term{binary} @term{output} @term{stream}
is @symbolref{write-byte, SYM}.
See @ref{glos-character, 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}.)

@anchor{glos-bind}
@anchor{glos-binds}
@anchor{glos-binded}
@item @b{bind}  @TransitiveVerb{}@spc{}(a @term{variable})
to establish a @term{binding} for the @term{variable}.

@item @bglos{binding}  @Noun{}@spc{} @anchor{glos-Binding} @anchor{glos-Bindings}
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.}
When the term @term{binding} is qualified by the name of a @term{namespace},
such as ``variable'' or ``function,''
it restricts the binding to the indicated namespace, as in:
@gexample{@symbolref{let, SYM} establishes variable bindings.}
or
@gexample{@symbolref{let, SYM} establishes bindings of variables.}

@item @bglos{bit}  @Noun{}@spc{}
an @term{object} @oftype{bit};
that is, the @term{integer} @f{0} or the @term{integer} @f{1}.

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

@item @bglos{bit vector}  @Noun{}@spc{} @anchor{glos-Bit vectors}
a specialized @term{vector} that is @oftype{bit-vector},
and whose elements are @oftype{bit}.

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

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

@item @bglos{block tag}  @Noun{}@spc{}
the @term{symbol} that, within the @term{lexical scope}
of a @symbolref{block, SYM} @term{form}, names the @term{block}
@term{established} by that @symbolref{block, SYM} @term{form}.
See @symbolref{return, SYM} or @symbolref{return-from, SYM}.

@item @bglos{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.
See @ref{Boa Lambda Lists}.

@item @bglos{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}.)

@item @bglos{boolean}
 @Noun{}@spc{}
an @term{object} @oftype{boolean};
that is, one of the following @term{objects}:
the symbol@tie{}@symbolref{t, SC}@spc{}  (representing @term{true}),
or the symbol@tie{}@nil{}@spc{}(representing @term{false}).
See @ref{glos-generalized boolean}.

@item @bglos{boolean equivalent}  @Noun{}@spc{}(of an @term{object} @mat{O@sub{1}})
any @term{object} @mat{O@sub{2}} that has the same truth value as @mat{O@sub{1}}
when both @mat{O@sub{1}} and @mat{O@sub{2}} are viewed as @term{generalized booleans}.

@anchor{glos-bound}
@anchor{glos-bounds}
@anchor{glos-boundes}
@anchor{glos-bounding}
@item @b{bound}
 @Adjective{}, @TransitiveVerb{}@spc{}
1. @Adjective{}@spc{}having an associated denotation in a @term{binding}.
@gexample{The variables named by a @symbolref{let, SYM} are bound within
its body.}
See @ref{glos-unbound, unbound}.
2. @Adjective{}@spc{}having a local @term{binding} which
@term{shadows}@sub{2} another.
@gexample{The variable @symbolref{*print-escape*, SYM} is bound while in
the @symbolref{princ, SYM} function.}
3. @TransitiveVerb{}@spc{}the past tense of @term{bind}.

@item @bglos{bound declaration}  @Noun{}@spc{}
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}
(specifically, at the head of that @term{form}'s body).
(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.)

@item @bglos{bounded}  @Adjective{}@spc{}(of a @term{sequence} @mat{S},
by an ordered pair
of @i{bounding indices} @mat{i@sub{start}} and @mat{i@sub{end}})
restricted to a subrange of the @term{elements} of @mat{S} that includes each @term{element}
beginning with (and including) the one indexed by @mat{i@sub{start}} and
continuing up to (but not including) the one indexed by @mat{i@sub{end}}.

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

@item @bglos{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 @i{bounding indices} of the @term{sequence};
that is, they denote @i{bounding indices} of the @term{sequence},
and are either:
an @term{integer} (denoting itself) and @nil{}@spc{}
(denoting the @term{length} of the @term{sequence}),
or two @term{integers} (each denoting themselves).

@item @bglos{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.
See the @term{function} @ref{break}.

@item @bglos{broadcast stream}  @Noun{}
an @term{output} @term{stream} @oftype{broadcast-stream}.

@item @bglos{built-in class}  @Noun{}
a @term{class} that is a @term{generalized instance} @ofclass{built-in-class}.

@item @bglos{built-in type}  @Noun{}
one of the @term{types} in @ref{StandardizedAtomicTypeSpecs, Figure 4.2}.

@item @bglos{byte}  @Noun{}
1. adjacent bits within an @term{integer}.
(The specific number of bits can vary from point to point in the program;
see the @term{function} @ref{byte}.)
2. an integer in a specified range.
(The specific range can vary from point to point in the program;
see the @term{functions} @ref{open} and @symbolref{write-byte, SYM}.)

@item @bglos{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 @symbolref{ldb, SYM}.


@end table
@node C
@unnumberedsec C
@table @asis

@item @bglos{cadr}  @pronounced{@Stress{ka}@stress{d@schwa{} r}}, @Noun{}@spc{}(of an @term{object})
the @term{car} of the @term{cdr} of that @term{object}.

@item @bglos{call}  @TransitiveVerb{}, @Noun{}@spc{}
1. @TransitiveVerb{}@spc{}(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 @symbolref{+, F} with the arguments
@f{5} and @f{1} yields a value of @f{6}.}
2. @Noun{}@spc{}a @term{situation} in which a @term{function} is called.

@item @bglos{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 @symbolref{defclass, SYM} form for the new class.}

@item @bglos{car}  @Noun{}
1. a. (of a @term{cons})
the component of a @term{cons} corresponding to the first
@term{argument} to @symbolref{cons, F}; the other component is the
@term{cdr}.
@gexample{The function @symbolref{rplaca, SYM} modifies the car of a cons.}
b. (of a @term{list})
the first @term{element} of the @term{list}, or @nil{}@spc{}if the
@term{list} is the @term{empty list}.
2. the @term{object} that is held in the @term{car}@sub{1}.
@gexample{The function @symbolref{car, SYM} returns the car of a cons.}

@item @bglos{case}  @Noun{}@spc{}(of a @term{character})  @anchor{glos-Case}
the property of being either @term{uppercase} or @term{lowercase}.
Not all @term{characters} have @term{case}.
@gexample{The characters @f{#@bsl{}A} and @f{#@bsl{}a} have case,
but the character @f{#@bsl{}@dollar{}} has no case.}
See @ref{Characters With Case}@spc{}and @thefunction{both-case-p}.

@item @bglos{case sensitivity mode}  @Noun{}
one of the @term{symbols}
@kwd{upcase}, @kwd{downcase}, @kwd{preserve}, or @kwd{invert}.

@item @bglos{catch}  @Noun{}
an @term{exit point} which is @term{established} by a @symbolref{catch, SYM}
@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 @i{thrown}.

@item @bglos{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}@sub{2}.)

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

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

@item @bglos{cell}
 @Noun{}@spc{}@Traditional{}@spc{}(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.

@item @bglos{character} @anchor{glos-Characters}
 @Noun{}, @Adjective{}
1. @Noun{}@spc{}an @term{object} @oftype{character}; that is,
an @term{object} that represents a unitary token in an aggregate quantity of text;
see @ref{Character Concepts}.
2. @Adjective{}@spc{}
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 @symbolref{read-char, SYM} and on a @term{character} @term{output} @term{stream}
is @symbolref{write-char, SYM}. See @ref{glos-binary, 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}.)

@item @bglos{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}@sub{1}.

@item @bglos{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}),
or a @term{character} (denoting itself).

@item @bglos{circular}  @Adjective{}
1. (of a @term{list}) a @term{circular list}.
2. (of an arbitrary @term{object})
having a @i{component}, @term{element}, @term{constituent}@sub{2},
or @term{subexpression} (as appropriate to the context)
that is the @term{object} itself.

@item @bglos{circular list}  @Noun{}@spc{}
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}.

@item @bglos{class}  @Noun{} @anchor{glos-Classes}
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 @symbolref{integer, SYM} is a subclass of the class @symbolref{number, SYM}.}
(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}.
See the @term{function} @ref{class-of}.
@gexample{The class of the object returned by @symbolref{gensym, SYM}
is @symbolref{symbol, SYM}.}
(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.)

@item @bglos{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};
see the @term{function} @ref{find-class})
or a @term{class} (denoting itself).

@item @bglos{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, see @ref{Determining the Class Precedence List}.

@anchor{glos-close}
@anchor{glos-closes}
@anchor{glos-closeing}
@item @b{close}
 @TransitiveVerb{}@spc{}(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.

@item @bglos{closed}  @Adjective{}@spc{}(of a @term{stream})
having been @term{closed} (see @ref{close}).
Some (but not all) operations that are valid on @term{open} @term{streams}
are not valid on @term{closed} @term{streams}.
See @ref{Open and Closed Streams}.

@item @bglos{closure}  @Noun{}
a @term{lexical closure}.

@item @bglos{coalesce}  @TransitiveVerb{}@spc{}(@term{literal} @term{objects} that are @term{similar})
to consolidate the identity of those @term{objects},
such that they become the @term{same}
@term{object}.
See @ref{Compiler Terminology}.

@item @bglos{code}  @Noun{} @anchor{glos-Code}
1. @Traditional{}@spc{}
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}.

@item @bglos{coerce}  @TransitiveVerb{}@spc{}(an @term{object} to a @term{type}) @anchor{glos-Coerces}
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}---see @ref{Rule of Canonical Representation for Complex Rationals}.

@item @bglos{colon}  @Noun{}
the @term{standard character} that is called ``colon'' (@f{:}).
See @ref{StdCharsThree, Figure 2.5}.

@item @bglos{comma}  @Noun{} @anchor{glos-Comma}
the @term{standard character} that is called ``comma'' (@f{,}).
See @ref{StdCharsThree, Figure 2.5}.

@item @bglos{compilation}  @Noun{}
the process of @i{compiling} @term{code} by the @term{compiler}.

@item @bglos{compilation environment}  @Noun{}@spc{}
1. An @term{environment} that represents information known by the
@term{compiler} about a @term{form} that is being @term{compiled}.
See @ref{Compiler Terminology}.
2. An @term{object} that represents the
@term{compilation environment}@sub{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).

@item @bglos{compilation unit}  @Noun{}
an interval during which a single unit of compilation is occurring.
See the @term{macro} @ref{with-compilation-unit}.

@item @bglos{compile} @TransitiveVerb{}@spc{}
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 @i{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 @i{compiling} the @term{code}
represented by the @term{function}.  See the @term{function} @ref{compile}.
3. (a @term{source file})
to produce a @term{compiled file} from a @term{source file}.
See the @term{function} @ref{compile-file}.

@item @bglos{compile time}  @Noun{}@spc{}
the duration of time that the @term{compiler} is processing @term{source code}.

@item @bglos{compile-time definition}  @Noun{}
a definition in the @term{compilation environment}.

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

@item @bglos{compiled file}  @Noun{}
a @term{file} which represents the results of @i{compiling} the
@term{forms} which appeared in a corresponding @term{source file},
and which can be @term{loaded}.  See the @term{function} @ref{compile-file}.

@item @bglos{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}.

@item @bglos{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 @symbolref{compile, SYM} and @symbolref{compile-file, SYM}
permit programs to invoke the @term{compiler}.

@item @bglos{compiler macro}  @Noun{} @anchor{glos-Compiler macro} @anchor{glos-Compiler macros}
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.)

@item @bglos{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.

@item @bglos{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 @symbolref{funcall, SYM} @term{form} whose first @term{argument} is a
@symbolref{function, SO} @term{form} whose @term{argument} is the @term{name}
of a @term{function} that has a definition as a @term{compiler macro}.

@item @bglos{compiler macro function}  @Noun{}@spc{}
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.  See @ref{Compiler Macros}.

@item @bglos{complex}  @Noun{} @anchor{glos-Complexes}
an @term{object} @oftype{complex}.

@item @bglos{complex float}  @Noun{}
an @term{object} @oftype{complex} which has a @term{complex part type}
that is a @term{subtype} of @symbolref{float, SC}.
A @term{complex float} is a @term{complex},
but it is not a @term{float}.

@item @bglos{complex part type}  @Noun{}@spc{}(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}.

@item @bglos{complex rational}  @Noun{}
an @term{object} @oftype{complex} which has a @term{complex part type}
that is a @term{subtype} of @symbolref{rational, SC}.
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{}@spc{}as an @term{object} @oftype{rational};
see @ref{Rule of Canonical Representation for Complex Rationals}.

@item @bglos{complex single float}  @Noun{}
an @term{object} @oftype{complex} which has a @term{complex part type}
that is a @term{subtype} of @symbolref{single-float, SYM}.
A @term{complex single float} is a @term{complex},
but it is not a @term{single float}.

@item @bglos{composite stream}  @Noun{}
a @term{stream} that is composed of one or more other @term{streams}.
@gexample{@symbolref{make-synonym-stream, SYM} creates a composite stream.}

@item @bglos{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}.

@item @bglos{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.}

@item @bglos{concatenated stream}  @Noun{}
an @term{input} @term{stream} @oftype{concatenated-stream}.

@item @bglos{condition}  @Noun{} @anchor{glos-Condition} @anchor{glos-Conditions}
1. an @term{object} which represents a @term{situation}---usually,
but not necessarily, during @term{signaling}.
2. an @term{object} @oftype{condition}.

@item @bglos{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, see @ref{Condition Designators}.

@item @bglos{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}.  See @ref{Signaling}.

@item @bglos{condition reporter}  @Noun{}
a @term{function} that describes how a @term{condition} is to be printed
when the @term{Lisp printer} is invoked while @symbolref{*print-escape*, SYM}
is @term{false}.  See @ref{Printing Conditions}.

@item @bglos{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.''
See the @term{function} @ref{pprint-newline} and @ref{Dynamic Control of the Arrangement of Output}.

@item @bglos{conformance}  @Noun{}
a state achieved by proper and complete adherence to the requirements
of this specification.  See @ref{Conformance}.

@item @bglos{conforming code}  @Noun{} @anchor{glos-Conforming code}
@term{code} that is all of part of a @term{conforming program}.

@item @bglos{conforming implementation}  @Noun{} @anchor{glos-Conforming implementations}
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 @i{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}.

@item @bglos{conforming processor}  @Noun{}@spc{}@ANSI{}@spc{}
a @term{conforming implementation}.

@item @bglos{conforming program}  @Noun{} @anchor{glos-Conforming programs}
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}.

@item @bglos{congruent}  @Noun{}@spc{}
conforming to the rules of @term{lambda list} congruency, as detailed in
@ref{Congruent Lambda-lists for all Methods of a Generic Function}.

@item @bglos{cons}  @Noun{}@Verb{}@spc{} @anchor{glos-Conses}
1. @Noun{}@spc{}a compound data @term{object} having two components called the
@term{car} and the @term{cdr}.
2. @Verb{}@spc{}to create such an @term{object}.
3. @Verb{}@spc{}@Idiomatic{}@spc{}to create any @term{object}, or to allocate storage.

@item @bglos{constant}  @Noun{}
1. a @term{constant form}.
2. a @term{constant variable}.
3. a @term{constant object}.
4. a @term{self-evaluating object}.

@item @bglos{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 @symbolref{car, SYM} form in which the argument is a
@symbolref{quote, SYM} form is a constant form.}

@item @bglos{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 @symbolref{compile-file, SYM}
is a constant object.}

@item @bglos{constant variable}  @Noun{} @anchor{glos-Constant variables}
a @term{variable}, the @term{value} of which can never change;
that is, a @term{keyword}@sub{1} or a @term{named constant}.
@gexample{The symbols @symbolref{t, SC}, @nil{}, @kwd{direction}, and
@symbolref{most-positive-fixnum, SYM}@spc{}are constant variables.}

@item @bglos{constituent}  @Noun{}, @Adjective{} @anchor{glos-Constituent}
1. a. @Noun{}@spc{}the @term{syntax type} of a @term{character} that is part of a @term{token}.
For details, see @ref{Constituent Characters}.
b. @Adjective{}@spc{}(of a @term{character})
having the @term{constituent}[1a] @term{syntax type}@sub{2}.
c. @Noun{}@spc{}a @term{constituent}[1b] @term{character}.
2. @Noun{}@spc{}(of a @term{composite stream})
one of possibly several @term{objects} that collectively comprise
the source or sink of that @term{stream}.

@item @bglos{constituent trait}  @Noun{}@spc{}(of a @term{character})
one of several classifications of a @term{constituent} @term{character}
in a @term{readtable}.  See @ref{Constituent Characters}.

@item @bglos{constructed stream}  @Noun{}@spc{}
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.}

@item @bglos{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}.
See @ref{Contagion in Numeric Operations}.

@item @bglos{continuable}  @Noun{}@spc{}(of an @term{error})
an @term{error} that is @term{correctable} by the @f{continue} restart.

@item @bglos{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.

@item @bglos{copy}  @Noun{}
1. (of a @term{cons} @mat{C})
a @term{fresh} @term{cons} with the @term{same} @term{car} and @term{cdr} as @mat{C}.
2. (of a @term{list} @mat{L})
a @term{fresh} @term{list} with the @term{same} @term{elements} as @mat{L}.
(Only the @term{list structure} is @term{fresh};
the @term{elements} are the @term{same}.)
See the @term{function} @ref{copy-list}.
3. (of an @term{association list} @mat{A} with @term{elements} @mat{A@sub{i}})
a @term{fresh} @term{list} @mat{B} with @term{elements} @mat{B@sub{i}}, each of which is
@nil{}@spc{}if @mat{A@sub{i}} is @nil{}, or else a @term{copy} of the @term{cons} @mat{A@sub{i}}.
See the @term{function} @ref{copy-alist}.
4. (of a @term{tree} @mat{T})
a @term{fresh} @term{tree} with the @term{same} @term{leaves} as @mat{T}.
See the @term{function} @ref{copy-tree}.
5. (of a @term{random state} @mat{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 @mat{R} would produce.
6. (of a @term{structure} @mat{S})
a @term{fresh} @term{structure} that has the same @term{type} as @mat{S},
and that has slot values, each of which is the @term{same} as the
corresponding slot value of @mat{S}.
(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.)

@item @bglos{correctable}  @Adjective{}@spc{}(of an @term{error})
1. (by a @term{restart} other than @t{abort}
that has been associated with the @term{error})
capable of being corrected by invoking that @term{restart}.
@gexample{The function @symbolref{cerror, SYM} signals an error
that is correctable by the @t{continue} @term{restart}.}
(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}.
See @ref{Associating a Restart with a Condition}.)
2. (when no specific @term{restart} is mentioned)
@term{correctable}@sub{1} by at least one @term{restart}.
@gexample{@symbolref{import, SYM} 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.}

@item @bglos{current input base}  @Noun{}@spc{}(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}.

@item @bglos{current logical block}  @Noun{}
the context of the innermost lexically enclosing use of @symbolref{pprint-logical-block, SYM}.

@item @bglos{current output base}  @Noun{}@spc{}(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}.

@item @bglos{current package}  @Noun{}@spc{}(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}.

@item @bglos{current pprint dispatch table}  @Noun{}@spc{}(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}.

@item @bglos{current random state}  @Noun{}@spc{}(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 @symbolref{random, SYM}.

@item @bglos{current readtable}  @Noun{}@spc{}(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}@sub{2} are parsed
into @term{objects} by the @term{Lisp reader}.


@end table
@node D
@unnumberedsec D
@table @asis

@item @bglos{data type}  @Noun{}@spc{}@Traditional{}@spc{}
a @term{type}.

@item @bglos{debug I/O}  @Noun{}@spc{}
the @term{bidirectional} @term{stream}
that is the @term{value} of @thevariable{*debug-io*}.

@item @bglos{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.

@item @bglos{declaration}  @Noun{} @anchor{glos-Declarations}
a @term{global declaration} or @term{local declaration}.

@item @bglos{declaration identifier}  @Noun{}
one of the @term{symbols}
@symbolref{declaration, SYM},
@symbolref{dynamic-extent, SYM},
@symbolref{ftype, SYM},
@code{function},
@symbolref{ignore, SYM},
@symbolref{inline, SYM},
@symbolref{notinline, SYM},
@symbolref{optimize, SYM},
@symbolref{special, SYM},
or @symbolref{type, SYM};
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 @symbolref{declaration, SYM}
@term{declaration}.

@item @bglos{declaration specifier}  @Noun{}
an @term{expression} that can appear at top level of a @t{declare}
expression or a @symbolref{declaim, SYM} form, or as the argument to @symbolref{proclaim, SYM},
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}.

@item @bglos{declare}  @Verb{}@spc{}
to @term{establish} a @term{declaration}.
See @ref{declare}, @symbolref{declaim, SYM}, or @symbolref{proclaim, SYM}.

@item @bglos{decline}  @Verb{}@spc{}(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.

@item @bglos{decoded time} @anchor{glos-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).
See @ref{Decoded Time}.

@item @bglos{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}@sub{2} by a more specific @term{method}.

@item @bglos{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}.

@item @bglos{define-method-combination arguments lambda list}  @Noun{} @anchor{glos-Define-method-combination arguments lambda lists}
a @term{lambda list} used by the @kwd{arguments} option
to @symbolref{define-method-combination, SYM}.
See @ref{Define-method-combination Arguments Lambda Lists}.

@item @bglos{define-modify-macro lambda list}  @Noun{} @anchor{glos-Define-modify-macro lambda lists}
a @term{lambda list} used by @symbolref{define-modify-macro, SYM}.
See @ref{Define-modify-macro Lambda Lists}.

@item @bglos{defined name}  @Noun{} @anchor{glos-Defined names}
a @term{symbol} the meaning of which is defined by @clisp{}.

@item @bglos{defining form}  @Noun{}
a @term{form} that has the side-effect of @term{establishing} a definition.
@gexample{@symbolref{defun, SYM} and @symbolref{defparameter, SYM} are defining forms.}

@item @bglos{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}.
See @ref{Defsetf Lambda Lists}.

@item @bglos{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} @t{*} (rather than @nil{}).
See @ref{Deftype Lambda Lists}.

@item @bglos{denormalized}
 @Adjective{}, @ANSI{}, @IEEE{}@spc{}(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}.

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

@item @bglos{derived type specifier}  @Noun{}
a @term{type specifier} for a @term{derived type}.

@item @bglos{designator}  @Noun{}@spc{}
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, see @ref{Designators}.

@item @bglos{destructive}  @Adjective{}@spc{}(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}.

@item @bglos{destructuring lambda list}  @Noun{} @anchor{glos-Destructuring lambda lists}
an @term{extended lambda list} used in @symbolref{destructuring-bind, SYM} and
nested within @term{macro lambda lists}.
See @ref{Destructuring Lambda Lists}.

@item @bglos{different}  @Adjective{}@spc{}
not the @term{same}
@gexample{The strings @f{"FOO"} and @f{"foo"} are different under
@symbolref{equal, SYM} but not under @symbolref{equalp, SYM}.}

@item @bglos{digit}  @Noun{}@spc{}(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}.
See @ref{Digits in a Radix}.

@item @bglos{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.}

@item @bglos{direct instance}  @Noun{}@spc{}(of a @term{class} @mat{C})
an @term{object} whose @term{class} is @mat{C} itself,
rather than some @term{subclass} of @mat{C}.
@gexample{The function @symbolref{make-instance, SYM} always returns a
direct instance of the class which is (or is named by)
its first argument.}

@item @bglos{direct subclass}  @Noun{}@spc{}(of a @term{class} @mat{C@sub{1}})
a @term{class} @mat{C@sub{2}},
such that @mat{C@sub{1}} is a @term{direct superclass} of @mat{C@sub{2}}.

@item @bglos{direct superclass}  @Noun{}@spc{}(of a @term{class} @mat{C@sub{1}})
a @term{class} @mat{C@sub{2}} which was explicitly designated as
a @term{superclass} of @mat{C@sub{1}} in the definition of @mat{C@sub{1}}.

@item @bglos{disestablish}  @TransitiveVerb{}@spc{}
to withdraw the @i{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}.

@item @bglos{disjoint}  @Noun{}@spc{}(of @term{types})
having no @term{elements} in common.

@item @bglos{dispatching macro character}  @Noun{}@spc{} @anchor{glos-Dispatching macro characters}
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}.
See the @term{function} @ref{make-dispatch-macro-character}.

@item @bglos{displaced array}  @Noun{}
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}.

@item @bglos{distinct}  @Adjective{}
not @term{identical}.

@item @bglos{documentation string}  @Noun{}@spc{}(in a defining @term{form}) @anchor{glos-Documentation strings}
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 @symbolref{defmacro, SYM} form can be preceded
by a documentation string of kind @t{function}.}

@item @bglos{dot}  @Noun{}
the @term{standard character} that is variously called
``full stop,''
``period,''
or ``dot'' (@f{.}).
See @ref{StdCharsThree, Figure 2.5}.

@item @bglos{dotted list}  @Noun{} @anchor{glos-Dotted lists}
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.)

@item @bglos{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.

@item @bglos{double float}  @Noun{}
an @term{object} @oftype{double-float}.

@item @bglos{double-quote}  @Noun{}
the @term{standard character} that is variously called
``quotation mark''
or ``double quote'' (@f{"}).
See @ref{StdCharsThree, Figure 2.5}.

@item @bglos{dynamic binding}  @Noun{}@spc{}
a @term{binding} in a @term{dynamic environment}.

@item @bglos{dynamic environment}  @Noun{}
that part of an @term{environment} that contains @term{bindings}
with @term{dynamic extent}.  A @term{dynamic environment} contains,
among other things:
@term{exit points} established by @symbolref{unwind-protect, SYM},
and
@term{bindings} of
@term{dynamic variables},
@term{exit points} established by @symbolref{catch, SYM},
@term{condition handlers},
and
@term{restarts}.

@item @bglos{dynamic extent}  @Noun{}
an @term{extent} whose duration is bounded by points of
@i{establishment} and @i{disestablishment} within the execution
of a particular @term{form}.  See @ref{glos-indefinite extent, indefinite extent}.
@gexample{Dynamic variable bindings have dynamic extent.}

@item @bglos{dynamic scope}  @Noun{}
@term{indefinite scope} along with @term{dynamic extent}.

@item @bglos{dynamic variable}  @Noun{}
a @term{variable} the @term{binding} for which is in the @term{dynamic environment}.
See @ref{special}.


@end table
@node E
@unnumberedsec E
@table @asis

@item @bglos{echo stream}  @Noun{}
a @term{stream} @oftype{echo-stream}.

@item @bglos{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}.

@item @bglos{element} @anchor{glos-Elements} @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 @symbolref{read-char, SYM} or @symbolref{read-byte, SYM},
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 @symbolref{write-char, SYM}
or @symbolref{write-byte, SYM}, as appropriate to the @term{stream}).
7. (of a @term{class}) a @term{generalized instance} of the @term{class}.

@item @bglos{element type}  @Noun{}@spc{}
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}.

@item @bglos{em}  @Noun{}@spc{}@Traditional{}@spc{}
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.

@item @bglos{empty list}
 @Noun{}
the @term{list} containing no @term{elements}. See @ref{glos-(), ()}.

@item @bglos{empty type}  @Noun{}
the @term{type} that contains no @term{elements}, and that is
a @term{subtype} of all @term{types} (including itself).
See @ref{glos-nil, nil}.

@item @bglos{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} @term{stream} that is at the @term{end of file}@sub{1}.

@item @bglos{environment}  @Noun{}
1. a set of @term{bindings}. See @ref{Introduction to Environments}.
2. an @term{environment object}.
@gexample{@symbolref{macroexpand, SYM} takes an optional environment argument.}

@item @bglos{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{@symbolref{macroexpand, SYM} takes an optional environment argument.}
(The @term{object} @nil{}@spc{}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}@sub{1} in which the corresponding @term{macro form}
is to be expanded.)
See @ref{Environment Objects}.

@item @bglos{environment parameter}  @Noun{}
A @term{parameter} in a @term{defining form} @mat{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} @mat{f} appeared.

@item @bglos{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}.
See @ref{Error Terminology}.
3. an @term{object} @oftype{error}.

@item @bglos{error output}  @Noun{}@spc{}
the @term{output} @term{stream} which is the @term{value} of the @term{dynamic variable}
@symbolref{*error-output*, SYM}.

@item @bglos{escape}  @Noun{}, @Adjective{}
1. @Noun{}@spc{}a @term{single escape} or a @term{multiple escape}.
2. @Adjective{}@spc{}@term{single escape} or @term{multiple escape}.

@item @bglos{establish}  @TransitiveVerb{}@spc{} @anchor{glos-Establishes}
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{@symbolref{let, SYM} establishes lexical bindings.}

@item @bglos{evaluate}  @TransitiveVerb{}@spc{}(a @term{form} or an @term{implicit progn}) @anchor{glos-Evaluate}
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.

@item @bglos{evaluation}  @Noun{} @anchor{glos-Evaluation}
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 @i{compiling} the @term{form} and then
@i{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.
See @ref{The Evaluation Model}.

@item @bglos{evaluation environment}  @Noun{}
a @term{run-time environment} in which macro expanders
and code specified by @symbolref{eval-when, SYM} to be evaluated
are evaluated.  All evaluations initiated by the @term{compiler}
take place in the @term{evaluation environment}.

@item @bglos{execute}  @TransitiveVerb{}@spc{}@Traditional{}@spc{}(@term{code})
to perform the imperative actions represented by the @term{code}.

@item @bglos{execution time}  @Noun{}
the duration of time that @term{compiled code} is being @term{executed}.

@item @bglos{exhaustive partition}  @Noun{}@spc{}(of a @term{type})
a set of @term{pairwise} @term{disjoint} @term{types} that form an
@term{exhaustive union}.

@item @bglos{exhaustive union}  @Noun{}@spc{}(of a @term{type})
a set of @term{subtypes} of the @term{type},
whose union contains all @term{elements} of that @term{type}.

@item @bglos{exit point}  @Noun{}
a point in a @term{control form}
from which (@eg{} @symbolref{block, SYM}),
through which (@eg{} @symbolref{unwind-protect, SYM}),
or to which (@eg{} @symbolref{tagbody, SYM})
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{@symbolref{catch, SYM} and @symbolref{block, SYM} establish bindings for
exit points to which @symbolref{throw, SYM} and @symbolref{return-from, SYM},
respectively, can transfer control and values;
@symbolref{tagbody, SYM} establishes a binding for an exit point
with lexical extent to which @symbolref{go, SYM} can transfer control;
and @symbolref{unwind-protect, SYM} establishes an exit point
through which control might be transferred by
operators such as @symbolref{throw, SYM}, @symbolref{return-from, SYM},
and @symbolref{go, SYM}.}

@item @bglos{explicit return}  @Noun{}@spc{}
the act of transferring control (and possibly @term{values})
to a @term{block} by using @symbolref{return-from, SYM} (or @symbolref{return, SYM}).

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

@item @bglos{exponent marker}  @Noun{} @anchor{glos-Exponent markers}
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, see @ref{Character Syntax}.
@gexample{The exponent marker `d' in `3.0d7' indicates
that this number is to be represented as a double float.}


@float Figure,fig26.1
@cartouche
@multitable{@f{D} or @f{d}}{@code{float} (see @symbolref{*read-default-float-format*, SYM})}
@headitem Marker @tab Meaning
@item @f{D} or @f{d} @tab @symbolref{double-float, SYM}
@item @f{E} or @f{e} @tab @symbolref{float, SC} (see @symbolref{*read-default-float-format*, SYM})
@item @f{F} or @f{f} @tab @symbolref{single-float, SYM}
@item @f{L} or @f{l} @tab @symbolref{long-float, SYM}
@item @f{S} or @f{s} @tab @symbolref{short-float, SYM}
@end multitable
@end cartouche
@caption{Exponent Markers}
@end float

@anchor{glos-export}
@anchor{glos-exports}
@anchor{glos-exportes}
@anchor{glos-exporting}
@item @b{export}  @TransitiveVerb{}@spc{}(a @term{symbol} in a @term{package})
to add the @term{symbol} to the list of @term{external symbols} of the
@term{package}.

@item @bglos{exported}  @Adjective{}@spc{}(of a @term{symbol} in a @term{package})
being an @term{external symbol} of the @term{package}.

@item @bglos{expressed adjustability}
 @Noun{}@spc{}(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}.
See also @ref{glos-actual adjustability, actual adjustability}.

@item @bglos{expressed array element type}  @Noun{}@spc{}(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{}@spc{}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}.)

@item @bglos{expressed complex part type}  @Noun{}@spc{}(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{}@spc{}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}.)

@item @bglos{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 @symbolref{let, SYM} 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)}.}

@item @bglos{expressly adjustable}  @Adjective{}@spc{}(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.

@item @bglos{extended character}  @Noun{}
a @term{character}
@oftype{extended-char}:
a @term{character} that is not a @term{base character}.

@item @bglos{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}.
See also @ref{glos-function designator, function designator}.

@item @bglos{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{@symbolref{defmacro, SYM} uses extended lambda lists.}

@item @bglos{extension}  @Noun{}
a facility in an @term{implementation} of @clisp{}@spc{}
that is not specified by this standard.

@item @bglos{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.

@item @bglos{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}.

@item @bglos{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).

@item @bglos{external symbol}  @Noun{}@spc{}(of a @term{package})
a @term{symbol} that is part of the `external interface' to the @term{package}
and that are @term{inherited}@sub{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};
see @ref{Symbols as Tokens}.

@item @bglos{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}.


@end table
@node F
@unnumberedsec F
@table @asis

@item @bglos{false}  @Noun{}
the @term{symbol} @nil{},
used to represent the failure of a @term{predicate} test.

@item @bglos{fbound}  @pronounced{@Stress{ef}@stress{ba\.und}} @Adjective{}@spc{}
(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}.
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.)
See the @term{functions} @ref{fboundp} and @symbolref{symbol-function, SYM}.

@item @bglos{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}@sub{1}.
See @ref{Features}.
@gexample{The @kwd{ansi-cl} feature is present in all conforming implementations.}

@item @bglos{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}.
See @ref{Feature Expressions}.

@item @bglos{features list}  @Noun{}
the @term{list} that is @thevalueof{*features*}.

@item @bglos{file}  @Noun{}
a named entry in a @term{file system},
having an @term{implementation-defined} nature.

@item @bglos{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 @symbolref{compile-file, SYM}
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}.

@item @bglos{file position}  @Noun{}@spc{}(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}.

@item @bglos{file position designator}  @Noun{}@spc{}(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).

@item @bglos{file stream}  @Noun{}
an @term{object} @oftype{file-stream}.

@item @bglos{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}.

@item @bglos{filename}  @Noun{}
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{}.

@item @bglos{fill pointer}  @Noun{}@spc{}(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}.)

@item @bglos{finite}  @Adjective{}@spc{}(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 @symbolref{integer, SYM} and @f{(integer 0)} do not.}

@item @bglos{fixnum}  @Noun{}@spc{}
an @term{integer} @oftype{fixnum}.

@item @bglos{float}  @Noun{} @anchor{glos-Floats}
an @term{object} @oftype{float}.

@item @bglos{for-value}  @Adjective{}@spc{}(of a @term{reference} to a @term{binding})
being a @term{reference} that @term{reads}@sub{1}
the @term{value} of the @term{binding}.

@item @bglos{form}  @Noun{} @anchor{glos-Forms}
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 @symbolref{quote, SYM} form is a constant form.}

@item @bglos{formal argument}  @Noun{}@spc{}@Traditional{}@spc{}
a @term{parameter}.

@item @bglos{formal parameter}  @Noun{}@spc{}@Traditional{}@spc{}
a @term{parameter}.

@item @bglos{format}  @TransitiveVerb{}@spc{}(a @term{format control} and @term{format arguments})
to perform output as if by @symbolref{format, SYM},
using the @term{format string} and @term{format arguments}.

@item @bglos{format argument}  @Noun{}
an @term{object} which is used as data by functions such as @symbolref{format, SYM}
which interpret @term{format controls}.

@item @bglos{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}.
See @ref{Compiling Format Strings}.

@item @bglos{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}.  See the @term{function} @ref{format}.
@gexample{In @f{"@tild{}D base 10 = @tild{}8R"}, the character
sequences `@f{@tild{}D}' and `@f{@tild{}8R}' are format directives.}
2. the conceptual category of all @term{format directives}@sub{1}
which use the same dispatch character.
@gexample{Both @f{"@tild{}3d"} and @f{"@tild{}3,'0D"} are valid uses of the
`@f{@tild{}D}' format directive.}

@item @bglos{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 @symbolref{format, SYM}.

@item @bglos{free declaration}  @Noun{}
a declaration that is not a @term{bound declaration}.
See @ref{declare}.

@item @bglos{fresh}  @Adjective{}@spc{}
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}.

@item @bglos{freshline}  @Noun{}
a conceptual operation on a @term{stream}, implemented by @thefunction{fresh-line}
and by the @term{format directive} @f{@tild{}@ampers{}}, 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}.

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

@item @bglos{function}  @Noun{} @anchor{glos-Functions}

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}.

@item @bglos{function block name}  @Noun{}@spc{}(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 @t{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.

@item @bglos{function cell}  @Noun{}@spc{}@Traditional{}@spc{}(of a @term{symbol})
The @term{place} which holds the @i{definition} of the
global @term{function} @term{binding}, if any, named by that @term{symbol},
and which is @term{accessed} by @symbolref{symbol-function, SYM}.
See @ref{glos-cell, cell}.

@item @bglos{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}.
See also @ref{glos-extended function designator, extended function designator}.

@item @bglos{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 @i{evaluating} subsequent
elements of the @term{function form}.

@item @bglos{function name}  @Noun{}@spc{}
1. (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}.
2. A @term{symbol} or a @term{list} @f{(setf @i{symbol})}.

@item @bglos{functional evaluation}  @Noun{}@spc{}
the process of extracting a @term{functional value} from a @term{function name}
or a @term{lambda expression}.
The evaluator performs @term{functional evaluation}
implicitly when it encounters a @term{function name}
or a @term{lambda expression}
in the @term{car} of a @term{compound form},
or explicitly when it encounters a @symbolref{function, SO} @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}.

@item @bglos{functional value}  @Noun{}@spc{}
1. (of a @term{function name} @mat{N} in an @term{environment} @mat{E})
The @term{value} of the @term{binding} named @mat{N}
in the @term{function} @term{namespace} for @term{environment} @mat{E};
that is, the contents of the @term{function cell} named @mat{N} in
@term{environment} @mat{E}.
2. (of an @term{fbound} @term{symbol} @mat{S})
the contents of the @term{symbol}'s @term{function cell}; that is,
the @term{value} of the @term{binding} named @mat{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}.
But if @mat{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}.)

@item @bglos{further compilation}  @Noun{}@spc{}
@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.}


@end table
@node G
@unnumberedsec G
@table @asis

@item @bglos{general}  @Adjective{}@spc{}(of an @term{array})
having @term{element type} @symbolref{t, SC},
and consequently able to have any @term{object} as an @term{element}.

@item @bglos{generalized boolean}
 @Noun{}@spc{}
an @term{object} used as a truth value, where the symbol@tie{}@nil{}@spc{}
represents @term{false} and all other @term{objects} represent @term{true}.
See @ref{glos-boolean, boolean}.

@item @bglos{generalized instance}  @Noun{}@spc{}(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 @mat{X}''
implies ``object of type @mat{X}'' and in cases where @mat{X} is a @term{class}
(or @term{class} @term{name}) the reverse is also true.
The former terminology emphasizes the view of @mat{X} as a @term{class}
while the latter emphasizes the view of @mat{X} as a @term{type specifier}.)

@item @bglos{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.)
See @ref{Generalized Reference}.  See also @term{place}.

@item @bglos{generalized synonym stream}  @Noun{}@spc{}(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}.

@item @bglos{generic function}  @Noun{} @anchor{glos-Generic functions}
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.

@item @bglos{generic function lambda list}  @Noun{}
A @term{lambda list} that is used to describe data flow into a @term{generic function}.
See @ref{Generic Function Lambda Lists}.

@item @bglos{gensym}  @Noun{}@spc{}@Traditional{}@spc{}
an @term{uninterned} @term{symbol}.
See the @term{function} @ref{gensym}.

@item @bglos{global declaration}  @Noun{}@spc{}
a @term{form} that makes certain kinds of information about
code globally available; that is, a @symbolref{proclaim, SYM} @term{form}
or a @symbolref{declaim, SYM} @term{form}.

@item @bglos{global environment}  @Noun{}@spc{}
that part of an @term{environment} that contains @term{bindings}
with @term{indefinite scope} and @term{indefinite extent}.

@item @bglos{global variable}  @Noun{}
a @term{dynamic variable} or a @term{constant variable}.

@item @bglos{glyph}  @Noun{}@spc{}
a visual representation.
@gexample{Graphic characters have associated glyphs.}

@item @bglos{go}  @Verb{}@spc{}
to transfer control to a @term{go point}.
See the @term{special operator} @ref{go}.

@item @bglos{go point}
one of possibly several @term{exit points} that are @term{established}
by @symbolref{tagbody, SYM} (or other abstractions, such as @symbolref{prog, SYM},
which are built from @symbolref{tagbody, SYM}).

@item @bglos{go tag}  @Noun{}@spc{}
the @term{symbol} or @term{integer} that, within the @term{lexical scope}
of a @symbolref{tagbody, SYM} @term{form}, names an @term{exit point}
@term{established} by that @symbolref{tagbody, SYM} @term{form}.

@item @bglos{graphic}  @Adjective{}@spc{}(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}.
See @ref{glos-non-graphic, non-graphic}.


@end table
@node H
@unnumberedsec H
@table @asis

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

@item @bglos{handler}  @Noun{}@spc{} @anchor{glos-Handlers}

a @term{condition handler}.

@item @bglos{hash table}  @Noun{}@spc{}
an @term{object} @oftype{hash-table},
which provides a mapping from @term{keys} to @term{values}.

@item @bglos{home package}  @Noun{}@spc{}(of a @term{symbol}) @anchor{glos-Hash tables} @anchor{glos-Hash Tables}
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{}@spc{}in their
@term{package cell} are said to have no @term{home package}, and also
to be @term{apparently uninterned}.)


@end table
@node I
@unnumberedsec I
@table @asis

@item @bglos{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}.


@float Figure,fig26.2
@cartouche
@multitable{*standard-input*}{*standard-output*}{*trace-output*}

@item *debug-io* @tab *error-io* @tab query-io*
@item *standard-input* @tab *standard-output* @tab *trace-output*
@end multitable
@end cartouche
@caption{Standardized I/O Customization Variables}
@end float


@item @bglos{identical}  @Adjective{}@spc{}
the @term{same} under @symbolref{eq, SYM}.

@item @bglos{identifier}  @Noun{}@spc{}
1. a @term{symbol} used to identify or to distinguish @term{names}.
2. a @term{string} used the same way.

@item @bglos{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.}

@item @bglos{implementation}  @Noun{}@spc{} @anchor{glos-Implementations}
a system, mechanism, or body of @term{code} that implements the semantics of @clisp{}.

@item @bglos{implementation limit}  @Noun{}@spc{}
a restriction imposed by an @term{implementation}.

@item @bglos{implementation-defined}  @Adjective{}@spc{}
@term{implementation-dependent}, but required by this specification to be
defined by each @term{conforming implementation} and to be documented by
the corresponding implementor.

@item @bglos{implementation-dependent}  @Adjective{}@spc{} @anchor{glos-Implementation-dependent}
describing a behavior or aspect of @clisp{}@spc{}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}.
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.''

@item @bglos{implementation-independent}  @Adjective{}@spc{}
used to identify or emphasize a behavior or aspect of @clisp{}@spc{}which does
not vary between @term{conforming implementations}.

@item @bglos{implicit block}  @Noun{}@spc{}
a @term{block} introduced by a @term{macro form}
rather than by an explicit @symbolref{block, SYM} @term{form}.

@item @bglos{implicit compilation}  @Noun{}@spc{}
@term{compilation} performed during @term{evaluation}.

@item @bglos{implicit progn}  @Noun{}@spc{}
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 @symbolref{progn, SYM}.

@item @bglos{implicit tagbody}  @Noun{}@spc{}
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 @symbolref{tagbody, SYM}.

@item @bglos{import}  @TransitiveVerb{}@spc{}(a @term{symbol} into a @term{package})
to make the @term{symbol} be @term{present} in the @term{package}.

@item @bglos{improper list}
 @Noun{}@spc{}
a @term{list} which is not a @term{proper list}:
a @term{circular list} or a @term{dotted list}.

@item @bglos{inaccessible}  @Adjective{}@spc{}
not @term{accessible}.

@item @bglos{indefinite extent}
 @Noun{}@spc{}
an @term{extent} whose duration is unlimited.
@gexample{Most Common Lisp objects have indefinite extent.}

@item @bglos{indefinite scope}  @Noun{}@spc{}
@term{scope} that is unlimited.

@item @bglos{indicator}  @Noun{}@spc{}
a @term{property indicator}.

@item @bglos{indirect instance}  @Noun{}@spc{}(of a @term{class} @mat{C@sub{1}})
an @term{object} of @term{class} @mat{C@sub{2}},
where @mat{C@sub{2}} is a @term{subclass} of @mat{C@sub{1}}.
@gexample{An integer is an indirect instance of the class @symbolref{number, SYM}.}

@item @bglos{inherit}  @TransitiveVerb{}@spc{}
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 @symbolref{use-package, SYM}.

@item @bglos{initial pprint dispatch table}  @Noun{}
@thevalueof{*print-pprint-dispatch*} at the time the @term{Lisp image} is started.

@item @bglos{initial readtable}  @Noun{}
@thevalueof{*readtable*} at the time the @term{Lisp image} is started.

@item @bglos{initialization argument list}  @Noun{}@spc{}
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}.
See @ref{Object Creation and Initialization}.

@item @bglos{initialization form}  @Noun{}@spc{}
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 @symbolref{defclass, SYM} form
is introduced by the keyword @kwd{initform}.}

@item @bglos{input}  @Adjective{}@spc{}(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}.
See the @term{function} @ref{input-stream-p}.

@item @bglos{instance}  @Noun{}@spc{} @anchor{glos-Instances}
1. a @term{direct instance}.
2. a @term{generalized instance}.
3. an @term{indirect instance}.

@item @bglos{integer}  @Noun{}@spc{} @anchor{glos-Integers} @anchor{glos-Integer}
an @term{object} @oftype{integer}, which represents a mathematical integer.

@item @bglos{interactive stream}  @Noun{}@spc{}
a @term{stream} on which it makes sense to perform interactive querying.
See @ref{Interactive Streams}.

@anchor{glos-intern}
@anchor{glos-interns}
@anchor{glos-internes}
@anchor{glos-interning}
@item @b{intern}  @TransitiveVerb{}@spc{} @anchor{glos-Interns} @anchor{glos-Interning}
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{}@spc{}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.

@item @bglos{internal symbol}  @Noun{}@spc{}(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}.

@item @bglos{internal time}  @Noun{} @anchor{glos-Internal time}
@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.
See @ref{Internal Time}.

@item @bglos{internal time unit}  @Noun{}@spc{}
a unit of time equal to @mat{1/n} of a second,
for some @term{implementation-defined} @term{integer} value of @mat{n}.
See the @term{variable} @ref{internal-time-units-per-second}.

@item @bglos{interned}  @Adjective{}@spc{}@Traditional{}@spc{}
1. (of a @term{symbol}) @term{accessible}@sub{3} in
any @term{package}.
2. (of a @term{symbol} in a specific @term{package})
@term{present} in that @term{package}.

@item @bglos{interpreted function}  @Noun{}@spc{}
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}.)

@item @bglos{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.

@item @bglos{interval designator}  @Noun{}@spc{}(of @term{type} @mat{T})
an ordered pair of @term{objects} that describe a @term{subtype} of @mat{T}
by delimiting an interval on the real number line.
See @ref{Interval Designators}.

@item @bglos{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, see @ref{Constituent Characters}.
2. @Adjective{}@spc{}(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}@sub{1}.
See @ref{ConstituentTraitsOfStdChars, Figure 2.8}.

@item @bglos{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}.


@float Figure,fig26.3
@cartouche
@multitable{do-all-symbols}{do-external-symbols}{dotimes}

@item do @tab do-external-symbols @tab dotimes
@item do* @tab do-symbols @tab loop
@item do-all-symbols @tab dolist @tab
@end multitable
@end cartouche
@caption{Standardized Iteration Forms}
@end float


@item @bglos{iteration variable}  @Noun{}
a @term{variable} @mat{V}, the @term{binding} for which was created by an
@term{explicit use} of @mat{V} in an @term{iteration form}.


@end table
@node K
@unnumberedsec K
@table @asis

@item @bglos{key}  @Noun{}@spc{}
an @term{object} used for selection during retrieval.
See @ref{glos-association list, association list}, @term{property list}, and @term{hash table}.
Also, see @ref{Sequence Concepts}.

@item @bglos{keyword}  @Noun{}@spc{} @anchor{glos-Keywords}
1. a @term{symbol} the @term{home package} of which is the @code{KEYWORD} @term{package}.
2. any @term{symbol}, usually but not necessarily in the @code{KEYWORD} @term{package},
that is used as an identifying marker in keyword-style argument passing.
See @ref{lambda (Symbol)}.
3. @Idiomatic{}@spc{}a @term{lambda list keyword}.

@item @bglos{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.
See also @ref{glos-supplied-p parameter, supplied-p parameter}.

@item @bglos{keyword/value pair}  @Noun{}@spc{}
two successive @term{elements} (a @term{keyword} and a @term{value},
respectively) of a @term{property list}.


@end table
@node L
@unnumberedsec L
@table @asis

@item @bglos{lambda combination}  @Noun{}@spc{}@Traditional{}@spc{}
a @term{lambda form}.

@item @bglos{lambda expression}  @Noun{}@spc{}
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}.
See @ref{lambda (Symbol)}.

@item @bglos{lambda form}  @Noun{}@spc{}
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 @i{evaluating}
subsequent elements of the @term{lambda form}.

@item @bglos{lambda list}  @Noun{}@spc{}
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}.

@item @bglos{lambda list keyword}  @Noun{}@spc{}
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 the @code{KEYWORD} @term{package}.

@item @bglos{lambda variable}  @Noun{}@spc{}
a @term{formal parameter}, used to emphasize the @term{variable}'s
relation to the @term{lambda list} that @term{established} it.

@item @bglos{leaf}  @Noun{}@spc{} @anchor{glos-leaves}
1. an @term{atom} in a @term{tree}@sub{1}.
2. a terminal node of a @term{tree}@sub{2}.

@item @bglos{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{}@spc{}@term{time} representations ignore
@term{leap seconds}; every day is assumed to be exactly 86400 seconds
long.

@item @bglos{left-parenthesis}  @Noun{}
the @term{standard character} ``@f{(}'',
that is variously called
``left parenthesis''
or ``open parenthesis''
See @ref{StdCharsThree, Figure 2.5}.

@item @bglos{length}  @Noun{}@spc{}(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.)

@item @bglos{lexical binding}  @Noun{}@spc{}
a @term{binding} in a @term{lexical environment}.

@item @bglos{lexical closure}  @Noun{}@spc{}
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}.

@item @bglos{lexical environment}  @Noun{}@spc{}
that part of the @term{environment} that contains @term{bindings}
whose names have @term{lexical scope}. A @term{lexical environment}
contains, among other things:
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} (see @ref{declare}).

@item @bglos{lexical scope}  @Noun{}@spc{}
@term{scope} that is limited to a spatial or textual region within the
establishing @term{form}.
@gexample{The names of parameters to a function normally are lexically scoped.}

@item @bglos{lexical variable}  @Noun{}@spc{}
a @term{variable} the @term{binding} for which is in the
@term{lexical environment}.

@item @bglos{Lisp image}  @Noun{}
a running instantiation of a @clisp{}@spc{}@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}.)

@item @bglos{Lisp printer}  @Noun{}@spc{}@Traditional{}@spc{} @anchor{glos-Lisp Printer}
the procedure that prints the character representation of an
@term{object} onto a @term{stream}. (This procedure is implemented
by @thefunction{write}.)

@item @bglos{Lisp read-eval-print loop}  @Noun{}@spc{}@Traditional{}@spc{}
an endless loop that @term{reads}@sub{2} a @term{form},
@term{evaluates} it,
and prints (@ie{} @term{writes}@sub{2}) the results.
In many @term{implementations},
the default mode of interaction with @clisp{}@spc{}during program development
is through such a loop.

@item @bglos{Lisp reader}  @Noun{}@spc{}@Traditional{}@spc{} @anchor{glos-Lisp Reader}
the procedure that parses character representations of @term{objects}
from a @term{stream}, producing @term{objects}.
(This procedure is implemented by @thefunction{read}.)


@item @bglos{list}  @Noun{}@spc{} @anchor{glos-Lists}
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}.
See also @ref{glos-proper list, proper list},
@term{dotted list},
or @term{circular list}.
2. the @term{type} that is the union of @symbolref{null, SC} and @symbolref{cons, SC}.

@item @bglos{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).

@item @bglos{list structure}  @Noun{}@spc{}(of a @term{list})
the set of @term{conses} that make up the @term{list}.
Note that while the @term{car}[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}@sub{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}@sub{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.)

@item @bglos{literal}  @Adjective{}@spc{}(of an @term{object}) @anchor{glos-Literal}
referenced directly in a program rather than being computed by the program;
that is,
appearing as data in a @symbolref{quote, SYM} @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.}

@item @bglos{load}  @TransitiveVerb{}@spc{}(a @term{file}) @anchor{glos-Loading}
to cause the @term{code} contained in the @term{file} to be @term{executed}.
See the @term{function} @ref{load}.

@item @bglos{load time}  @Noun{}
the duration of time that the loader is @term{loading} @term{compiled code}.

@item @bglos{load time value}  @Noun{}@spc{}
an @term{object} referred to in @term{code} by a @symbolref{load-time-value, SYM}
@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.  See the @term{special operator} @ref{load-time-value}.

@item @bglos{loader}  @Noun{}
a facility that is part of Lisp and that @term{loads} a @term{file}.
See the @term{function} @ref{load}.

@item @bglos{local declaration}  @Noun{}@spc{}
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 @t{declare} @term{expression}.

@item @bglos{local precedence order}  @Noun{}@spc{}(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}.

@item @bglos{local slot}  @Noun{}@spc{}(of a @term{class}) @anchor{glos-Local slots}
a @term{slot} @term{accessible} in only one @term{instance},
namely the @term{instance} in which the @term{slot} is allocated.

@item @bglos{logical block}  @Noun{}
a conceptual grouping of related output used by the @term{pretty printer}.
See the @term{macro} @ref{Dynamic Control of the Arrangement of Output}.

@item @bglos{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}.
See @ref{Logical Pathnames}.

@item @bglos{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.)

@item @bglos{logical pathname}  @Noun{}@spc{} @anchor{glos-Logical pathname} @anchor{glos-Logical pathnames}
an @term{object} @oftype{logical-pathname}.

@item @bglos{long float}  @Noun{}@spc{}
an @term{object} @oftype{long-float}.

@item @bglos{loop keyword}  @Noun{}@spc{}@Traditional{} @anchor{glos-Loop keywords}
a symbol that is a specially recognized part of the syntax of
an extended @symbolref{loop, SYM} @term{form}.  Such symbols are recognized by their
@term{name} (using @symbolref{string=, SYM}), not by their identity; as such, they
may be in any package.  A @term{loop keyword} is not a @term{keyword}.

@item @bglos{lowercase}  @Adjective{}@spc{}(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}.
See @ref{Characters With Case}.


@end table
@node M
@unnumberedsec M
@table @asis

@item @bglos{macro}  @Noun{}@spc{} @anchor{glos-Macro} @anchor{glos-Macros}
1. a @term{macro form}
2. a @term{macro function}.
3. a @term{macro name}.

@item @bglos{macro character}  @Noun{}@spc{} @anchor{glos-Macro characters}
a @term{character} which, when encountered by the @term{Lisp reader}
in its main dispatch loop, introduces a @term{reader macro}@sub{1}.
(@term{Macro characters} have nothing to do with @term{macros}.)

@item @bglos{macro expansion}  @Noun{}@spc{}
1. the process of translating a @term{macro form} into another
@term{form}.
2. the @term{form} resulting from this process.

@item @bglos{macro form}  @Noun{}@spc{} @anchor{glos-Macro forms}
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}.

@item @bglos{macro function}  @Noun{}@spc{}
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}.

@item @bglos{macro lambda list}  @Noun{}
an @term{extended lambda list} used in @term{forms} that @term{establish}
@term{macro} definitions, such as @symbolref{defmacro, SYM} and @symbolref{macrolet, SYM}.
See @ref{Macro Lambda Lists}.

@item @bglos{macro name}  @Noun{}@spc{}
a @term{name} for which @symbolref{macro-function, SYM} 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}.

@item @bglos{macroexpand hook}  @Noun{}
the @term{function} that is @thevalueof{*macroexpand-hook*}.

@item @bglos{mapping}  @Noun{}@spc{}
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{}@spc{}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'').

@item @bglos{metaclass}  @Noun{}@spc{}
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}.

@item @bglos{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{}.

@item @bglos{method}  @Noun{}@spc{} @anchor{glos-Method} @anchor{glos-Methods}
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.

@item @bglos{method combination}  @Noun{}@spc{}
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}@sub{1} for one or more
specific @term{generic functions} is to be performed.

@item @bglos{method-defining form}  @Noun{}@spc{}
a @term{form} that defines a @term{method} for a @term{generic function},
whether explicitly or implicitly.
See @ref{Introduction to Generic Functions}.

@item @bglos{method-defining operator}  @Noun{}
an @term{operator} corresponding to a @term{method-defining form}.
See @ref{StdMethDefOps, Figure 7.1}.

@item @bglos{minimal compilation}  @Noun{} @anchor{glos-Minimal compilation}
actions the @term{compiler} must take at compile time.
See @ref{Compilation Semantics}.

@item @bglos{modified lambda list}
 @Noun{}@spc{}
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}.
See @ref{glos-ordinary lambda list, ordinary lambda list}.
@gexample{@symbolref{deftype, SYM} uses a modified lambda list.}

@item @bglos{most recent}  @Adjective{}
innermost;
that is, having been @term{established} (and not yet @term{disestablished})
more recently than any other of its kind.

@item @bglos{multiple escape}  @Noun{}, @Adjective{}
1. @Noun{}@spc{}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}@sub{2} @term{characters}
with their @term{case} preserved.
For details, see @ref{Multiple Escape Characters}.
2. @Adjective{}@spc{}(of a @term{character})
having the @term{multiple escape} @term{syntax type}.
3. @Noun{}@spc{}a @term{multiple escape}@sub{2} @term{character}.
(In the @term{standard readtable},
@term{vertical-bar} is a @term{multiple escape} @term{character}.)

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


@end table
@node N
@unnumberedsec N
@table @asis

@item @bglos{name}  @Noun{}, @TransitiveVerb{}@spc{} @anchor{glos-Names}
1. @Noun{}@spc{}an @term{identifier} by which an @term{object},
a @term{binding}, or an @term{exit point}
is referred to by association using a @term{binding}.
2. @TransitiveVerb{}@spc{}to give a @term{name} to.
3. @Noun{}@spc{}(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 @symbolref{symbol-name, SYM}.}
4. @Noun{}@spc{}(of a @term{pathname})
a. the name component, returned by @symbolref{pathname-name, SYM}.
b. the entire namestring, returned by @symbolref{namestring, SYM}.
5. @Noun{}@spc{}(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}.)

@item @bglos{named constant}  @Noun{}@spc{}
a @term{variable} that is defined by @clisp{},
by the @term{implementation},
or by user code (see the @term{macro} @ref{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.}

@item @bglos{namespace}  @Noun{}@spc{}
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.}

@item @bglos{namestring}  @Noun{}@spc{} @anchor{glos-Namestrings}
a @term{string} that represents a @term{filename}
using either the @term{standardized} notation for naming @term{logical pathnames}
described in @ref{Syntax of Logical Pathname Namestrings},
or some @term{implementation-defined} notation for naming a @term{physical pathname}.

@item @bglos{newline}  @Noun{}
the @term{standard character} @NewlineChar{},
notated for the @term{Lisp reader} as @f{#@bsl{}Newline}.

@item @bglos{next method}  @Noun{}@spc{}
the next @term{method} to be invoked with respect to a given
@term{method} for a particular set of arguments or argument
@term{classes}.
See @ref{Applying method combination to the sorted list of applicable methods}.

@item @bglos{nickname}  @Noun{}@spc{}(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}.

@item @bglos{nil}
 @Noun{}@spc{}
the @term{object} that is at once
the @term{symbol} named @f{"NIL"} in the @code{COMMON-LISP} @term{package},
the @term{empty list},
the @term{boolean} (or @term{generalized boolean}) representing @term{false},
and the @term{name} of the @term{empty type}.

@item @bglos{non-atomic}  @Adjective{}@spc{}
being other than an @term{atom}; @ie{} being a @term{cons}.

@item @bglos{non-constant variable}  @Noun{} @anchor{glos-Non-constant variables}
a @term{variable} that is not a @term{constant variable}.

@item @bglos{non-correctable}  @Adjective{}@spc{}(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.)

@item @bglos{non-empty}  @Adjective{}
having at least one @term{element}.

@item @bglos{non-generic function}  @Noun{}@spc{}
a @term{function} that is not a @term{generic function}.

@item @bglos{non-graphic} @anchor{glos-Non-graphic}
 @Adjective{}@spc{}(of a @term{character})
not @term{graphic}.
See @ref{Graphic Characters}.

@item @bglos{non-list}  @Noun{}, @Adjective{}@spc{}
other than a @term{list}; @ie{} a @term{non-nil} @term{atom}.

@item @bglos{non-local exit}  @Noun{}@spc{}
a transfer of control (and sometimes @term{values}) to
an @term{exit point} for reasons other than a @term{normal return}.
@gexample{The operators @symbolref{go, SYM}, @symbolref{throw, SYM},
and @symbolref{return-from, SYM} cause a non-local exit.}

@item @bglos{non-nil}  @Noun{}, @Adjective{}@spc{}
not @nil{}.  Technically, any @term{object} which is not @nil{}@spc{}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.

@item @bglos{non-null lexical environment}  @Noun{}@spc{}
a @term{lexical environment} that has additional information not present in
the @term{global environment}, such as one or more @term{bindings}.

@item @bglos{non-simple}  @Adjective{}
not @term{simple}.

@item @bglos{non-terminating}  @Adjective{}@spc{}(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.
See @ref{Reader Algorithm}.

@item @bglos{non-top-level form}  @Noun{}@spc{}
a @term{form} that, by virtue of its position as a @term{subform}
of another @term{form}, is not a @term{top level form}.
See @ref{Processing of Top Level Forms}.

@item @bglos{normal return}  @Noun{}@spc{}
the natural transfer of control and @term{values} which occurs after
the complete @i{execution} of a @term{form}.

@item @bglos{normalized}  @Adjective{}, @ANSI{}, @IEEE{}@spc{}(of a @term{float})
conforming to the description of ``normalized'' as described by @IEEEFloatingPoint{}.
See @ref{glos-denormalized, denormalized}.

@item @bglos{null}  @Adjective{}, @Noun{}@spc{}
1. @Adjective{}@spc{}
a. (of a @term{list}) having no @term{elements}: empty.  See @ref{glos-empty list, 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}@sub{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{}@spc{}an @term{object} @oftype{null} (the only such @term{object} being @nil{}).

@item @bglos{null lexical environment}  @Noun{}@spc{}
the @term{lexical environment} which has no @term{bindings}.

@item @bglos{number}  @Noun{} @anchor{glos-Numbers}
an @term{object} @oftype{number}.

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


@end table
@node O
@unnumberedsec O
@table @asis

@item @bglos{object}  @Noun{}@spc{} @anchor{glos-Object} @anchor{glos-Objects}
1. any Lisp datum.
@gexample{The function @symbolref{cons, F} 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 @symbolref{function, SC} or @symbolref{class, SYM}) are commonly
referred to by @term{name}.
@gexample{The function @symbolref{symbol-function, SYM} takes a function name
and returns a function object.}

@item @bglos{object-traversing}  @Adjective{}@spc{}
operating in succession on components of an @term{object}.
@gexample{The operators @symbolref{mapcar, SYM}, @symbolref{maphash, SYM},
@symbolref{with-package-iterator, SYM} and @symbolref{count, SYM}
perform object-traversing operations.}

@item @bglos{open}  @Adjective{}, @TransitiveVerb{}@spc{}(a @term{file})
1. @TransitiveVerb{}@spc{}to create and return a @term{stream} to the @term{file}.
2. @Adjective{}@spc{}(of a @term{stream})
having been @term{opened}@sub{1}, but not yet @term{closed}.

@item @bglos{operator}  @Noun{}@spc{} @anchor{glos-Operators}
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 @symbolref{function, SO} @term{special form})
the @term{cadr} of the @symbolref{function, SO} @term{special form}, which
might be either an @term{operator}@sub{2} or a @term{lambda expression}.
4. (of a @term{compound form})
the @term{car} of the @term{compound form}, which might be
either an @term{operator}@sub{2}
or a @term{lambda expression}, and which is never @f{(setf @term{symbol})}.

@item @bglos{optimize quality}  @Noun{}@spc{}@anchor{glos-optimize qualities}
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 @symbolref{optimize, SYM} @term{declaration}.
The @term{standardized} @term{optimize qualities} are
@f{compilation-speed} (speed of the compilation process),
@f{debug} (ease of debugging),
@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}.

@item @bglos{optional parameter}  @Noun{} @anchor{glos-Optional parameters}
A @term{parameter} for which a corresponding positional @term{argument}
is optional.  If the @term{argument} is not supplied, a default value
is used.  See also @ref{glos-supplied-p parameter, supplied-p parameter}.

@item @bglos{ordinary function}  @Noun{}@spc{} @anchor{glos-Ordinary functions}
a @term{function} that is not a @term{generic function}.

@item @bglos{ordinary lambda list}
 @Noun{}@spc{}
the kind of @term{lambda list} used by @t{lambda}.
See @ref{glos-modified lambda list, modified lambda list} and @term{extended lambda list}.
@gexample{@symbolref{defun, SYM} uses an ordinary lambda list.}

@item @bglos{otherwise inaccessible part}  @Noun{}@spc{}(of an @term{object}, @mat{O@sub{1}})
an @term{object}, @mat{O@sub{2}}, which would be made @term{inaccessible} if
@mat{O@sub{1}} were made @term{inaccessible}.  (Every @term{object} is an
@term{otherwise inaccessible part} of itself.)

@item @bglos{output}  @Adjective{}@spc{}(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}.
See the @term{function} @ref{output-stream-p}.


@end table
@node P
@unnumberedsec P
@table @asis

@item @bglos{package}  @Noun{}@spc{} @anchor{glos-Packages}
an @term{object} @oftype{package}.

@item @bglos{package cell}  @Noun{}@spc{}@Traditional{}@spc{}(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{}@spc{}if no such @term{package} exists or is known.
See the @term{function} @ref{symbol-package}.

@item @bglos{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).

@item @bglos{package marker}  @Noun{}@spc{}
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}.
See @ref{Character Syntax}.

@item @bglos{package prefix}  @Noun{}@spc{} @anchor{glos-Package prefixes}
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}.

@item @bglos{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 @symbolref{find-package, SYM} consult this mapping in order
to find a @term{package} from its @term{name}.
@term{Operators} such as @symbolref{do-all-symbols, SYM}, @symbolref{find-all-symbols, SYM},
and @symbolref{list-all-packages, SYM} operate only on @term{packages} that exist
in the @term{package registry}.

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

@item @bglos{parallel}
 @Adjective{}@spc{}@Traditional{}@spc{}(of @term{binding} or @i{assignment})
done in the style of @symbolref{psetq, SYM}, @symbolref{let, SYM}, or @symbolref{do, SYM};
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{cons}).
Note that this does not imply traditional computational ``parallelism''
since the @term{forms} that produce @term{values} are evaluated @term{sequentially}.
See @ref{glos-sequential, sequential}.

@item @bglos{parameter}  @Noun{}@spc{}
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})
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.
See @ref{Formatted Output}.
@gexample{In @f{"@tild{}3,'0D"}, the number @f{3} and the character
@f{#@bsl{}0} are parameters to the @f{@tild{}D} format directive.}

@item @bglos{parameter specializer}  @Noun{}@spc{}
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})}.

@item @bglos{parameter specializer name}  @Noun{}@spc{} @anchor{glos-Parameter specializer names}
1. (of a @term{method} definition) an expression used in code to
name a @term{parameter specializer}.
See @ref{Introduction to Methods}.
2. a @term{class},
a @term{symbol} naming a @term{class},
or a @term{list} @f{(eql @term{form})}.

@item @bglos{pathname}  @Noun{}@spc{} @anchor{glos-Pathname} @anchor{glos-Pathnames}
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.''

@item @bglos{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:
a @term{pathname} @term{namestring}
(denoting the corresponding @term{pathname}),
a @term{stream associated with a file}
(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).
See @ref{Open and Closed Streams}.

@item @bglos{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.}

@item @bglos{place}  @Noun{}@spc{} @anchor{glos-Places}
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}@sub{1}.

@item @bglos{plist}  @pronounced{@Stress{p@harde{}}@stress{list}} @Noun{}@spc{}
a @term{property list}.

@item @bglos{portable}  @Adjective{}@spc{}(of @term{code}) @anchor{glos-Portable}
required to produce equivalent results and observable side effects
in all @term{conforming implementations}.

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

@item @bglos{potential number}  @Noun{}@spc{}
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.
See @ref{Potential Numbers as Tokens}.

@item @bglos{pprint dispatch table}  @Noun{}@spc{}
an @term{object} that can be @thevalueof{*print-pprint-dispatch*}
and hence can control how @term{objects} are printed when
@symbolref{*print-pretty*, SYM} is @term{true}.
See @ref{Pretty Print Dispatch Tables}.

@item @bglos{predicate}  @Noun{}@spc{}
a @term{function} that returns a @term{generalized boolean}
as its first value.

@item @bglos{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}.

@item @bglos{pretty print}  @TransitiveVerb{}@spc{}(an @term{object})
to invoke the @term{pretty printer} on the @term{object}.

@item @bglos{pretty printer}  @Noun{}@spc{}
the procedure that prints the character representation of an
@term{object} onto a @term{stream} when the @term{value} of
@symbolref{*print-pretty*, SYM} 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.
See the @term{variable} @ref{The Lisp Pretty Printer}.

@item @bglos{pretty printing stream}  @Noun{}@spc{}
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.

@item @bglos{primary method}  @Noun{}@spc{}
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;
see @ref{Introduction to Methods}.

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

@item @bglos{principal}  @Adjective{}@spc{}(of a value returned by a @clisp{}@spc{}@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{}@spc{}@term{function} has been defined to return.

@item @bglos{print name}  @Noun{}@spc{}@Traditional{}@spc{}(usually of a @term{symbol})
a @term{name}@sub{3}.

@item @bglos{printer control variable}  @Noun{}@spc{}
a @term{variable} whose specific purpose is to control some action
of the @term{Lisp printer}; that is, one of the @term{variables}
in @ref{StdPrinterControlVars, Figure 22.1},
or else some @term{implementation-defined} @term{variable} which is
defined by the @term{implementation} to be a @term{printer control variable}.

@item @bglos{printer escaping}  @Noun{}
The combined state of the @term{printer control variables}
@symbolref{*print-escape*, SYM} and @symbolref{*print-readably*, SYM}.
If the value of either @symbolref{*print-readably*, SYM} or @symbolref{*print-escape*, SYM} is @term{true},
then @newterm{printer escaping} is ``enabled'';
otherwise (if the values of both @symbolref{*print-readably*, SYM} and @symbolref{*print-escape*, SYM}
are @term{false}),
then @term{printer escaping} is ``disabled''.

@item @bglos{printing}  @Adjective{}@spc{}(of a @term{character})
being a @term{graphic} @term{character} other than @term{space}.

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

@item @bglos{processor}  @Noun{}, @ANSI{}
an @term{implementation}.

@item @bglos{proclaim}  @TransitiveVerb{}@spc{}(a @term{proclamation})
to @term{establish} that @term{proclamation}.

@item @bglos{proclamation}  @Noun{}@spc{}
a @term{global declaration}.

@item @bglos{prog tag}  @Noun{}@spc{}@Traditional{}@spc{}
a @term{go tag}.

@item @bglos{program}  @Noun{}@spc{}@Traditional{}@spc{} @anchor{glos-Programs}
@clisp{}@spc{}@term{code}.

@item @bglos{programmer}  @Noun{} @anchor{glos-Programmers}
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}.

@item @bglos{programmer code}  @Noun{}@spc{}
@term{code} that is supplied by the programmer;
that is, @term{code} that is not @term{system code}.

@item @bglos{proper list}
 @Noun{}@spc{}
A @term{list} terminated by the @term{empty list}.
(The @term{empty list} is a @term{proper list}.)
See @ref{glos-improper list, improper list}.

@item @bglos{proper name}  @Noun{}@spc{}(of a @term{class})
a @term{symbol} that @term{names} the @term{class} whose @term{name}
is that @term{symbol}.
See the @term{functions} @ref{class-name} and @symbolref{find-class, SYM}.

@item @bglos{proper sequence}  @Noun{}@spc{}
a @term{sequence} which is not an @term{improper list};
that is, a @term{vector} or a @term{proper list}.

@item @bglos{proper subtype}  @Noun{}@spc{}(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}).

@item @bglos{property}  @Noun{}@spc{}(of a @term{property list}) @anchor{glos-properties}
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}.

@item @bglos{property indicator}  @Noun{}@spc{}(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}.

@item @bglos{property list}  @Noun{}@spc{}
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}.
2. (of a @term{symbol})
the component of the @term{symbol} containing a @term{property list}.


@item @bglos{property value}  @Noun{}@spc{}(of a @term{property indicator} on
a @term{property list})
the @term{object} associated with the @term{property indicator}
on the @term{property list}.

@item @bglos{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
@i{purport to conform}.  This is an important distinction in
certain specific cases; @eg{} see the @term{variable} @ref{*features*}.


@end table
@node Q
@unnumberedsec Q
@table @asis

@item @bglos{qualified method}  @Noun{}@spc{}
a @term{method} that has one or more @term{qualifiers}.

@item @bglos{qualifier}  @Noun{}@spc{}(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}.

@item @bglos{query I/O}  @Noun{}@spc{}
the @term{bidirectional} @term{stream}
that is the @term{value} of @thevariable{*query-io*}.

@item @bglos{quoted object}  @Noun{}@spc{}
an @term{object} which is the second element of a
@symbolref{quote, SYM} @term{form}.


@end table
@node R
@unnumberedsec R
@table @asis

@item @bglos{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.
(There are @mat{n} valid digit characters for any given @term{radix} @mat{n},
and those digits are the first @mat{n} digits in the sequence
@f{0}, @f{1}, @mat{@ldots{}}, @f{9}, @f{A}, @f{B}, @mat{@ldots{}}, @f{Z},
which have the weights
@f{0}, @f{1}, @mat{@ldots{}}, @f{9}, @f{10}, @f{11}, @mat{@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.)

@item @bglos{random state}  @Noun{}@spc{}
an @term{object} @oftype{random-state}.

@item @bglos{rank}  @Noun{}@spc{}
a non-negative @term{integer} indicating the number of
@term{dimensions} of an @term{array}.

@item @bglos{ratio}  @Noun{}@spc{} @anchor{glos-Ratios}
an @term{object} @oftype{ratio}.

@item @bglos{ratio marker}  @Noun{}@spc{}
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}.
See @ref{Character Syntax}.

@item @bglos{rational}  @Noun{}@spc{}
an @term{object} @oftype{rational}.

@item @bglos{read}  @TransitiveVerb{}@spc{} @anchor{glos-Read}
1. (a @term{binding} or @term{slot} or component)
to obtain the @term{value} of the @term{binding} or @term{slot}.
2. (an @term{object} from a @term{stream})
to parse an @term{object} from its representation on the @term{stream}.

@item @bglos{readably}  @Adverb{}@spc{}(of a manner of printing an @term{object} @mat{O@sub{1}})
in such a way as to permit the @term{Lisp Reader} to later @i{parse}
the printed output into an @term{object} @mat{O@sub{2}} that is @term{similar} to @mat{O@sub{1}}.

@item @bglos{reader} @anchor{glos-Reader}
 @Noun{}
1. a @term{function} that @term{reads}@sub{1} a @term{variable} or @term{slot}.
2. the @term{Lisp reader}.

@item @bglos{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}.
See @ref{Reader Algorithm}.
2. the @term{character} or @term{characters} that introduce
a @term{reader macro}@sub{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}.)

@item @bglos{reader macro function}  @Noun{}
a @term{function} @term{designator} that denotes a @term{function}
that implements a @term{reader macro}@sub{2}.
See the @term{functions} @ref{set-macro-character} and @symbolref{set-dispatch-macro-character, SYM}.

@item @bglos{readtable}  @Noun{}
an @term{object} @oftype{readtable}.

@item @bglos{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}.
See @ref{Effect of Readtable Case on the Lisp Printer}.

@item @bglos{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{}@spc{}(denoting the @term{standard readtable}),
or a @term{readtable} (denoting itself).

@item @bglos{recognizable subtype}  @Noun{}@spc{}(of a @term{type})
a @term{subtype} of the @term{type} which can be reliably detected
to be such by the @term{implementation}.
See the @term{function} @ref{subtypep}.

@item @bglos{reference}  @Noun{}, @TransitiveVerb{}@spc{}
1. @Noun{}@spc{}an act or occurrence of referring to an @term{object},
a @term{binding}, an @term{exit point}, a @term{tag},
or an @term{environment}.
2. @TransitiveVerb{}@spc{}to refer to an @term{object}, a @term{binding}, an
@term{exit point}, a @term{tag}, or an @term{environment},
usually by @term{name}.

@item @bglos{registered package}  @Noun{} @anchor{glos-Registered packages}
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{}@spc{}
or created by @symbolref{make-package, SYM} or @symbolref{defpackage, SYM}
are @term{registered packages}.  @term{Registered packages} can be turned into
@term{unregistered packages} by @symbolref{delete-package, SYM}.)

@item @bglos{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.}
See @ref{glos-absolute, absolute}.

@item @bglos{repertoire}  @Noun{}, @ISO{}
a @term{subtype} of @symbolref{character, SC}.  See @ref{Character Repertoires}.

@item @bglos{report}  @Noun{}@spc{}(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}.

@item @bglos{report message}  @Noun{}
the text that is output by a @term{condition reporter}.

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

@item @bglos{rest list}  @Noun{}@spc{}(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}.

@item @bglos{rest parameter}  @Noun{}
A @term{parameter} which was introduced by @keyref{rest}.

@item @bglos{restart}  @Noun{}@spc{} @anchor{glos-Restarts}
an @term{object} @oftype{restart}.

@item @bglos{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).

@item @bglos{restart function}  @Noun{} @anchor{glos-Restart functions}
a @term{function} that invokes a @term{restart}, as if by @symbolref{invoke-restart, SYM}.
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{}@spc{}shows a list of the
@term{standardized} @term{restart functions}.


@float Figure,fig26.4
@cartouche
@multitable{continue}{muffle-warning}{use-value}

@item abort @tab muffle-warning @tab use-value
@item continue @tab store-value @tab
@end multitable
@end cartouche
@caption{Standardized Restart Functions}
@end float


@item @bglos{return}  @TransitiveVerb{}@spc{}(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}.

@item @bglos{return value}  @Noun{}@spc{}@Traditional{}@spc{}
a @term{value}@sub{1}

@item @bglos{right-parenthesis}  @Noun{}
the @term{standard character} ``@f{)}'',
that is variously called
``right parenthesis''
or ``close parenthesis''
See @ref{StdCharsThree, Figure 2.5}.

@item @bglos{run time}  @Noun{}
1. @term{load time}
2. @term{execution time}

@item @bglos{run-time compiler}  @Noun{}
refers to the @symbolref{compile, SYM} function or to @term{implicit compilation},
for which the compilation and run-time @term{environments} are maintained
in the same @term{Lisp image}.

@item @bglos{run-time definition}  @Noun{}
a definition in the @term{run-time environment}.

@item @bglos{run-time environment}  @Noun{}
the @term{environment} in which a program is @term{executed}.


@end table
@node S
@unnumberedsec S
@table @asis

@item @bglos{safe}  @Adjective{}@spc{}
1. (of @term{code})
processed in a @term{lexical environment} where the the highest
@ref{optimize, @code{safety}} level (@f{3}) was in effect.
See @ref{optimize}.
2. (of a @term{call}) a @term{safe call}.

@item @bglos{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}@sub{1} @term{code}.
For more detailed information, see @ref{Safe and Unsafe Calls}.

@item @bglos{same}  @Adjective{}@spc{}
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 @symbolref{string-equal, SYM}}.
2. (of @term{objects} if no predicate is implied by context)
indistinguishable by @symbolref{eql, F}.
Note that @symbolref{eq, SYM} might be capable of distinguishing some
@term{numbers} and @term{characters} which @symbolref{eql, F} cannot
distinguish, but the nature of such, if any,
is @term{implementation-dependent}.
Since @symbolref{eq, SYM} is used only rarely in this specification,
@symbolref{eql, F} is the default predicate when none is mentioned explicitly.
@gexample{The conses returned by two successive calls to @symbolref{cons, F}
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.}

@item @bglos{satisfy the test}  @Verb{}@spc{}
(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.
See @ref{Satisfying a One-Argument Test}.
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 @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}.
See @ref{Satisfying a Two-Argument Test}.

@item @bglos{scope}  @Noun{}@spc{}
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.

@item @bglos{script}  @Noun{}@spc{}@ISO{}
one of possibly several sets that form an @term{exhaustive partition}
of the type @symbolref{character, SC}.  See @ref{Character Scripts}.

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

@item @bglos{section}  @Noun{}
a partitioning of output by a @term{conditional newline} on a @term{pretty printing stream}.
See @ref{Dynamic Control of the Arrangement of Output}.

@item @bglos{self-evaluating object}  @Noun{} @anchor{glos-Self-evaluating objects}
an @term{object} that is neither a @term{symbol} nor a
@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.}

@item @bglos{semi-standard}  @Adjective{}@spc{}(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.

@item @bglos{semicolon}  @Noun{}
the @term{standard character} that is called ``semicolon'' (@f{;}).
See @ref{StdCharsThree, Figure 2.5}.

@item @bglos{sequence}  @Noun{}@spc{} @anchor{glos-Sequences}
1. an ordered collection of elements
2. a @term{vector} or a @term{list}.

@item @bglos{sequence function}  @Noun{}
one of the @term{functions} in @ref{SequenceFunctions, Figure 17.1},
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}.

@item @bglos{sequential} @anchor{glos-Sequential}
 @Adjective{}@spc{}@Traditional{}@spc{}(of @term{binding} or @i{assignment})
done in the style of @symbolref{setq, SYM}, @symbolref{let*, SYM}, or @symbolref{do*, SYM};
that is, interleaving the evaluation of the @term{forms} that produce @term{values}
with the @i{assignments} or @term{bindings} of the @term{variables} (or @term{cons}).
See @ref{glos-parallel, parallel}.

@item @bglos{sequentially}  @Adverb{}
in a @term{sequential} way.

@item @bglos{serious condition}  @Noun{}@spc{} @anchor{glos-Serious conditions}
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}.

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

@item @bglos{set}  @TransitiveVerb{}@spc{}@Traditional{}@spc{}(any @term{variable}
or a @term{symbol} that
is the @term{name} of a @term{dynamic variable})
to @term{assign} the @term{variable}.

@item @bglos{setf expander}  @Noun{}@spc{}
a function used by @symbolref{setf, SYM} to compute the @term{setf expansion}
of a @term{place}.

@item @bglos{setf expansion}  @Noun{}@spc{}
a set of five @term{expressions}@sub{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.
See @ref{Setf Expansions}.

@item @bglos{setf function}  @Noun{}
a @term{function} whose @term{name} is @f{(setf @term{symbol})}.

@item @bglos{setf function name}  @Noun{}@spc{}(of a @term{symbol} @param{S})
the @term{list} @f{(setf @param{S})}.

@item @bglos{shadow}  @TransitiveVerb{}@spc{}
1. to override the meaning of.
@gexample{That binding of @f{X} shadows an outer one.}
2. to hide the presence of.
@gexample{That @symbolref{macrolet, SYM} of @f{F} shadows the
outer @symbolref{flet, SYM} of @f{F}.}
3. to replace.
@gexample{That package shadows the symbol @f{cl:car} with
its own symbol @f{car}.}

@item @bglos{shadowing symbol}  @Noun{}@spc{}(in a @term{package})
an @term{element} of the @term{package}'s @term{shadowing symbols list}.

@item @bglos{shadowing symbols list}  @Noun{}@spc{}(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}.
See the @term{function} @ref{package-shadowing-symbols}.

@item @bglos{shared slot}  @Noun{}@spc{}(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}@sub{1} the @term{slot}.

@item @bglos{sharpsign}  @Noun{} @anchor{glos-Sharpsign}
the @term{standard character} that is variously called ``number sign,'' ``sharp,''
or ``sharp sign'' (@f{#}).
See @ref{StdCharsThree, Figure 2.5}.

@item @bglos{short float}  @Noun{}@spc{}
an @term{object} @oftype{short-float}.

@item @bglos{sign}  @Noun{}@spc{}
one of the @term{standard characters} ``@f{+}'' or ``@f{-}''.

@item @bglos{signal}  @Verb{}@spc{} @anchor{glos-Signals}
to announce, using a standard protocol, that a particular situation,
represented by a @term{condition}, has been detected.
See @ref{Condition System Concepts}.

@item @bglos{signature}  @Noun{}@spc{}(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}.

@item @bglos{similar}  @Adjective{}@spc{}(of two @term{objects})
defined to be equivalent under the @term{similarity} relationship.

@item @bglos{similarity}  @Noun{} @anchor{glos-Similarity}
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.
See @ref{Literal Objects in Compiled Files}.

@item @bglos{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}.

@item @bglos{simple array}  @Noun{}@spc{}
an @term{array} @oftype{simple-array}.

@item @bglos{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)}.

@item @bglos{simple bit vector}  @Noun{}@spc{}
a @term{bit vector} @oftype{simple-bit-vector}.

@item @bglos{simple condition}  @Noun{}@spc{}
a @term{condition} @oftype{simple-condition}.

@item @bglos{simple general vector}  @Noun{}@spc{}
a @term{simple vector}.

@item @bglos{simple string}  @Noun{}@spc{}
a @term{string} @oftype{simple-string}.

@item @bglos{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} @symbolref{t, SC}.

@item @bglos{single escape}  @Noun{}, @Adjective{}
1. @Noun{}@spc{}the @term{syntax type} of a @term{character}
that indicates that the next @term{character} is
to be treated as an @term{alphabetic}@sub{2} @term{character}
with its @term{case} preserved.
For details, see @ref{Single Escape Character}.
2. @Adjective{}@spc{}(of a @term{character})
having the @term{single escape} @term{syntax type}.
3. @Noun{}@spc{}a @term{single escape}@sub{2} @term{character}.
(In the @term{standard readtable},
@term{slash} is the only @term{single escape}.)

@item @bglos{single float}  @Noun{}@spc{}
an @term{object} @oftype{single-float}.

@item @bglos{single-quote}  @Noun{} @anchor{glos-Single-quote}
the @term{standard character} that is variously called
``apostrophe,''
``acute accent,''
``quote,''
or ``single quote'' (@f{'}).
See @ref{StdCharsThree, Figure 2.5}.

@item @bglos{singleton}  @Adjective{}@spc{}(of a @term{sequence})
having only one @term{element}.
@gexample{@f{(list 'hello)} returns a singleton list.}

@item @bglos{situation}  @Noun{}@spc{}
the @term{evaluation} of a @term{form} in a specific @term{environment}.

@item @bglos{slash}  @Noun{}
the @term{standard character} that is variously called
``solidus''
or ``slash'' (@f{/}).
See @ref{StdCharsThree, Figure 2.5}.

@item @bglos{slot}  @Noun{}@spc{} @anchor{glos-Slots}
a component of an @term{object} that can store a @term{value}.

@item @bglos{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}.

@item @bglos{source code}  @Noun{}@spc{}
@term{code} representing @term{objects} suitable for @term{evaluation}
(@eg{} @term{objects} created by @symbolref{read, SYM},
by @term{macro expansion},
or by @term{compiler macro expansion}).

@item @bglos{source file}  @Noun{}@spc{}
a @term{file} which contains a textual representation of @term{source code},
that can be edited, @term{loaded}, or @term{compiled}.

@item @bglos{space}  @Noun{}  @anchor{glos-Space}
the @term{standard character} @SpaceChar{},
notated for the @term{Lisp reader} as @f{#@bsl{}Space}.

@item @bglos{special form}  @Noun{}@spc{}
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}.

@item @bglos{special operator}  @Noun{}@spc{}
one of a fixed set of @term{symbols},
enumerated in @ref{CLSpecialOps, Figure 3.2},
that may appear in the @term{car} of
a @term{form} in order to identify the @term{form} as a @term{special form}.

@item @bglos{special variable}  @Noun{}@spc{}@Traditional{}
a @term{dynamic variable}.

@anchor{glos-specialize}
@anchor{glos-specializes}
@anchor{glos-specializeing}
@item @b{specialize}  @TransitiveVerb{}@spc{}(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}.

@item @bglos{specialized}  @Adjective{}@spc{}
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};
see @ref{Array Elements}.
@gexample{@f{(make-array 5 :element-type 'bit)} makes an array of length
five that is specialized for bits.}

@item @bglos{specialized lambda list}  @Noun{}
an @term{extended lambda list} used in @term{forms} that @term{establish}
@term{method} definitions, such as @symbolref{defmethod, SYM}.
See @ref{Specialized Lambda Lists}.

@item @bglos{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 @i{non-null} @term{list} @mat{L1} of length @mat{n},
whose last element is a @term{list} @mat{L2} of length @mat{m}
(denoting a list @mat{L3} of length @mat{m+n-1} whose @term{elements} are
@mat{L1@sub{i}} for @mat{i < n-1} followed by @mat{L2@sub{j}} for @mat{j < m}).
@gexample{The list (1 2 (3 4 5)) is a spreadable argument list designator for
the list (1 2 3 4 5).}

@item @bglos{stack allocate}  @TransitiveVerb{}@spc{}@Traditional{}@spc{}
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.

@item @bglos{stack-allocated}  @Adjective{}@spc{}@Traditional{}@spc{}
having been @term{stack allocated}.

@item @bglos{standard character}  @Noun{}@spc{} @anchor{glos-Standard characters}
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}.
See @ref{Standard Characters}.

@item @bglos{standard class}  @Noun{}@spc{}
a @term{class} that is a @term{generalized instance} @ofclass{standard-class}.

@item @bglos{standard generic function}
a @term{function} @oftype{standard-generic-function}.

@item @bglos{standard input}  @Noun{}@spc{}
the @term{input} @term{stream} which is the @term{value} of the @term{dynamic variable}
@symbolref{*standard-input*, SYM}.

@item @bglos{standard method combination}  @Noun{}@spc{}
the @term{method combination} named @code{standard}.

@item @bglos{standard object}  @Noun{}@spc{}
an @term{object} that is
a @term{generalized instance}
@ofclass{standard-object}.

@item @bglos{standard output}  @Noun{}@spc{}
the @term{output} @term{stream} which is the @term{value} of the @term{dynamic variable}
@symbolref{*standard-output*, SYM}.

@item @bglos{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.)

@item @bglos{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.)

@item @bglos{standard syntax}  @Noun{}
the syntax represented by the @term{standard readtable}
and used as a reference syntax throughout this document.
See @ref{Character Syntax}.

@item @bglos{standardized}  @Adjective{}@spc{}(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.}

@item @bglos{startup environment}  @Noun{}
the @term{global environment} of the running @term{Lisp image}
from which the @term{compiler} was invoked.

@item @bglos{step}  @TransitiveVerb{}, @Noun{}@spc{} @anchor{glos-Stepping}
1. @TransitiveVerb{}@spc{}(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{}@spc{}the @term{code} that identifies how the next value in an iteration
is to be computed.
3. @TransitiveVerb{}@spc{}(@term{code}) to specially execute the @term{code}, pausing at
intervals to allow user confirmation or intervention, usually for debugging.

@item @bglos{stream}  @Noun{}@spc{} @anchor{glos-Streams}
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.

@item @bglos{stream associated with a file}  @Noun{}@spc{}
a @term{file stream}, or a @term{synonym stream} the @term{target}
of which is a @term{stream associated with a file}.
Such a @term{stream} cannot be created with
@symbolref{make-two-way-stream, SYM},
@symbolref{make-echo-stream, SYM},
@symbolref{make-broadcast-stream, SYM},
@symbolref{make-concatenated-stream, SYM},
@symbolref{make-string-input-stream, SYM},
or @symbolref{make-string-output-stream, SYM}.

@item @bglos{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:
@symbolref{t, SC}@spc{}(denoting @thevalueof{*terminal-io*}),
@nil{}@spc{}(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).

@item @bglos{stream element type}  @Noun{}@spc{}(of a @term{stream})
the @term{type} of data for which the @term{stream} is specialized.

@item @bglos{stream variable}  @Noun{}
a @term{variable} whose @term{value} must be a @term{stream}.

@item @bglos{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:
@symbolref{t, SC}@spc{}(denoting @symbolref{*terminal-io*, SYM}),
@nil{}@spc{}(denoting @symbolref{*standard-input*, SYM}
for @term{input} @term{stream variable designators}
or denoting @symbolref{*standard-output*, SYM}
for @term{output} @term{stream variable designators}),
or some other @term{symbol} (denoting itself).

@item @bglos{string}  @Noun{}@spc{} @anchor{glos-Strings}
a specialized @term{vector} that is @oftype{string},
and whose elements are @oftypes{character}.

@item @bglos{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).
The intent is that this term be consistent with the behavior of @symbolref{string, F};
@term{implementations} that extend @symbolref{string, F} must extend the meaning of
this term in a compatible way.

@item @bglos{string equal}  @Adjective{}@spc{}
the @term{same} under @symbolref{string-equal, SYM}.

@item @bglos{string stream}  @Noun{}@spc{}
a @term{stream} @oftype{string-stream}.

@item @bglos{structure}  @Noun{}@spc{} @anchor{glos-Structures}
an @term{object} @oftype{structure-object}.

@item @bglos{structure class}  @Noun{}@spc{}
a @term{class} that is a @term{generalized instance} @ofclass{structure-class}.

@item @bglos{structure name}  @Noun{}
a @term{name} defined with @symbolref{defstruct, SYM}.
Usually, such a @term{type} is also a @term{structure class},
but there may be @term{implementation-dependent} situations
in which this is not so, if the @kwd{type} option to @symbolref{defstruct, SYM} is used.

@item @bglos{style warning}  @Noun{}
a @term{condition} @oftype{style-warning}.

@item @bglos{subclass}
 @Noun{}@spc{}
a @term{class} that @term{inherits} from another @term{class},
called a @term{superclass}.
(No @term{class} is a @term{subclass} of itself.)

@item @bglos{subexpression}  @Noun{}@spc{}(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.)

@item @bglos{subform}  @Noun{}@spc{}(of a @term{form}) @anchor{glos-Subforms}
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))}.}

@item @bglos{subrepertoire}  @Noun{}@spc{}
a subset of a @term{repertoire}.

@item @bglos{subtype}
 @Noun{}@spc{}
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.)

@item @bglos{superclass}  @Noun{}@spc{}
a @term{class} from which another @term{class}
(called a @term{subclass}) @term{inherits}.
(No @term{class} is a @term{superclass} of itself.)
See @ref{glos-subclass, subclass}.

@item @bglos{supertype}  @Noun{}@spc{}
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.)
See @ref{glos-subtype, subtype}.

@item @bglos{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}).
See @ref{Ordinary Lambda Lists}.

@item @bglos{symbol}  @Noun{}@spc{} @anchor{glos-Symbol} @anchor{glos-Symbols}
an @term{object} @oftype{symbol}.

@item @bglos{symbol macro}  @Noun{}@spc{}
a @term{symbol} that stands for another @term{form}.
See the @term{macro} @ref{symbol-macrolet}.

@item @bglos{synonym stream}  @Noun{}@spc{}
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}.
See the @term{function} @ref{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}.

@item @bglos{synonym stream symbol}  @Noun{}@spc{}(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.

@item @bglos{syntax type}  @Noun{}@spc{}(of a @term{character})
one of several classifications, enumerated in @ref{PossibleSyntaxTypes, Figure 2.6},
that are used for dispatch during parsing by the @term{Lisp reader}.
See @ref{Character Syntax Types}.

@item @bglos{system class}  @Noun{}@spc{}
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}.

@item @bglos{system code}  @Noun{}@spc{}
@term{code} supplied by the @term{implementation} to implement this specification
(@eg{} the definition of @symbolref{mapcar, SYM})
or generated automatically in support of this specification
(@eg{} during method combination);
that is, @term{code} that is not @term{programmer code}.


@end table
@node T
@unnumberedsec T
@table @asis

@item @bglos{t}
 @Noun{}@spc{}
1. a. the @term{boolean} representing true.
b. the canonical @term{generalized boolean} representing true.
(Although any @term{object} other than @nil{}@spc{}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.

@item @bglos{tag}  @Noun{}@spc{}
1. a @term{catch tag}.
2. a @term{go tag}.

@item @bglos{tail}  @Noun{}@spc{}(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.}

@item @bglos{target}  @Noun{}@spc{}
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.)

@item @bglos{terminal I/O}  @Noun{}@spc{} @anchor{glos-Terminal I/O}
the @term{bidirectional} @term{stream}
that is the @term{value} of @thevariable{*terminal-io*}.

@item @bglos{terminating}  @Noun{}@spc{}(of a @term{macro character})
being such that, if it appears while parsing a token, it terminates that token.
See @ref{Reader Algorithm}.

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

@item @bglos{throw}  @Verb{}@spc{}
to transfer control and @term{values} to a @term{catch}.
See the @term{special operator} @ref{throw}.

@item @bglos{tilde}  @Noun{} @anchor{glos-Tilde}
the @term{standard character} that is called ``tilde'' (@f{@tild{}}).
See @ref{StdCharsThree, Figure 2.5}.

@item @bglos{time}
a representation of a point (@term{absolute} @term{time})
or an interval (@term{relative} @term{time})
on a time line.
See @ref{glos-decoded time, decoded time}, @term{internal time}, and @term{universal time}.

@item @bglos{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 @i{-3}.
(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.)

@item @bglos{token}  @Noun{}
a textual representation for a @term{number} or a @term{symbol}.
See @ref{Interpretation of Tokens}.

@item @bglos{top level form}  @Noun{}@spc{} @anchor{glos-Top level forms}
a @term{form} which is processed specially by @symbolref{compile-file, SYM} 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.  See @ref{Processing of Top Level Forms}.

@item @bglos{trace output}  @Noun{}@spc{}
the @term{output} @term{stream} which is the @term{value} of the @term{dynamic variable}
@symbolref{*trace-output*, SYM}.

@item @bglos{tree}  @Noun{}@spc{}
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.
2. in general, any recursive data structure that has some notion of
``branches'' and @term{leaves}.

@item @bglos{tree structure}  @Noun{}@spc{}(of a @term{tree}@sub{1})
the set of @term{conses} that make up the @term{tree}.
Note that while the @term{car}[1b] component of each such @term{cons}
is part of the @term{tree structure},
the @term{objects} that are the @term{cars}@sub{2} of each @term{cons}
in the @term{tree}
are not themselves part of its @term{tree structure}
unless they are also @term{conses}.

@item @bglos{true}  @Noun{}@spc{}
any @term{object}
that is not @term{false}
and that is used to represent the success of a @term{predicate} test.
See @ref{glos-t, t}@sub{1}.

@item @bglos{truename}  @Noun{}@spc{}
1. the canonical @term{filename} of a @term{file} in the @term{file system}.
See @ref{Truenames}.
2. a @term{pathname} representing a @term{truename}@sub{1}.

@item @bglos{two-way stream}  @Noun{}@spc{}
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}.

@item @bglos{type}  @Noun{}@spc{} @anchor{glos-Type} @anchor{glos-Types}
1. a set of @term{objects}, usually with common structure, behavior, or purpose.
(Note that the expression ``@i{X} is of type @param{S@mat{@sub{a}}}''
naturally implies that ``@i{X} is of type @param{S@mat{@sub{b}}}'' if
@param{S@mat{@sub{a}}} is a @term{subtype} of @param{S@mat{@sub{b}}}.)
2. (immediately following the name of a @term{type})
a @term{subtype} of that @term{type}.
@gexample{The type @symbolref{vector, SC} is an array type.}

@item @bglos{type declaration}  @Noun{}@spc{}
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}.

@item @bglos{type equivalent}  @Adjective{}@spc{}(of two @term{types} @mat{X} and @mat{Y})
having the same @term{elements};
that is, @mat{X} is a @term{subtype} of @mat{Y}
and @mat{Y} is a @term{subtype} of @mat{X}.

@item @bglos{type expand}  @Noun{}
to fully expand a @term{type specifier}, removing any references to
@term{derived types}.  (@clisp{}@spc{}provides no program interface to cause
this to occur, but the semantics of @clisp{}@spc{}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}.)

@item @bglos{type specifier}  @Noun{}@spc{} @anchor{glos-Type specifiers}
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.}


@end table
@node U
@unnumberedsec U
@table @asis

@item @bglos{unbound}
 @Adjective{}@spc{}
not having an associated denotation in a @term{binding}.
See @ref{glos-bound, bound}.

@item @bglos{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}.

@item @bglos{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}.

@item @b{unintern}  @TransitiveVerb{}@spc{}(a @term{symbol} in a @term{package}) @anchor{glos-unintern} @anchor{glos-uninterns} @anchor{glos-uninternes} @anchor{glos-uninterning}
to make the @term{symbol} not be @term{present} in that @term{package}.
(The @term{symbol} might continue to be @term{accessible} by inheritance.)

@item @bglos{uninterned}  @Adjective{}@spc{}(of a @term{symbol}) @anchor{glos-Uninterned}
not @term{accessible} in any @term{package}; @ie{} not @term{interned}@sub{1}.

@item @bglos{universal time}  @Noun{}
@term{time}, represented as a non-negative @term{integer} number of seconds.
@term{Absolute} @term{universal time} is measured as an offset
from the beginning of the year 1900 (ignoring @term{leap seconds}).
See @ref{Universal Time}.

@item @bglos{unqualified method}  @Noun{}@spc{}
a @term{method} with no @term{qualifiers}.

@item @bglos{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{}.
See the @term{function} @ref{delete-package}.

@item @bglos{unsafe}  @Adjective{}@spc{}(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.)

@item @bglos{unsafe call}  @Noun{}
a @term{call} that is not a @term{safe call}.
For more detailed information, see @ref{Safe and Unsafe Calls}.

@anchor{glos-upgrading}
@item @bglos{upgrade}  @TransitiveVerb{}@spc{}(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.
See the @term{function} @ref{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.
See the @term{function} @ref{upgraded-complex-part-type}.

@item @bglos{upgraded array element type}  @Noun{}@spc{}(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.
See @ref{Array Upgrading}.

@item @bglos{upgraded complex part type}  @Noun{}@spc{}(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.
See the @term{function} @ref{upgraded-complex-part-type}.

@item @bglos{uppercase}  @Adjective{}@spc{}(of a @term{character}) @anchor{glos-Uppercase}
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}.
See @ref{Characters With Case}.

@item @bglos{use}  @TransitiveVerb{}@spc{}(a @term{package} @mat{P@sub{1}})
to @term{inherit} the @term{external symbols} of @mat{P@sub{1}}.
(If a package @mat{P@sub{2}} uses @mat{P@sub{1}},
the @term{external symbols} of @mat{P@sub{1}}
become @term{internal symbols} of @mat{P@sub{2}}
unless they are explicitly @term{exported}.)
@gexample{The package @code{CL-USER} uses the package @code{CL}.}

@item @bglos{use list}  @Noun{}@spc{}(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}.

@item @bglos{user}  @Noun{}@spc{}
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}.


@end table
@node V
@unnumberedsec V
@table @asis

@item @bglos{valid array dimension}  @Noun{}@spc{}
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 @symbolref{array-dimension-limit, SYM}.
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
@symbolref{array-total-size-limit, SYM}.

@item @bglos{valid array index}  @Noun{}@spc{}(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}@sub{1}
of the @term{array}.
(Unless otherwise explicitly specified,
the phrase ``a @term{list} of @i{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@tie{}@f{3} array,
valid array indices for the first  dimension are @f{0} and@tie{}@f{1}, and
valid array indices for the second dimension are @f{0}, @f{1} and@tie{}@f{2}.}

@item @bglos{valid array row-major index}  @Noun{}@spc{}(of an @term{array},
which might have any number
of @term{dimensions}@sub{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}.

@item @bglos{valid fill pointer}  @Noun{}@spc{}(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}.

@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.}


@item @bglos{valid logical pathname host}  @Noun{}
a @term{string} that has been defined as the name of a @term{logical host}.
See the @term{function} @ref{load-logical-pathname-translations}.

@item @bglos{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}.

@item @bglos{valid pathname directory}  @Noun{}
a @term{string},
a @term{list} of @term{strings},
@nil{},
@kwd{wild},
@kwd{unspecific},
or some other @term{object} defined by the @term{implementation}
to be a @i{valid directory component}.

@item @bglos{valid pathname host}  @Noun{}
a @term{valid physical pathname host}
or a @term{valid logical pathname host}.

@item @bglos{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}.

@item @bglos{valid pathname type}  @Noun{}
a @term{string},
@nil{},
@kwd{wild},
@kwd{unspecific}.

@item @bglos{valid pathname version}  @Noun{}
a non-negative @term{integer},
or one of @kwd{wild},
@kwd{newest},
@kwd{unspecific},
or @nil{}.
The symbols @kwd{oldest}, @kwd{previous}, and @kwd{installed} are
@term{semi-standard} special version symbols.

@item @bglos{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.


@item @bglos{valid sequence index}  @Noun{}@spc{}(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}.
(If the @term{sequence} is an @term{array},
the @term{valid sequence index} is further constrained to be a @term{fixnum}.)

@item @bglos{value}  @Noun{}@spc{}
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{}@spc{}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}.

@item @bglos{value cell}  @Noun{}@spc{}@Traditional{}@spc{}(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 @symbolref{symbol-value, SYM}.
See @ref{glos-cell, cell}.

@item @bglos{variable}  @Noun{}@spc{} @anchor{glos-Variables}
a @term{binding} in the ``variable'' @term{namespace}.
See @ref{Symbols as Forms}.

@item @bglos{vector}  @Noun{}@spc{} @anchor{glos-Vectors}
a one-dimensional @term{array}.

@item @bglos{vertical-bar}  @Noun{} @anchor{glos-Vertical-bar}
the @term{standard character} that is called ``vertical bar'' (@f{|}).
See @ref{StdCharsThree, Figure 2.5}.


@end table
@node W
@unnumberedsec W
@table @asis

@item @bglos{whitespace}  @Noun{}@spc{} @anchor{glos-Whitespace}
1. one or more @term{characters} that are
either the @term{graphic} @term{character} @f{#@bsl{}Space}
or else @term{non-graphic} characters such as @f{#@bsl{}Newline}
that only move the print position.
2. a. @Noun{}@spc{}the @term{syntax type} of a @term{character}
that is a @term{token} separator.
For details, see @ref{Whitespace Characters}.
b. @Adjective{}@spc{}(of a @term{character})
having the @term{whitespace}[2a] @term{syntax type}@sub{2}.
c. @Noun{}@spc{}a @term{whitespace}[2b] @term{character}.

@item @bglos{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}.
See the @term{function} @ref{wild-pathname-p}.

@item @bglos{write}  @TransitiveVerb{}@spc{} @anchor{glos-writing}
1. (a @term{binding} or @term{slot} or component)
to change the @term{value} of the @term{binding} or @term{slot}.
2. (an @term{object} to a @term{stream})
to output a representation of the @term{object} to the @term{stream}.

@item @bglos{writer}  @Noun{}
a @term{function} that @term{writes}@sub{1} a @term{variable} or @term{slot}.


@end table
@node Y
@unnumberedsec Y
@table @asis

@item @bglos{yield}  @TransitiveVerb{}@spc{}(@term{values})
to produce the @term{values} as the result of @term{evaluation}.
@gexample{The form @f{(+ 2 3)} yields @f{5}.}

@end table