@node Glossary (Glossary), Appendix, Environment, Top
@chapter Glossary

@menu
* Glossary::			
@end menu

@node Glossary,  , Glossary (Glossary), Glossary (Glossary)
@section Glossary

@c including concept-glossary

Each entry in this glossary has the following parts:

@table @asis

@item @t{*}  
the term being defined, set in boldface.

@item @t{*}  
optional pronunciation, enclosed in square brackets and
set in boldface, as in the following example:
pronounced 'a ,list .  The pronunciation key follows
@i{Webster's Third New International Dictionary
 the English Language, Unabridged},
  except that ``{e}'' is used to notate the schwa (upside-down ``e'') character.

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

@table @asis

@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, ``{Math.}''

@item --  
an optional context, present if this definition is
meaningful only in that context. For example, ``(of a @i{symbol})''.

@item --  
the definition.

@item --  
an optional example sentence. For example,
           {``This is an example of an example.''}

@item --  
optional cross references.

@end table

@end table

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 ``{Idiom.}'' 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, ``@i{complex float}'' refers to a single glossary entry 
for ``@i{complex float}'' rather than the combined meaning of the 
glossary terms ``@i{complex}'' and ``@i{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:

     Abbreviation       Meaning
@table @asis
@item @i{adj.}
adjective
@item @i{adv.}
adverb
@item @i{ANSI}
compatible with one or more ANSI standards
@item @i{Comp.}
computers
@item @i{Idiom.}
idiomatic
@item @i{IEEE}
compatible with one or more IEEE standards
@item @i{ISO}
compatible with one or more ISO standards
@item @i{Math.}
mathematics
@item @i{Trad.}
traditional
@item @i{n.}
noun
@item @i{v.}
verb
@item @i{v.t.}
transitive verb
@end table

@table @asis

@subheading @b{Non-alphabetic}
@table @asis

@IGindex{()}
@item @b{()}
 pronounced 'nil , @i{n.}
  an alternative notation for writing the symbol~@b{nil}, used to emphasize
  the use of @i{nil} as an @i{empty list}.

@end table
@subheading @b{A}
@table @asis

@IGindex{absolute}
@item @b{absolute}
 @i{adj.}
  1. (of a @i{time})
     representing a specific point in time.
  2. (of a @i{pathname})
     representing a specific position in a directory hierarchy.
  See @i{relative}.

@IGindex{access}
@item @b{access}
 @i{n.}, @i{v.t.}
  1. @i{v.t.} (a @i{place}, or @i{array})
     to @i{read}_1 or @i{write}_1 the @i{value} of
         the @i{place}
      or an @i{element} of the @i{array}.
  2. @i{n.} (of a @i{place})
     an attempt to @i{access}_1 the @i{value} of the @i{place}.

@IGindex{accessibility}
@item @b{accessibility}
 @i{n.}
  the state of being @i{accessible}.

@IGindex{accessible}
@item @b{accessible}
 @i{adj.} 
  1. (of an @i{object}) capable of being @i{referenced}.
  2. (of @i{shared slots} or @i{local slots} in an @i{instance} of 
     a @i{class}) having been defined by the @i{class} 
     of the @i{instance} or @i{inherited} from a
     @i{superclass} of that @i{class}.
  3. (of a @i{symbol} in a @i{package})
     capable of being @i{referenced} without a @i{package prefix} 
     when that @i{package} is current, regardless of whether the
     @i{symbol} is @i{present} in that @i{package} or is @i{inherited}.

@IGindex{accessor}
@item @b{accessor}
 @i{n.}
  an @i{operator} that performs an @i{access}.
  See @i{reader} and @i{writer}.

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

@IGindex{actual adjustability}
@item @b{actual adjustability}
 @i{n.} (of an @i{array})
  a @i{generalized boolean} that is associated with the @i{array}, 
  representing whether the @i{array} is @i{actually adjustable}.
  See also @i{expressed adjustability} and @b{adjustable-array-p}.

@IGindex{actual argument}
@item @b{actual argument}
 @i{n.} @i{Trad.} 
  an @i{argument}.

@IGindex{actual array element type}
@item @b{actual array element type}
 @i{n.} (of an @i{array})
  the @i{type} for which the @i{array} is actually specialized,
  which is the @i{upgraded array element type} of 
  the @i{expressed array element type} of the @i{array}.
  See the @i{function} @b{array-element-type}.

@IGindex{actual complex part type}
@item @b{actual complex part type}
 @i{n.} (of a @i{complex})
  the @i{type} in which the real and imaginary parts of the @i{complex}
  are actually represented, which is the @i{upgraded complex part type} of the
  @i{expressed complex part type} of the @i{complex}.

@IGindex{actual parameter}
@item @b{actual parameter}
 @i{n.} @i{Trad.} 
  an @i{argument}.

@IGindex{actually adjustable}
@item @b{actually adjustable}
 @i{adj.} (of an @i{array})
  such that @b{adjust-array} can adjust its characteristics
  by direct modification.
  A @i{conforming program} may depend on
  an @i{array} being @i{actually adjustable}
  only if either that @i{array} is known to have been @i{expressly adjustable}
  or if that @i{array} has been explicitly tested by @b{adjustable-array-p}.

@IGindex{adjustability}
@item @b{adjustability}
 @i{n.} (of an @i{array})
  1. @i{expressed adjustability}.
  2. @i{actual adjustability}.

@IGindex{adjustable}
@item @b{adjustable}
 @i{adj.} (of an @i{array})
  1. @i{expressly adjustable}.
  2. @i{actually adjustable}.

@IGindex{after method}
@item @b{after method}
 @i{n.}
  a @i{method} having the @i{qualifier} @t{:after}.

@IGindex{alist}
@item @b{alist}
 pronounced '\=a ,list , @i{n.} 
  an @i{association list}.

@IGindex{alphabetic}
@item @b{alphabetic}
 @i{n.}, @i{adj.}
  1. @i{adj.} (of a @i{character})
     being one of the @i{standard characters} @t{A} through @t{Z} 
         or @t{a} through @t{z},
      or being any @i{implementation-defined} character that has @i{case},
      or being some other @i{graphic} @i{character}
         defined by the @i{implementation} to be @i{alphabetic}_1.
  2. a. @i{n.}
        one of several possible @i{constituent traits} of a @i{character}.
        For details, see @ref{Constituent Characters} and @ref{Reader Algorithm}.
     b. @i{adj.} (of a @i{character})
        being a @i{character} 
              that has @i{syntax type} @i{constituent} in the @i{current readtable} 
	  and that has the @i{constituent trait} @i{alphabetic}_@{2a@}.
	See @i{Figure~2--8}.

@IGindex{alphanumeric}
@item @b{alphanumeric}
 @i{adj.} (of a @i{character})
  being either an @i{alphabetic}_1 @i{character}
            or a @i{numeric} {character}.

@IGindex{ampersand}
@item @b{ampersand}
 @i{n.}
  the @i{standard character} that is called ``ampersand'' (@t{&}).
  See @i{Figure~2--5}.

@IGindex{anonymous}
@item @b{anonymous}
 @i{adj.} 
  1. (of a @i{class} or @i{function}) having no @i{name}
  2. (of a @i{restart}) having a @i{name} of @b{nil}.

@IGindex{apparently uninterned}
@item @b{apparently uninterned}
 @i{adj.} 
  having a @i{home package} of @b{nil}.  (An @i{apparently uninterned} @i{symbol} 
  might or might not be an @i{uninterned} @i{symbol}.  @i{Uninterned symbols}
  have a @i{home package} of @b{nil}, but @i{symbols} which have been @i{uninterned}
  from their @i{home package} also have a @i{home package} of @b{nil},
  even though they might still be @i{interned} in some other @i{package}.)

@IGindex{applicable}
@item @b{applicable}
 @i{adj.}
  1. (of a @i{handler}) being an @i{applicable handler}.
  2. (of a @i{method}) being an @i{applicable method}.
  3. (of a @i{restart}) being an @i{applicable restart}.

@IGindex{applicable handler}
@item @b{applicable handler}
 @i{n.} (for a @i{condition} being @i{signaled})
  an @i{active} @i{handler} for which the associated type contains the
  @i{condition}.

@IGindex{applicable method}
@item @b{applicable method}
 @i{n.} (of a @i{generic function}
				     called with @i{arguments})
  a @i{method} of the @i{generic function} for which the
  @i{arguments} satisfy the @i{parameter specializers} 
  of that @i{method}.
  See @ref{Selecting the Applicable Methods}.

@IGindex{applicable restart}
@item @b{applicable restart}
 @i{n.}
  1. (for a @i{condition})
     an @i{active} @i{handler} for which the associated test returns 
     @i{true} when given the @i{condition} as an argument.
  2. (for no particular @i{condition})
     an @i{active} @i{handler} for which the associated test returns 
     @i{true} when given @b{nil} as an argument.

@IGindex{apply}
@item @b{apply}
 @i{v.t.} (a @i{function} to a @i{list})
  to @i{call} the @i{function} with arguments that are the @i{elements}
  of the @i{list}.
  {``Applying the function @b{+} to a list of integers returns
	    the sum of the elements of that list.''} 

@IGindex{argument}
@item @b{argument}
 @i{n.}
  1. (of a @i{function}) an @i{object} which is offered as data
     to the @i{function} when it is @i{called}.

  2. (of a @i{format control}) a @i{format argument}.

@IGindex{argument evaluation order}
@item @b{argument evaluation order}
 @i{n.} 
  the order in which @i{arguments} are evaluated in a function call.
  {``The argument evaluation order for Common Lisp is left to right.''}
  See @ref{Evaluation}.

@IGindex{argument precedence order}
@item @b{argument precedence order}
 @i{n.}
  the order in which the @i{arguments} to a @i{generic function} are
  considered when sorting the @i{applicable methods} into precedence order.

@IGindex{around method}
@item @b{around method}
 @i{n.}
  a @i{method} having the @i{qualifier} @t{:around}.

@IGindex{array}
@item @b{array}
 @i{n.}
  an @i{object} of @i{type} @b{array}, which serves as a container for other
  @i{objects} arranged in a Cartesian coordinate system.

@IGindex{array element type}
@item @b{array element type}
 @i{n.} (of an @i{array})
  1. a @i{type} associated with the @i{array}, 
     and of which all @i{elements} of the @i{array} are 
     constrained to be members.
  2. the @i{actual array element type} of the @i{array}.
  3. the @i{expressed array element type} of the @i{array}.

@IGindex{array total size}
@item @b{array total size}
 @i{n.} 
  the total number of @i{elements} in an @i{array}, computed by taking 
  the product of the @i{dimensions} of the @i{array}.
  (The size of a zero-dimensional @i{array} is therefore one.)

@IGindex{assign}
@item @b{assign}
 @i{v.t.} (a @i{variable})
  to change the @i{value} of the @i{variable} in a @i{binding}
  that has already been @i{established}.
  See the @i{special operator} @b{setq}.

@IGindex{association list}
@item @b{association list}
 @i{n.} 
  a @i{list} of @i{conses} representing an association 
  of @i{keys} with @i{values}, where the @i{car} of each
  @i{cons} is the @i{key} and the @i{cdr} is the
  @i{value} associated with that @i{key}.

@IGindex{asterisk}
@item @b{asterisk}
 @i{n.}
  the @i{standard character} that is variously called
      ``asterisk''
   or ``star'' (@t{*}).
  See @i{Figure~2--5}.

@IGindex{at-sign}
@item @b{at-sign}
 @i{n.}
  the @i{standard character} that is variously called
     ``commercial at''
  or ``at sign'' (@t{@@}).
  See @i{Figure~2--5}.

@IGindex{atom}
@item @b{atom}
 @i{n.}
  any @i{object} that is not a @i{cons}.
  {``A vector is an atom.''}

@IGindex{atomic}
@item @b{atomic}
 @i{adj.} 
  being an @i{atom}.
  {``The number 3, the symbol @t{foo}, and @b{nil} are atomic.''}

@IGindex{atomic type specifier}
@item @b{atomic type specifier}
 @i{n.}
  a @i{type specifier} that is @i{atomic}.
  For every @i{atomic type specifier}, @i{x}, there is an equivalent
  @i{compound type specifier} with no arguments supplied, @t{(@i{x})}.

@IGindex{attribute}
@item @b{attribute}
 @i{n.} (of a @i{character})
  a program-visible aspect of the @i{character}.
  The only @i{standardized} @i{attribute} of a @i{character}
  is its @i{code}_2, but @i{implementations} are permitted to have
  additional @i{implementation-defined} @i{attributes}.
  See @ref{Character Attributes}.
  {``An implementation that support fonts
            might make font information an attribute of a character,
            while others might represent font information separately from characters.''}

@IGindex{aux variable}
@item @b{aux variable}
 @i{n.}
  a @i{variable} that occurs in the part of a @i{lambda list}
  that was introduced by @b{&aux}.  Unlike all other @i{variables}
  introduced by a @i{lambda-list}, @i{aux variables} are not 
  @i{parameters}.

@IGindex{auxiliary method}
@item @b{auxiliary method}
 @i{n.}
  a member of one of two sets of @i{methods} 
  (the set of @i{primary methods} is the other)
  that form an exhaustive partition of the set of @i{methods}
  on the @i{method}'s @i{generic function}.
  How these sets are determined is dependent on the @i{method combination} type;
  see @ref{Introduction to Methods}.

@end table
@subheading @b{B}
@table @asis

@IGindex{backquote}
@item @b{backquote}
 @i{n.}
  the @i{standard character} that is variously called
       ``grave accent'' 
    or ``backquote'' (@t{`}).
  See @i{Figure~2--5}.

@IGindex{backslash}
@item @b{backslash}
 @i{n.}
  the @i{standard character} that is variously called
       ``reverse solidus'' 
    or ``backslash'' (@t{\}).
  See @i{Figure~2--5}.

@IGindex{base character}
@item @b{base character}
 @i{n.}
  a @i{character}

  of @i{type} @b{base-char}.

@IGindex{base string}
@item @b{base string}
 @i{n.}
  a @i{string} of @i{type} @b{base-string}.

@IGindex{before method}
@item @b{before method}
 @i{n.}
  a @i{method} having the @i{qualifier} @t{:before}.

@IGindex{bidirectional}
@item @b{bidirectional}
 @i{adj.} (of a @i{stream})
  being both an @i{input} @i{stream} and an @i{output} @i{stream}.

@IGindex{binary}
@item @b{binary}
 @i{adj.} 
  1. (of a @i{stream})
     being a @i{stream} that has an @i{element type} that is a @i{subtype} of @i{type} @b{integer}.
     The most fundamental operation on a @i{binary} @i{input} @i{stream} 
     is @b{read-byte} and on a @i{binary} @i{output} @i{stream} 
     is @b{write-byte}.
     See @i{character}.
  2. (of a @i{file})
     having been created by opening a @i{binary} @i{stream}.
     (It is @i{implementation-dependent} whether this is an detectable aspect 
      of the @i{file}, or whether any given @i{character} @i{file} can be
      treated as a @i{binary} @i{file}.)

@IGindex{bind}
@item @b{bind}
 @i{v.t.} (a @i{variable})
  to establish a @i{binding} for the @i{variable}.

@IGindex{binding}
@item @b{binding}
 @i{n.} 
  an association between a @i{name} and that which the @i{name} 
  denotes.  
  {``A lexical binding is a lexical association between a 
            name and its value.''}

@IGindex{bit}
@item @b{bit}
 @i{n.} 
  an @i{object} of @i{type} @b{bit}; 
  that is, the @i{integer} @t{0} or the @i{integer} @t{1}.

@IGindex{bit array}
@item @b{bit array}
 @i{n.}
  a specialized @i{array} that is of @i{type} @t{(array bit)},
  and whose elements are of @i{type} @b{bit}.

@IGindex{bit vector}
@item @b{bit vector}
 @i{n.} 
  a specialized @i{vector} that is of @i{type} @b{bit-vector},
  and whose elements are of @i{type} @b{bit}.

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

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

@IGindex{block tag}
@item @b{block tag}
 @i{n.} 
  the @i{symbol} that, within the @i{lexical scope} 
  of a @b{block} @i{form}, names the @i{block}
  @i{established} by that @b{block} @i{form}.
  See @b{return} or @b{return-from}.

@IGindex{boa lambda list}
@item @b{boa lambda list}
 @i{n.}
  a @i{lambda list} that is syntactically like an @i{ordinary lambda list},
  but that is processed in ``@b{b}y @b{o}rder of @b{a}rgument'' style.
  See @ref{Boa Lambda Lists}.

@IGindex{body parameter}
@item @b{body parameter}
 @i{n.}
  a @i{parameter} available in certain @i{lambda lists}
  which from the point of view of @i{conforming programs}
  is like a @i{rest parameter} in every way except that it is introduced
  by @b{&body} instead of @b{&rest}.  (@i{Implementations} are 
  permitted to provide extensions which distinguish @i{body parameters}
  and @i{rest parameters}---@i{e.g.}, the @i{forms} for @i{operators}
  which were defined using a @i{body parameter} might be pretty printed
  slightly differently than @i{forms} for @i{operators} which were 
  defined using @i{rest parameters}.)

@IGindex{boolean}
@item @b{boolean}
 @i{n.} 
  an @i{object} of @i{type} @b{boolean};
  that is, one of the following @i{objects}: 
       the symbol~@b{t}   (representing @i{true}),
    or the symbol~@b{nil} (representing @i{false}).
  See @i{generalized boolean}.

@IGindex{boolean equivalent}
@item @b{boolean equivalent}
 @i{n.} (of an @i{object} O_1)
  any @i{object} O_2 that has the same truth value as O_1
  when both O_1 and O_2 are viewed as @i{generalized booleans}.

@IGindex{bound}
@item @b{bound}
 @i{adj.}, @i{v.t.} 
  1. @i{adj.} having an associated denotation in a @i{binding}.
     {``The variables named by a @b{let} are bound within
               its body.''}
     See @i{unbound}.
  2. @i{adj.} having a local @i{binding} which 
     @i{shadows}_2 another. 
     {``The variable @b{*print-escape*} is bound while in
               the @b{princ} function.''}
  3. @i{v.t.} the past tense of @i{bind}.

@IGindex{bound declaration}
@item @b{bound declaration}
 @i{n.} 
  a @i{declaration} that refers to or is associated with a @i{variable}
  or @i{function} and that appears within the @i{special form} 
  that @i{establishes} the @i{variable} or @i{function},
  but before the body of that @i{special form}
  (specifically, at the head of that @i{form}'s body).
  (If a @i{bound declaration} refers to a @i{function} @i{binding} or
   a @i{lexical variable} @i{binding}, the @i{scope} of
   the @i{declaration} is exactly the @i{scope} of that
   @i{binding}.  If the @i{declaration} refers to a
   @i{dynamic variable} @i{binding}, the @i{scope} of
   the @i{declaration} is what the @i{scope} of the 
   @i{binding} would have been if it were lexical rather than dynamic.)

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

@IGindex{bounding index}
@item @b{bounding index}
 @i{n.} (of a @i{sequence} with @i{length} n)
  either of a conceptual pair of @i{integers}, i_@{start@} and i_@{end@},
  respectively called the ``lower bounding index'' and ``upper bounding index'',
  such that 0 <= i_@{start@} <= i_@{end@} <= n, and which therefore delimit
  a subrange of the @i{sequence} @i{bounded} by i_@{start@} and i_@{end@}.

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

@IGindex{break loop}
@item @b{break loop}
 @i{n.}
  A variant of the normal @i{Lisp read-eval-print loop} that is recursively
  entered, usually because the ongoing @i{evaluation} of some other @i{form}
  has been suspended for the purpose of debugging.  Often, a @i{break loop}
  provides the ability to exit in such a way as to continue the suspended computation.
  See the @i{function} @b{break}.

@IGindex{broadcast stream}
@item @b{broadcast stream}
 @i{n.}
  an @i{output} @i{stream} of @i{type} @b{broadcast-stream}.

@IGindex{built-in class}
@item @b{built-in class}
 @i{n.}
  a @i{class} that is a @i{generalized instance} of @i{class} @b{built-in-class}.

@IGindex{built-in type}
@item @b{built-in type}
 @i{n.}
   one of the @i{types} in @i{Figure~4--2}.

@IGindex{byte}
@item @b{byte}
 @i{n.}
  1. adjacent bits within an @i{integer}.
     (The specific number of bits can vary from point to point in the program;
      see the @i{function} @b{byte}.)
  2. an integer in a specified range.
     (The specific range can vary from point to point in the program;
      see the @i{functions} @b{open} and @b{write-byte}.)

@IGindex{byte specifier}
@item @b{byte specifier}
 @i{n.}
  An @i{object} of @i{implementation-dependent} nature 
  that is returned by the @i{function} @b{byte} and
  that specifies the range of bits in an @i{integer} to be used
  as a @i{byte} by @i{functions} such as @b{ldb}.

@end table
@subheading @b{C}
@table @asis

@IGindex{cadr}
@item @b{cadr}
 pronounced 'ka ,de r , @i{n.} (of an @i{object})
  the @i{car} of the @i{cdr} of that @i{object}.

@IGindex{call}
@item @b{call}
 @i{v.t.}, @i{n.} 
  1. @i{v.t.} (a @i{function} with @i{arguments})
     to cause the @i{code} represented by that @i{function} to be 
     @i{executed} in an @i{environment} where @i{bindings} for
     the @i{values} of its @i{parameters} have been @i{established}
     based on the @i{arguments}.
     {``Calling the function @b{+} with the arguments 
               @t{5} and @t{1} yields a value of @t{6}.''}
  2. @i{n.} a @i{situation} in which a @i{function} is called.

@IGindex{captured initialization form}
@item @b{captured initialization form}
 @i{n.}
  an @i{initialization form} along with the @i{lexical environment}
  in which the @i{form} that defined the @i{initialization form}
  was @i{evaluated}.
  {``Each newly added shared slot is set to the result of evaluating
            the captured initialization form for the slot that was specified
            in the @b{defclass} form for the new class.''}

@IGindex{car}
@item @b{car}
 @i{n.}
  1. a. (of a @i{cons}) 
        the component of a @i{cons} corresponding to the first
        @i{argument} to @b{cons}; the other component is the
        @i{cdr}.
	{``The function @b{rplaca} modifies the car of a cons.''}
     b. (of a @i{list})
        the first @i{element} of the @i{list}, or @b{nil} if the
        @i{list} is the @i{empty list}.
  2. the @i{object} that is held in the @i{car}_1.
     {``The function @b{car} returns the car of a cons.''}

@IGindex{case}
@item @b{case}
 @i{n.} (of a @i{character})
  the property of being either @i{uppercase} or @i{lowercase}.
  Not all @i{characters} have @i{case}.
  {``The characters @t{#\A} and @t{#\a} have case,
	    but the character @t{#\$} has no case.''}
  See @ref{Characters With Case} and the @i{function} @b{both-case-p}.

@IGindex{case sensitivity mode}
@item @b{case sensitivity mode}
 @i{n.}
  one of the @i{symbols}
  @t{:upcase}, @t{:downcase}, @t{:preserve}, or @t{:invert}.

@IGindex{catch}
@item @b{catch}
 @i{n.}
  an @i{exit point} which is @i{established} by a @b{catch}
  @i{form} within the @i{dynamic scope} of its body,
  which is named by a @i{catch tag},
  and to which control and @i{values} may be @i{thrown}.

@IGindex{catch tag}
@item @b{catch tag}
 @i{n.}
  an @i{object} which names an @i{active} @i{catch}.
  (If more than one @i{catch} is active with the same @i{catch tag},
   it is only possible to @i{throw} to the innermost such @i{catch}
   because the outer one is @i{shadowed}_2.)

@IGindex{cddr}
@item @b{cddr}
 pronounced 'kud e ,de r  or
	      pronounced 'ke ,dude r , @i{n.} 
	      (of an @i{object})
  the @i{cdr} of the @i{cdr} of that @i{object}.

@IGindex{cdr}
@item @b{cdr}
 pronounced 'ku ,de r , @i{n.} 
  1. a. (of a @i{cons}) 
        the component of a @i{cons} corresponding to the second @i{argument}
        to @b{cons}; the other component is the @i{car}.
	{``The function @b{rplacd} modifies the cdr of a cons.''}
     b. (of a @i{list} L_1)
        either the @i{list} L_2 that contains 
	       the @i{elements} of L_1 that follow after the first, 
	or else @b{nil} if L_1 is the @i{empty list}.
  2. the @i{object} that is held in the @i{cdr}_1.
     {``The function @b{cdr} returns the cdr of a cons.''}

@IGindex{cell}
@item @b{cell}
 @i{n.} @i{Trad.} (of an @i{object})
  a conceptual @i{slot} of that @i{object}.
  The @i{dynamic variable} and global @i{function} @i{bindings}
  of a @i{symbol} are sometimes referred to as its @i{value cell}
  and @i{function cell}, respectively.

@IGindex{character}
@item @b{character}
 @i{n.}, @i{adj.}
  1. @i{n.} an @i{object} of @i{type} @b{character}; that is,
     an @i{object} that represents a unitary token in an aggregate quantity of text;
     see @ref{Character Concepts}.
  2. @i{adj.} 
     a. (of a @i{stream})
        having an @i{element type} that is a @i{subtype} of @i{type} @b{character}.
        The most fundamental operation on a @i{character} @i{input} @i{stream} 
        is @b{read-char} and on a @i{character} @i{output} @i{stream} 
        is @b{write-char}. See @i{binary}.
     b. (of a @i{file})
        having been created by opening a @i{character} @i{stream}.
        (It is @i{implementation-dependent} whether this is an inspectable aspect 
         of the @i{file}, or whether any given @i{binary} @i{file} can be
         treated as a @i{character} @i{file}.)

@IGindex{character code}
@item @b{character code}
 @i{n.}
  1. one of possibly several @i{attributes} of a @i{character}.
  2. a non-negative @i{integer} less than the @i{value} of @b{char-code-limit}
     that is suitable for use as a @i{character code}_1.

@IGindex{character designator}
@item @b{character designator}
 @i{n.}
  a @i{designator} for a @i{character}; that is,
  an @i{object} that denotes a @i{character} 
  and that is one of:
       a @i{designator} for a @i{string} of @i{length} one
         (denoting the @i{character} that is its only @i{element}),

    or a @i{character} (denoting itself).

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

@IGindex{circular list}
@item @b{circular list}
 @i{n.} 
  a chain of @i{conses} that has no termination because some
 @i{cons} in the chain is the @i{cdr} of a later @i{cons}.

@IGindex{class}
@item @b{class}
 @i{n.}
  1. an @i{object} that uniquely determines the structure and behavior of 
     a set of other @i{objects} called its @i{direct instances}, 
     that contributes structure and behavior to a set of
     other @i{objects} called its @i{indirect instances},
     and that acts as a @i{type specifier} for a set of objects
     called its @i{generalized instances}.
     {``The class @b{integer} is a subclass of the class @b{number}.''}
     (Note that the phrase ``the @i{class} @t{foo}'' is often substituted for
      the more precise phrase ``the @i{class} named @t{foo}''---in both
      cases, a @i{class} @i{object} (not a @i{symbol}) is denoted.)
  2. (of an @i{object})
     the uniquely determined @i{class} of which the @i{object} is
     a @i{direct instance}.
     See the @i{function} @b{class-of}.
     {``The class of the object returned by @b{gensym} 
 	       is @b{symbol}.''}
     (Note that with this usage a phrase such as ``its @i{class} is @t{foo}'' 
      is often substituted for the more precise phrase
      ``its @i{class} is the @i{class} named @t{foo}''---in both
      cases, a @i{class} @i{object} (not a @i{symbol}) is denoted.)

@IGindex{class designator}
@item @b{class designator}
 @i{n.}
  a @i{designator} for a @i{class}; that is,
  an @i{object} that denotes a @i{class} 
  and that is one of:
       a @i{symbol} (denoting the @i{class} named by that @i{symbol};
		        see the @i{function} @b{find-class})
    or a @i{class} (denoting itself).

@IGindex{class precedence list}
@item @b{class precedence list}
 @i{n.}
  a unique total ordering on a @i{class}
  and its @i{superclasses} that is consistent with the
  @i{local precedence orders} for the @i{class} and its
  @i{superclasses}.
  For detailed information, see @ref{Determining the Class Precedence List}.

@IGindex{close}
@item @b{close}
 @i{v.t.} (a @i{stream})
  to terminate usage of the @i{stream} as a source or sink of data,
  permitting the @i{implementation} to reclaim its internal data structures,
  and to free any external resources which might have been locked by the
 @i{stream} when it was opened.

@IGindex{closed}
@item @b{closed}
 @i{adj.} (of a @i{stream})
  having been @i{closed} (see @i{@i}{close}).
  Some (but not all) operations that are valid on @i{open} @i{streams} 
  are not valid on @i{closed} @i{streams}.
  See @ref{File Operations on Open and Closed Streams}.

@IGindex{closure}
@item @b{closure}
 @i{n.}
  a @i{lexical closure}.

@IGindex{coalesce}
@item @b{coalesce}
 @i{v.t.} (@i{literal objects} that are @i{similar})
  to consolidate the identity of those @i{objects},
  such that they become the @i{same} 
  @i{object}.
  See @ref{Compiler Terminology}.

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

@IGindex{coerce}
@item @b{coerce}
 @i{v.t.} (an @i{object} to a @i{type})
  to produce an @i{object} from the given @i{object},
  without modifying that @i{object},
  by following some set of coercion rules that must be specifically 
  stated for any context in which this term is used.
  The resulting @i{object} is necessarily of the indicated @i{type}, 
  except when that type is a @i{subtype} of @i{type} @b{complex}; in that case,
  if a @i{complex rational} with an imaginary part of zero would result,
  the result is a @i{rational} 
  rather than a @i{complex}---see @ref{Rule of Canonical Representation for Complex Rationals}.

@IGindex{colon}
@item @b{colon}
 @i{n.}
  the @i{standard character} that is called ``colon'' (@t{:}).
  See @i{Figure~2--5}.

@IGindex{comma}
@item @b{comma}
 @i{n.}
  the @i{standard character} that is called ``comma'' (@t{,}).
  See @i{Figure~2--5}.

@IGindex{compilation}
@item @b{compilation}
 @i{n.}
  the process of @i{compiling} @i{code} by the @i{compiler}.

@IGindex{compilation environment}
@item @b{compilation environment}
 @i{n.} 
  1. An @i{environment} that represents information known by the
     @i{compiler} about a @i{form} that is being @i{compiled}.
     See @ref{Compiler Terminology}.
  2. An @i{object} that represents the
     @i{compilation environment}_1 
     and that is used as a second argument to a @i{macro function}
     (which supplies a @i{value} for any @b{&environment} @i{parameter}
      in the @i{macro function}'s definition).

@IGindex{compilation unit}
@item @b{compilation unit}
 @i{n.}
  an interval during which a single unit of compilation is occurring.
  See the @i{macro} @b{with-compilation-unit}.

@IGindex{compile}
@item @b{compile}
 @i{v.t.} 
  1. (@i{code})
     to perform semantic preprocessing of the @i{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 @i{load time values}
     to be resolved prior to run time.
  2. (a @i{function})
     to produce a new @i{object} of @i{type} @b{compiled-function}
     which represents the result of @i{compiling} the @i{code} 
     represented by the @i{function}.  See the @i{function} @b{compile}.
  3. (a @i{source file})
     to produce a @i{compiled file} from a @i{source file}.
     See the @i{function} @b{compile-file}.

@IGindex{compile time}
@item @b{compile time}
 @i{n.} 
  the duration of time that the @i{compiler} is processing @i{source code}.

@IGindex{compile-time definition}
@item @b{compile-time definition}
 @i{n.}
  a definition in the @i{compilation environment}.

@IGindex{compiled code}
@item @b{compiled code}
 @i{n.}
  1. @i{compiled functions}.
  2. @i{code} that represents @i{compiled functions},
     such as the contents of a @i{compiled file}.

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

@IGindex{compiled function}
@item @b{compiled function}
 @i{n.}
  an @i{object} of @i{type} @b{compiled-function}, which is a @i{function}
  that has been @i{compiled}, which contains no references to @i{macros} that
  must be expanded at run time, and which contains no unresolved references 
  to @i{load time values}.

@IGindex{compiler}
@item @b{compiler}
 @i{n.}
  a facility that is part of Lisp and that translates @i{code}
  into an @i{implementation-dependent} form
  that might be represented or @i{executed} efficiently.
  The functions @b{compile} and @b{compile-file}
  permit programs to invoke the @i{compiler}.

@IGindex{compiler macro}
@item @b{compiler macro}
 @i{n.}
  an auxiliary macro definition for a globally defined @i{function}
  or @i{macro} which might or might not be called by any given
  @i{conforming implementation} and which must preserve the semantics
  of the globally defined @i{function} or @i{macro} but which might
  perform some additional optimizations.  (Unlike a @i{macro}, 
  a @i{compiler macro} does not extend the syntax of @r{Common Lisp}; rather, it
  provides an alternate implementation strategy for some existing syntax
  or functionality.)

@IGindex{compiler macro expansion}
@item @b{compiler macro expansion}
 @i{n.}
  1. the process of translating a @i{form} into another @i{form}
     by a @i{compiler macro}.
  2. the @i{form} resulting from this process.

@IGindex{compiler macro form}
@item @b{compiler macro form}
 @i{n.}
  a @i{function form} or @i{macro form} whose @i{operator}
  has a definition as a @i{compiler macro}, 
  or a @b{funcall} @i{form} whose first @i{argument} is a
  @b{function} @i{form} whose @i{argument} is the @i{name}
  of a @i{function} that has a definition as a @i{compiler macro}.

@IGindex{compiler macro function}
@item @b{compiler macro function}
 @i{n.} 
  a @i{function} of two arguments, a @i{form} and an 
  @i{environment}, that implements @i{compiler macro expansion} by
  producing either a @i{form} to be used in place of the original
  argument @i{form} or else @b{nil}, indicating that the original @i{form}
  should not be replaced.  See @ref{Compiler Macros}.

@IGindex{complex}
@item @b{complex}
 @i{n.}
  an @i{object} of @i{type} @b{complex}.

@IGindex{complex float}
@item @b{complex float}
 @i{n.}
  an @i{object} of @i{type} @b{complex} which has a @i{complex part type}
  that is a @i{subtype} of @b{float}.
  A @i{complex float} is a @i{complex},
  but it is not a @i{float}.

@IGindex{complex part type}
@item @b{complex part type}
 @i{n.} (of a @i{complex})
  1. the @i{type} which is used to represent both the real part 
     and the imaginary part of the @i{complex}.
  2. the @i{actual complex part type} of the @i{complex}.
  3. the @i{expressed complex part type} of the @i{complex}.

@IGindex{complex rational}
@item @b{complex rational}
 @i{n.}
  an @i{object} of @i{type} @b{complex} which has a @i{complex part type}
  that is a @i{subtype} of @b{rational}.
  A @i{complex rational} is a @i{complex}, but it is not a @i{rational}.  
  No @i{complex rational} has an imaginary part of zero because such a
  number is always represented by @r{Common Lisp} as an @i{object} of @i{type} @b{rational};
  see @ref{Rule of Canonical Representation for Complex Rationals}.

@IGindex{complex single float}
@item @b{complex single float}
 @i{n.}
  an @i{object} of @i{type} @b{complex} which has a @i{complex part type}
  that is a @i{subtype} of @b{single-float}.
  A @i{complex single float} is a @i{complex},
  but it is not a @i{single float}.

@IGindex{composite stream}
@item @b{composite stream}
 @i{n.}
  a @i{stream} that is composed of one or more other @i{streams}.
  {``@b{make-synonym-stream} creates a composite stream.''}

@IGindex{compound form}
@item @b{compound form}
 @i{n.}
  a @i{non-empty} @i{list} which is a @i{form}:
  a @i{special form},
  a @i{lambda form},
  a @i{macro form}, 
  or a @i{function form}.

@IGindex{compound type specifier}
@item @b{compound type specifier}
 @i{n.}
  a @i{type specifier} that is a @i{cons};
  @i{i.e.}, a @i{type specifier} that is not an @i{atomic type specifier}.
  {``@t{(vector single-float)} is a compound type specifier.''}

@IGindex{concatenated stream}
@item @b{concatenated stream}
 @i{n.}
  an @i{input} @i{stream} of @i{type} @b{concatenated-stream}.

@IGindex{condition}
@item @b{condition}
 @i{n.}
  1. an @i{object} which represents a @i{situation}---usually,
     but not necessarily, during @i{signaling}.
  2. an @i{object} of @i{type} @b{condition}.

@IGindex{condition designator}
@item @b{condition designator}
 @i{n.}
  one or more @i{objects} that, taken together, 
  denote either an existing @i{condition} @i{object} 
	     or a @i{condition} @i{object} to be implicitly created.
  For details, see @ref{Condition Designators}.

@IGindex{condition handler}
@item @b{condition handler}
 @i{n.}
  a @i{function} that might be invoked by the act of @i{signaling},
  that receives the @i{condition} being signaled as its only argument,
  and that is permitted to @i{handle} the @i{condition} 
  or to @i{decline}.  See @ref{Signaling}.

@IGindex{condition reporter}
@item @b{condition reporter}
 @i{n.}
  a @i{function} that describes how a @i{condition} is to be printed
  when the @i{Lisp printer} is invoked while @b{*print-escape*} 
  is @i{false}.  See @ref{Printing Conditions}.

@IGindex{conditional newline}
@item @b{conditional newline}
 @i{n.}
  a point in output where a @i{newline} might be inserted at the
  discretion of the @i{pretty printer}.
  There are four kinds of @i{conditional newlines},
  called ``linear-style,''
	 ``fill-style,''
	 ``miser-style,''
     and ``mandatory-style.''
  See the @i{function} @b{pprint-newline} and @ref{Dynamic Control of the Arrangement of Output}.

@IGindex{conformance}
@item @b{conformance}
 @i{n.}
  a state achieved by proper and complete adherence to the requirements
  of this specification.  See @ref{Conformance}.

@IGindex{conforming code}
@item @b{conforming code}
 @i{n.}
  @i{code} that is all of part of a @i{conforming program}.

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

@IGindex{conforming processor}
@item @b{conforming processor}
 @i{n.} @i{ANSI} 
  a @i{conforming implementation}.

@IGindex{conforming program}
@item @b{conforming program}
 @i{n.}
  a @i{program}, used to emphasize the fact that the @i{program}
  depends for its correctness only upon documented aspects of @r{Common Lisp}, and
  can therefore be expected to run correctly in any @i{conforming implementation}.

@IGindex{congruent}
@item @b{congruent}
 @i{n.} 
  conforming to the rules of @i{lambda list} congruency, as detailed in 
  @ref{Congruent Lambda-lists for all Methods of a Generic Function}.

@IGindex{cons}
@item @b{cons}
 @i{n.}@i{v.} 
  1. @i{n.} a compound data @i{object} having two components called the
     @i{car} and the @i{cdr}.
  2. @i{v.} to create such an @i{object}.
  3. @i{v.} @i{Idiom.} to create any @i{object}, or to allocate storage.

@IGindex{constant}
@item @b{constant}
 @i{n.}
  1. a @i{constant form}.
  2. a @i{constant variable}.
  3. a @i{constant object}.
  4. a @i{self-evaluating object}.

@IGindex{constant form}
@item @b{constant form}
 @i{n.}
  any @i{form}
   for which @i{evaluation} always @i{yields} the same @i{value},
   that neither affects nor is affected by the @i{environment}
     in which it is @i{evaluated} (except that it is permitted to
     refer to the names of @i{constant variables} 
     defined in the @i{environment}),
   and
   that neither affects nor is affected by the state of any @i{object}
     except those @i{objects} that are @i{otherwise inaccessible parts}
     of @i{objects} created by the @i{form} itself.
  {``A @b{car} form in which the argument is a
            @b{quote} form is a constant form.''}

@IGindex{constant object}
@item @b{constant object}
 @i{n.}
  an @i{object} that is constrained (@i{e.g.}, by its context in a @i{program}
  or by the source from which it was obtained) to be @i{immutable}.
  {``A literal object that has been processed by @b{compile-file}
	    is a constant object.''}

@IGindex{constant variable}
@item @b{constant variable}
 @i{n.}
  a @i{variable}, the @i{value} of which can never change;
  that is, a @i{keyword}_1 or a @i{named constant}.
  {``The symbols @b{t}, @b{nil}, @t{:direction}, and
            @b{most-positive-fixnum} are constant variables.''}

@IGindex{constituent}
@item @b{constituent}
 @i{n.}, @i{adj.}
  1. a. @i{n.} the @i{syntax type} of a @i{character} that is part of a @i{token}.
         For details, see @ref{Constituent Characters}.
     b. @i{adj.} (of a @i{character})
        having the @i{constituent}_@{1a@} @i{syntax type}_2.
     c. @i{n.} a @i{constituent}_@{1b@} @i{character}.
  2. @i{n.} (of a @i{composite stream})
     one of possibly several @i{objects} that collectively comprise
     the source or sink of that @i{stream}.

@IGindex{constituent trait}
@item @b{constituent trait}
 @i{n.} (of a @i{character})
  one of several classifications of a @i{constituent} @i{character}
  in a @i{readtable}.  See @ref{Constituent Characters}.

@IGindex{constructed stream}
@item @b{constructed stream}
 @i{n.} 
  a @i{stream} whose source or sink is a Lisp @i{object}.
  Note that since a @i{stream} is another Lisp @i{object},
  @i{composite streams} are considered @i{constructed streams}.
  {``A string stream is a constructed stream.''}

@IGindex{contagion}
@item @b{contagion}
 @i{n.}
  a process whereby operations on @i{objects} of differing @i{types}
  (@i{e.g.}, arithmetic on mixed @i{types} of @i{numbers}) produce a result
  whose @i{type} is controlled by the dominance of one @i{argument}'s
  @i{type} over the @i{types} of the other @i{arguments}.
  See @ref{Contagion in Numeric Operations}.

@IGindex{continuable}
@item @b{continuable}
 @i{n.} (of an @i{error})
  an @i{error} that is @i{correctable} by the @t{continue} restart.

@IGindex{control form}
@item @b{control form}
 @i{n.}
  1. a @i{form} that establishes one or more places to which control
     can be transferred.
  2. a @i{form} that transfers control.

@IGindex{copy}
@item @b{copy}
 @i{n.}
  1. (of a @i{cons} C)
     a @i{fresh} @i{cons} with the @i{same} @i{car} and @i{cdr} as C.
  2. (of a @i{list} L)
     a @i{fresh} @i{list} with the @i{same} @i{elements} as L.  
     (Only the @i{list structure} is @i{fresh};
      the @i{elements} are the @i{same}.)
     See the @i{function} @b{copy-list}.
  3. (of an @i{association list} A with @i{elements} A_i)
     a @i{fresh} @i{list} B with @i{elements} B_i, each of which is
     @b{nil} if A_i is @b{nil}, or else a @i{copy} of the @i{cons} A_i.
     See the @i{function} @b{copy-alist}.
  4. (of a @i{tree} T)
     a @i{fresh} @i{tree} with the @i{same} @i{leaves} as T.
     See the @i{function} @b{copy-tree}.
  5. (of a @i{random state} R)
     a @i{fresh} @i{random state} that, if used as an argument to
     to the @i{function} @b{random} would produce the same series of ``random''
     values as R would produce.

  6. (of a @i{structure} S)
     a @i{fresh} @i{structure} that has the same @i{type} as S,
     and that has slot values, each of which is the @i{same} as the 
     corresponding slot value of S.

  (Note that since the difference between a @i{cons}, a @i{list}, 
   and a @i{tree} is a matter of ``view'' or ``intention,''  there can
   be no general-purpose @i{function} which, based solely on the @i{type}
   of an @i{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 @i{copy} of the
   given @i{list}'' or ``copy of the @i{list} @i{x}'' imply the
   second definition.)

@IGindex{correctable}
@item @b{correctable}
 @i{adj.} (of an @i{error})
  1. (by a @i{restart} other than @b{abort} 
      that has been associated with the @i{error})
     capable of being corrected by invoking that @i{restart}.
     {``The function @b{cerror} signals an error 
	       that is correctable by the @b{continue} @i{restart}.''}

     (Note that correctability is not a property of an
      @i{error} @i{object}, but rather a property of the 
      @i{dynamic environment} that is in effect when the
      @i{error} is @i{signaled}.
      Specifically, the @i{restart} is ``associated with'' 
      the @i{error} @i{condition} @i{object}.
      See @ref{Associating a Restart with a Condition}.)

  2. (when no specific @i{restart} is mentioned)
     @i{correctable}_1 by at least one @i{restart}.
     {``@b{import} signals a correctable error of @i{type} @b{package-error}
	       if any of the imported symbols has the same name as
	        some distinct symbol already accessible in the package.''}

@IGindex{current input base}
@item @b{current input base}
 @i{n.} (in a @i{dynamic environment})
  the @i{radix} that is the @i{value} of @b{*read-base*} in that @i{environment}, 
  and that is the default @i{radix} employed by the @i{Lisp reader}
  and its related @i{functions}.

@IGindex{current logical block}
@item @b{current logical block}
 @i{n.}
  the context of the innermost lexically enclosing use of @b{pprint-logical-block}.

@IGindex{current output base}
@item @b{current output base}
 @i{n.} (in a @i{dynamic environment})
  the @i{radix} that is the @i{value} of @b{*print-base*} in that @i{environment}, 
  and that is the default @i{radix} employed by the @i{Lisp printer}
  and its related @i{functions}.

@IGindex{current package}
@item @b{current package}
 @i{n.} (in a @i{dynamic environment})
  the @i{package} that is the @i{value} of @b{*package*} in that @i{environment}, 
  and that is the default @i{package} employed by the @i{Lisp reader} 
  and @i{Lisp printer}, and their related @i{functions}.

@IGindex{current pprint dispatch table}
@item @b{current pprint dispatch table}
 @i{n.} (in a @i{dynamic environment})
  the @i{pprint dispatch table} that is the @i{value} of @b{*print-pprint-dispatch*}
  in that @i{environment}, and that is the default @i{pprint dispatch table}
  employed by the @i{pretty printer}.

@IGindex{current random state}
@item @b{current random state}
 @i{n.} (in a @i{dynamic environment})
  the @i{random state} that is the @i{value} of @b{*random-state*} in that @i{environment}, 
  and that is the default @i{random state} employed by @b{random}.

@IGindex{current readtable}
@item @b{current readtable}
 @i{n.} (in a @i{dynamic environment})
  the @i{readtable} that is the @i{value} of @b{*readtable*} in that @i{environment}, 
  and that affects the way in which @i{expressions}_2 are parsed 
  into @i{objects} by the @i{Lisp reader}.

@end table
@subheading @b{D}
@table @asis

@IGindex{data type}
@item @b{data type}
 @i{n.} @i{Trad.} 
  a @i{type}.

@IGindex{debug I/O}
@item @b{debug I/O}
 @i{n.} 
  the @i{bidirectional} @i{stream} 
  that is the @i{value} of the @i{variable} @b{*debug-io*}.

@IGindex{debugger}
@item @b{debugger}
 @i{n.}
  a facility that allows the @i{user} to handle a @i{condition} interactively.
  For example, the @i{debugger} might permit interactive
  selection of a @i{restart} from among the @i{active} @i{restarts},
  and it might perform additional @i{implementation-defined} services
  for the purposes of debugging.

@IGindex{declaration}
@item @b{declaration}
 @i{n.}
  a @i{global declaration} or @i{local declaration}.

@IGindex{declaration identifier}
@item @b{declaration identifier}
 @i{n.}
  one of the @i{symbols}
     @b{declaration},
     @b{dynamic-extent},
     @b{ftype},
     @b{function},
     @b{ignore}, 
     @b{inline},  
     @b{notinline},
     @b{optimize}, 
     @b{special}, 
  or @b{type};
  or a @i{symbol} which is the @i{name} of a @i{type};
  or a @i{symbol} which has been @i{declared}
     to be a @i{declaration identifier} by using a @b{declaration}
     @i{declaration}.

@IGindex{declaration specifier}
@item @b{declaration specifier}
 @i{n.}
  an @i{expression} that can appear at top level of a @b{declare} 
  expression or a @b{declaim} form, or as the argument to @b{proclaim},
  and which has a @i{car} which is a @i{declaration identifier},
  and which has a @i{cdr} that is data interpreted according to rules
  specific to the @i{declaration identifier}.

@IGindex{declare}
@item @b{declare}
 @i{v.} 
  to @i{establish} a @i{declaration}.
  See @b{declare}, @b{declaim}, or @b{proclaim}.

@IGindex{decline}
@item @b{decline}
 @i{v.} (of a @i{handler})
  to return normally without having @i{handled} the @i{condition}
  being @i{signaled}, permitting the signaling process to continue
  as if the @i{handler} had not been present.

@IGindex{decoded time}
@item @b{decoded time}
 @i{n.}
  @i{absolute} @i{time}, represented as an ordered series of
  nine @i{objects} which, taken together, form a description of
  a point in calendar time, accurate to the nearest second (except
  that @i{leap seconds} are ignored).
  See @ref{Decoded Time}.

@IGindex{default method}
@item @b{default method}
 @i{n.}
  a @i{method} having no @i{parameter specializers} other than
  the @i{class} @b{t}.  Such a @i{method} is always an @i{applicable method}
  but might be @i{shadowed}_2 by a more specific @i{method}.

@IGindex{defaulted initialization argument list}
@item @b{defaulted initialization argument list}
 @i{n.}
  a @i{list} of alternating initialization argument @i{names} and
  @i{values} in which unsupplied initialization arguments are
  defaulted, used in the protocol for initializing and reinitializing 
  @i{instances} of @i{classes}.

@IGindex{define-method-combination arguments lambda list}
@item @b{define-method-combination arguments lambda list}
 @i{n.}
  a @i{lambda list} used by the @t{:arguments} option 
  to @b{define-method-combination}.
  See @ref{Define-method-combination Arguments Lambda Lists}.

@IGindex{define-modify-macro lambda list}
@item @b{define-modify-macro lambda list}
 @i{n.}
  a @i{lambda list} used by @b{define-modify-macro}.
  See @ref{Define-modify-macro Lambda Lists}.

@IGindex{defined name}
@item @b{defined name}
 @i{n.}
  a @i{symbol} the meaning of which is defined by @r{Common Lisp}.

@IGindex{defining form}
@item @b{defining form}
 @i{n.}
  a @i{form} that has the side-effect of @i{establishing} a definition.
  {``@b{defun} and @b{defparameter} are defining forms.''}

@IGindex{defsetf lambda list}
@item @b{defsetf lambda list}
 @i{n.}
  a @i{lambda list} that is like an @i{ordinary lambda list} 
  except that it does not permit @b{&aux}
     and that it permits use of @b{&environment}.
  See @ref{Defsetf Lambda Lists}.

@IGindex{deftype lambda list}
@item @b{deftype lambda list}
 @i{n.}
  a @i{lambda list} that is like a @i{macro lambda list}
  except that the default @i{value} for unsupplied @i{optional parameters}
  and @i{keyword parameters} is the @i{symbol} @b{*} (rather than @b{nil}).
  See @ref{Deftype Lambda Lists}.

@IGindex{denormalized}
@item @b{denormalized}
 @i{adj.}, @i{ANSI}, @i{IEEE} (of a @i{float})
  conforming to the description of ``denormalized'' as described by 
  {IEEE Standard for Binary Floating-Point Arithmetic}.
  For example, in an @i{implementation} where the minimum possible exponent 
  was @t{-7} but where @t{0.001} was a valid mantissa, the number @t{1.0e-10}
  might be representable as @t{0.001e-7} internally even if the @i{normalized}
  representation would call for it to be represented instead as @t{1.0e-10} 
  or @t{0.1e-9}.  By their nature, @i{denormalized} @i{floats} generally
  have less precision than @i{normalized} @i{floats}.

@IGindex{derived type}
@item @b{derived type}
 @i{n.}
  a @i{type specifier} which is defined in terms of an expansion into another
  @i{type specifier}.  @b{deftype} defines @i{derived types}, 
  and there may be other @i{implementation-defined} @i{operators}
  which do so as well.

@IGindex{derived type specifier}
@item @b{derived type specifier}
 @i{n.}
  a @i{type specifier} for a @i{derived type}.

@IGindex{designator}
@item @b{designator}
 @i{n.} 
  an @i{object} that denotes another @i{object}.
  In the dictionary entry for an @i{operator}
  if a @i{parameter} is described as a @i{designator} for a @i{type},
  the description of the @i{operator} is written in a way
  that assumes that appropriate coercion to that @i{type} has already occurred;
  that is, that the @i{parameter} is already of the denoted @i{type}.
  For more detailed information, see @ref{Designators}.

@IGindex{destructive}
@item @b{destructive}
 @i{adj.} (of an @i{operator})
  capable of modifying some program-visible aspect of one or more
  @i{objects} that are either explicit @i{arguments} to the
  @i{operator} or that can be obtained directly or indirectly 
  from the @i{global environment} by the @i{operator}.

@IGindex{destructuring lambda list}
@item @b{destructuring lambda list}
 @i{n.}
  an @i{extended lambda list} used in @b{destructuring-bind} and
  nested within @i{macro lambda lists}.  
  See @ref{Destructuring Lambda Lists}.

@IGindex{different}
@item @b{different}
 @i{adj.} 
  not the @i{same}
  {``The strings @t{"FOO"} and @t{"foo"} are different under
	    @b{equal} but not under @b{equalp}.''}

@IGindex{digit}
@item @b{digit}
 @i{n.} (in a @i{radix})
  a @i{character} that is among the possible digits (@t{0} to @t{9},
  @t{A} to @t{Z}, and @t{a} to @t{z}) and that is defined to have an 
  associated numeric weight as a digit in that @i{radix}.
  See @ref{Digits in a Radix}.

@IGindex{dimension}
@item @b{dimension}
 @i{n.}
  1. a non-negative @i{integer} indicating the number of
     @i{objects} an @i{array} can hold along one axis.
     If the @i{array} is a @i{vector} with a @i{fill pointer},
     the @i{fill pointer} is ignored.
     {``The second dimension of that array is 7.''}
  2. an axis of an array.
     {``This array has six dimensions.''}

@IGindex{direct instance}
@item @b{direct instance}
 @i{n.} (of a @i{class} C)
  an @i{object} whose @i{class} is C itself,
  rather than some @i{subclass} of C.
  {``The function @b{make-instance} always returns a 
  	    direct instance of the class which is (or is named by)
	    its first argument.''}

@IGindex{direct subclass}
@item @b{direct subclass}
 @i{n.} (of a @i{class} C_1)
  a @i{class} C_2,
  such that C_1 is a @i{direct superclass} of C_2.

@IGindex{direct superclass}
@item @b{direct superclass}
 @i{n.} (of a @i{class} C_1)
  a @i{class} C_2 which was explicitly designated as 
  a @i{superclass} of C_1 in the definition of C_1.

@IGindex{disestablish}
@item @b{disestablish}
 @i{v.t.} 
  to withdraw the @i{establishment} of 
      an @i{object},
      a  @i{binding},
      an @i{exit point}, 
      a  @i{tag},
      a  @i{handler},
      a  @i{restart}, 
   or an @i{environment}.

@IGindex{disjoint}
@item @b{disjoint}
 @i{n.} (of @i{types})
  having no @i{elements} in common.

@IGindex{dispatching macro character}
@item @b{dispatching macro character}
 @i{n.} 
  a @i{macro character} that has an associated table that specifies 
  the @i{function} to be called for each @i{character} that is
  seen following the @i{dispatching macro character}.
  See the @i{function} @b{make-dispatch-macro-character}.

@IGindex{displaced array}
@item @b{displaced array}
 @i{n.}
  an @i{array} which has no storage of its own, but which is instead
  indirected to the storage of another @i{array}, called its
  @i{target}, at a specified offset, in such a way that any attempt
  to @i{access} the @i{displaced array} implicitly references the 
  @i{target} @i{array}.

@IGindex{distinct}
@item @b{distinct}
 @i{adj.}
  not @i{identical}.

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

@IGindex{dot}
@item @b{dot}
 @i{n.}
  the @i{standard character} that is variously called
     ``full stop,''
     ``period,''
  or ``dot'' (@t{.}).
  See @i{Figure~2--5}.

@IGindex{dotted list}
@item @b{dotted list}
 @i{n.}
  a @i{list} which has a terminating @i{atom} that is not @b{nil}.
  (An @i{atom} by itself is not a @i{dotted list}, however.)

@IGindex{dotted pair}
@item @b{dotted pair}
 @i{n.}
  1. a @i{cons} whose @i{cdr} is a @i{non-list}.
  2. any @i{cons}, used to emphasize the use of the @i{cons}
     as a symmetric data pair.

@IGindex{double float}
@item @b{double float}
 @i{n.}
  an @i{object} of @i{type} @b{double-float}.

@IGindex{double-quote}
@item @b{double-quote}
 @i{n.}
  the @i{standard character} that is variously called
      ``quotation mark''
   or ``double quote'' (@t{"}).
  See @i{Figure~2--5}.

@IGindex{dynamic binding}
@item @b{dynamic binding}
 @i{n.} 
  a @i{binding} in a @i{dynamic environment}.

@IGindex{dynamic environment}
@item @b{dynamic environment}
 @i{n.}
  that part of an @i{environment} that contains @i{bindings} 
  with @i{dynamic extent}.  A @i{dynamic environment} contains,
  among other things:
    @i{exit points} established by @b{unwind-protect},
  and 
    @i{bindings} of
      @i{dynamic variables},
      @i{exit points} established by @b{catch},
      @i{condition handlers},
    and
      @i{restarts}.  

@IGindex{dynamic extent}
@item @b{dynamic extent}
 @i{n.}
  an @i{extent} whose duration is bounded by points of 
  @i{establishment} and @i{disestablishment} within the execution
  of a particular @i{form}.  See @i{indefinite extent}.
  {``Dynamic variable bindings have dynamic extent.''}

@IGindex{dynamic scope}
@item @b{dynamic scope}
 @i{n.}
  @i{indefinite scope} along with @i{dynamic extent}.

@IGindex{dynamic variable}
@item @b{dynamic variable}
 @i{n.}
  a @i{variable} the @i{binding} for which is in the @i{dynamic environment}.
  See @b{special}.

@end table
@subheading @b{E}
@table @asis

@IGindex{echo stream}
@item @b{echo stream}
 @i{n.}
  a @i{stream} of @i{type} @b{echo-stream}.

@IGindex{effective method}
@item @b{effective method}
 @i{n.}
  the combination of @i{applicable methods} that are executed
  when a @i{generic function} is invoked with a particular sequence
  of @i{arguments}.

@IGindex{element}
@item @b{element}
 @i{n.}
  1. (of a @i{list}) 
     an @i{object} that is the @i{car} of one of the @i{conses}
     that comprise the @i{list}.
  2. (of an @i{array})
     an @i{object} that is stored in the @i{array}.
  3. (of a @i{sequence})
     an @i{object} that is an @i{element} of the @i{list} or @i{array}
     that is the @i{sequence}.
  4. (of a @i{type})
     an @i{object} that is a member of the set of @i{objects}
     designated by the @i{type}.
  5. (of an @i{input} @i{stream})
     a @i{character} or @i{number} (as appropriate to the
     @i{element type} of the @i{stream})
     that is among the ordered series of @i{objects} that can be 
     read from the @i{stream} (using @b{read-char} or @b{read-byte},
     as appropriate to the @i{stream}).
  6. (of an @i{output} @i{stream})
     a @i{character} or @i{number} (as appropriate to the
     @i{element type} of the @i{stream})
     that is among the ordered series of @i{objects} that has been
     or will be written to the @i{stream} (using @b{write-char} 
     or @b{write-byte}, as appropriate to the @i{stream}).
  7. (of a @i{class}) a @i{generalized instance} of the @i{class}.

@IGindex{element type}
@item @b{element type}
 @i{n.} 
  1. (of an @i{array}) the @i{array element type} of the @i{array}.
  2. (of a @i{stream}) the @i{stream element type} of the @i{stream}.

@IGindex{em}
@item @b{em}
 @i{n.} @i{Trad.} 
  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 @i{glyph} in the font, and other characters' 
   widths are typically fractions of an @i{em}.  In implementations providing 
   non-Roman characters with wider characters than ``M,'' it is permissible 
   for another character to be the @i{implementation-defined} reference character
   for this measure, and for ``M'' to be only a fraction of an @i{em}
   wide.)  
  In a fixed width font, a line with @i{n} characters is @i{n} 
  @i{ems} wide; in a variable width font, @i{n} @i{ems} is the
  expected upper bound on the width of such a line.

@IGindex{empty list}
@item @b{empty list}
 @i{n.}
  the @i{list} containing no @i{elements}. See @i{()}.

@IGindex{empty type}
@item @b{empty type}
 @i{n.}
  the @i{type} that contains no @i{elements}, and that is
  a @i{subtype} of all @i{types} (including itself).
  See @i{nil}.

@IGindex{end of file}
@item @b{end of file}
 @i{n.}
  1. the point in an @i{input} @i{stream} beyond which there is
     no further data.
     Whether or not there is such a point on an @i{interactive stream} 
     is @i{implementation-defined}.
  2. a @i{situation} that occurs upon an attempt to obtain data from an
     @i{input stream} that is at the @i{end of file}_1.

@IGindex{environment}
@item @b{environment}
 @i{n.}
  1. a set of @i{bindings}. See @ref{Introduction to Environments}.
  2. an @i{environment object}.
     {``@b{macroexpand} takes an optional environment argument.''}

@IGindex{environment object}
@item @b{environment object}
 @i{n.}
  an @i{object} representing a set of @i{lexical bindings},
     used in the processing of a @i{form} to provide meanings for
     @i{names} within that @i{form}.
     {``@b{macroexpand} takes an optional environment argument.''}
     (The @i{object} @b{nil} when used as an @i{environment object}
      denotes the @i{null lexical environment};
      the @i{values} of @i{environment parameters} 
      to @i{macro functions} are @i{objects}
      of @i{implementation-dependent} nature which represent the 
      @i{environment}_1 in which the corresponding @i{macro form}
      is to be expanded.)
     See @ref{Environment Objects}.

@IGindex{environment parameter}
@item @b{environment parameter}
 @i{n.}
  A @i{parameter} in a @i{defining form} f for which there is no corresponding
  @i{argument}; instead, this @i{parameter} receives as its value an
  @i{environment} @i{object} which corresponds to the
  @i{lexical environment} in which the @i{defining form} f appeared.

@IGindex{error}
@item @b{error}
 @i{n.}
  1. (only in the phrase ``is an error'')
     a @i{situation} in which the semantics of a program are not specified, 
     and in which the consequences are undefined.
  2. a @i{condition} which represents an @i{error} @i{situation}.
     See @ref{Error Terminology}.
  3. an @i{object} of @i{type} @b{error}.

@IGindex{error output}
@item @b{error output}
 @i{n.} 
  the @i{output} @i{stream} which is the @i{value} of the @i{dynamic variable}
  @b{*error-output*}.

@IGindex{escape}
@item @b{escape}
 @i{n.}, @i{adj.}
  1. @i{n.} a @i{single escape} or a @i{multiple escape}.
  2. @i{adj.} @i{single escape} or @i{multiple escape}.

@IGindex{establish}
@item @b{establish}
 @i{v.t.} 
  to build or bring into being 
      a  @i{binding},
      a  @i{declaration},
      an @i{exit point},
      a  @i{tag},
      a  @i{handler}, 
      a @i{restart},
   or an @i{environment}. 
  {``@b{let} establishes lexical bindings.''}

@IGindex{evaluate}
@item @b{evaluate}
 @i{v.t.} (a @i{form} or an @i{implicit progn})
  to @i{execute} the @i{code} represented by the @i{form}
  (or the series of @i{forms} making up the @i{implicit progn})
  by applying the rules of @i{evaluation},
  returning zero or more values.

@IGindex{evaluation}
@item @b{evaluation}
 @i{n.}
  a model whereby @i{forms} are @i{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 @i{form} and then
  @i{executing} the @i{compiled} @i{code}; this choice is 
  dependent both on context and the nature of the @i{implementation}, 
  but in any case is not in general detectable by any program.  The evaluation
  model is designed in such a way that a @i{conforming implementation} 
  might legitimately have only a compiler and no interpreter, or vice versa.
  See @ref{The Evaluation Model}.

@IGindex{evaluation environment}
@item @b{evaluation environment}
 @i{n.}
  a @i{run-time environment} in which macro expanders 
  and code specified by @b{eval-when} to be evaluated
  are evaluated.  All evaluations initiated by the @i{compiler} 
  take place in the @i{evaluation environment}.

@IGindex{execute}
@item @b{execute}
 @i{v.t.} @i{Trad.} (@i{code})
  to perform the imperative actions represented by the @i{code}.

@IGindex{execution time}
@item @b{execution time}
 @i{n.}
  the duration of time that @i{compiled code} is being @i{executed}.

@IGindex{exhaustive partition}
@item @b{exhaustive partition}
 @i{n.} (of a @i{type})
  a set of @i{pairwise} @i{disjoint} @i{types} that form an 
  @i{exhaustive union}.

@IGindex{exhaustive union}
@item @b{exhaustive union}
 @i{n.} (of a @i{type})
  a set of @i{subtypes} of the @i{type},
  whose union contains all @i{elements} of that @i{type}.

@IGindex{exit point}
@item @b{exit point}
 @i{n.}
  a point in a @i{control form}
       from which (@i{e.g.}, @b{block}),
       through which (@i{e.g.}, @b{unwind-protect}),
    or to which (@i{e.g.}, @b{tagbody})
  control and possibly @i{values} can be transferred both actively by using 
  another @i{control form} and passively through the normal control and
  data flow of @i{evaluation}.
  {``@b{catch} and @b{block} establish bindings for
            exit points to which @b{throw} and @b{return-from},
	    respectively, can transfer control and values;
	    @b{tagbody} establishes a binding for an exit point
	    with lexical extent to which @b{go} can transfer control;
	    and @b{unwind-protect} establishes an exit point 
	    through which control might be transferred by 
	    operators such as @b{throw}, @b{return-from},
            and @b{go}.''}

@IGindex{explicit return}
@item @b{explicit return}
 @i{n.} 
  the act of transferring control (and possibly @i{values}) 
  to a @i{block} by using @b{return-from} (or @b{return}).

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

@IGindex{exponent marker}
@item @b{exponent marker}
 @i{n.}
  a character that is used in the textual notation for a @i{float}
  to separate the mantissa from the exponent.
  The characters defined as @i{exponent markers} in the @i{standard readtable}
  are shown in Figure 26--1.
  For more information, see @ref{Character Syntax}.
  {``The exponent marker `d' in `3.0d7' indicates
	    that this number is to be represented as a double float.''}

@group
@noindent
@w{  Marker  Meaning                                  }
@w{  @t{D} or @t{d}  @b{double-float}                             }
@w{  @t{E} or @t{e}  @b{float} (see @b{*read-default-float-format*})  }
@w{  @t{F} or @t{f}  @b{single-float}                             }
@w{  @t{L} or @t{l}  @b{long-float}                               }
@w{  @t{S} or @t{s}  @b{short-float}                              }

@noindent
@w{           Figure 26--1: Exponent Markers          }

@end group

@IGindex{export}
@item @b{export}
 @i{v.t.} (a @i{symbol} in a @i{package})
  to add the @i{symbol} to the list of @i{external symbols} of the
  @i{package}.

@IGindex{exported}
@item @b{exported}
 @i{adj.} (of a @i{symbol} in a @i{package})
  being an @i{external symbol} of the @i{package}.

@IGindex{expressed adjustability}
@item @b{expressed adjustability}
 @i{n.} (of an @i{array})
  a @i{generalized boolean} that is conceptually (but not necessarily actually)
  associated with the @i{array}, representing whether the @i{array}
  is @i{expressly adjustable}.
  See also @i{actual adjustability}.

@IGindex{expressed array element type}
@item @b{expressed array element type}
 @i{n.} (of an @i{array})
  the @i{type} which is the @i{array element type}
  implied by a @i{type declaration} for the @i{array}, 
  or which is the requested @i{array element type} at its time 
  of creation, prior to any selection of an @i{upgraded array element type}.
  (@r{Common Lisp} does not provide a way of detecting this @i{type}
   directly at run time, but an @i{implementation} is permitted 
   to make assumptions about the @i{array}'s contents and
   the operations which may be performed on the @i{array} when
   this @i{type} is noted during code analysis, even if those 
   assumptions would not be valid in general for the
   @i{upgraded array element type} of the
   @i{expressed array element type}.)

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

@IGindex{expression}
@item @b{expression}
 @i{n.}
  1. an @i{object}, often used to emphasize the use 
     of the @i{object} to encode or represent information in a specialized
     format, such as program text.
     {``The second expression in a @b{let} form is a list
   	       of bindings.''}
  2. the textual notation used to notate an @i{object} in a source file.
     {``The expression @t{'sample} is equivalent to @t{(quote sample)}.''}

@IGindex{expressly adjustable}
@item @b{expressly adjustable}
 @i{adj.} (of an @i{array})
  being @i{actually adjustable} by virtue of an explicit request for this
  characteristic having been made at the time of its creation.
  All @i{arrays} that are @i{expressly adjustable} 
  are @i{actually adjustable},
  but not necessarily vice versa.

@IGindex{extended character}
@item @b{extended character}
 @i{n.}
  a @i{character} 

  of @i{type} @b{extended-char}:

  a @i{character} that is not a @i{base character}.

@IGindex{extended function designator}
@item @b{extended function designator}
 @i{n.}
  a @i{designator} for a @i{function}; that is,
  an @i{object} that denotes a @i{function}
  and that is one of:
      a @i{function name} (denoting the @i{function} it names
                              in the @i{global environment}),
   or a @i{function} (denoting itself).
  The consequences are undefined if 
  a @i{function name} is used as an 
  @i{extended function designator} but
  it does not have a global definition as a @i{function},
  or if it is a @i{symbol} 
     that has a global definition as a @i{macro} or a @i{special form}.
  See also @i{function designator}.

@IGindex{extended lambda list}
@item @b{extended lambda list}
 @i{n.}
  a list resembling an @i{ordinary lambda list} in form and purpose, but 
  offering additional syntax or functionality not available in an
  @i{ordinary lambda list}.
  {``@b{defmacro} uses extended lambda lists.''}

@IGindex{extension}
@item @b{extension}
 @i{n.}
  a facility in an @i{implementation} of @r{Common Lisp} 
  that is not specified by this standard.

@IGindex{extent}
@item @b{extent}
 @i{n.}
  the interval of time during which a @i{reference} to 
      an @i{object},
      a  @i{binding},
      an @i{exit point},
      a  @i{tag},
      a  @i{handler},
      a  @i{restart},
   or an @i{environment} is defined.

@IGindex{external file format}
@item @b{external file format}
 @i{n.}
  an @i{object} of @i{implementation-dependent} nature which determines
  one of possibly several @i{implementation-dependent} ways in which
  @i{characters} are encoded externally in a @i{character} @i{file}.

@IGindex{external file format designator}
@item @b{external file format designator}
 @i{n.}
  a @i{designator} for an @i{external file format}; that is,
  an @i{object} that denotes an @i{external file format}
  and that is one of:
      the @i{symbol} @t{:default} 
         (denoting an @i{implementation-dependent} default 
          @i{external file format} that can accomodate at least
          the @i{base characters}),
      some other @i{object} defined by the @i{implementation} to be
      an @i{external file format designator}
         (denoting an @i{implementation-defined} @i{external file format}),
   or some other @i{object} defined by the @i{implementation} to be
      an @i{external file format} 
         (denoting itself).

@IGindex{external symbol}
@item @b{external symbol}
 @i{n.} (of a @i{package})
  a @i{symbol} that is part of the `external interface' to the @i{package}
  and that are @i{inherited}_3 by any other @i{package}
   that @i{uses} the @i{package}.
  When using the @i{Lisp reader}, 
  if a @i{package prefix} is used,
  the @i{name} of an @i{external symbol} is separated
    from the @i{package} @i{name} by a single @i{package marker}
  while
  the @i{name} of an @i{internal symbol} is separated
    from the @i{package} @i{name} by a double @i{package marker};
  see @ref{Symbols as Tokens}.

@IGindex{externalizable object}
@item @b{externalizable object}
 @i{n.}
  an @i{object} that can be used as a @i{literal} @i{object} 
  in @i{code} to be processed by the @i{file compiler}.  

@end table
@subheading @b{F}
@table @asis

@IGindex{false}
@item @b{false}
 @i{n.}
  the @i{symbol} @b{nil},
  used to represent the failure of a @i{predicate} test.

@IGindex{fbound}
@item @b{fbound}
 pronounced 'ef ,baund  @i{adj.} 
							 (of a @i{function name})
  @i{bound} in the @i{function} @i{namespace}.
  (The @i{names} of @i{macros} and @i{special operators} are @i{fbound},
   but the nature and @i{type} of the @i{object} which is their @i{value}
   is @i{implementation-dependent}.

   Further, defining a @i{setf expander} @i{F} does not cause the @i{setf function}
   @t{(setf @i{F})} to become defined; as such, if there is a such a definition
   of a @i{setf expander} @i{F}, the @i{function} @t{(setf @i{F})}
   can be @i{fbound} if and only if, by design or coincidence, a
   function binding for @t{(setf @i{F})} has been independently established.)

  See the @i{functions} @b{fboundp} and @b{symbol-function}.

@IGindex{feature}
@item @b{feature}
 @i{n.}
  1. an aspect or attribute 
        of @r{Common Lisp}, 
        of the @i{implementation},
     or of the @i{environment}.
  2. a @i{symbol} that names a @i{feature}_1.
  See @ref{Features}.
  {``The @t{:ansi-cl} feature is present in all conforming implementations.''}

@IGindex{feature expression}
@item @b{feature expression}
 @i{n.}
  A boolean combination of @i{features} used by the @t{#+} and @t{#-} 
  @i{reader macros} in order to direct conditional @i{reading} of
  @i{expressions} by the @i{Lisp reader}.
  See @ref{Feature Expressions}.

@IGindex{features list}
@item @b{features list}
 @i{n.}
  the @i{list} that is the @i{value} of @b{*features*}.

@IGindex{file}
@item @b{file}
 @i{n.}
  a named entry in a @i{file system},
  having an @i{implementation-defined} nature.

@IGindex{file compiler}
@item @b{file compiler}
 @i{n.}
  any @i{compiler} which @i{compiles} @i{source code} contained in a @i{file},
  producing a @i{compiled file} as output.  The @b{compile-file} 
  function is the only interface to such a @i{compiler} provided by @r{Common Lisp},
  but there might be other, @i{implementation-defined} mechanisms for 
  invoking the @i{file compiler}.

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

@IGindex{file position designator}
@item @b{file position designator}
 @i{n.} (in a @i{stream})
  a @i{designator} for a @i{file position} in that @i{stream}; that is,
      the symbol @t{:start}  
        (denoting @t{0}, the first @i{file position} in that @i{stream}),
      the symbol @t{:end}
	(denoting the last @i{file position} in that @i{stream};
	 @i{i.e.}, the position following the last @i{element} of the @i{stream}),
   or a @i{file position} (denoting itself).

@IGindex{file stream}
@item @b{file stream}
 @i{n.}
  an @i{object} of @i{type} @b{file-stream}.

@IGindex{file system}
@item @b{file system}
 @i{n.}
  a facility which permits aggregations of data to be stored in named
  @i{files} on some medium that is external to the @i{Lisp image}
  and that therefore persists from @i{session} to @i{session}.

@IGindex{filename}
@item @b{filename}
 @i{n.}
  a handle, not necessarily ever directly represented as an @i{object},
  that can be used to refer to a @i{file} in a @i{file system}.
  @i{Pathnames} and @i{namestrings} are two kinds of @i{objects} 
  that substitute for @i{filenames} in @r{Common Lisp}.  

@IGindex{fill pointer}
@item @b{fill pointer}
 @i{n.} (of a @i{vector})
  an @i{integer} associated with a @i{vector} that represents the
  index above which no @i{elements} are @i{active}.
  (A @i{fill pointer} is a non-negative @i{integer} no
   larger than the total number of @i{elements} in the @i{vector}.
   Not all @i{vectors} have @i{fill pointers}.)

@IGindex{finite}
@item @b{finite}
 @i{adj.} (of a @i{type})
  having a finite number of @i{elements}.
  {``The type specifier @t{(integer 0 5)} denotes a finite type,
	    but the type specifiers @b{integer} and @t{(integer 0)} do not.''}

@IGindex{fixnum}
@item @b{fixnum}
 @i{n.} 
  an @i{integer} of @i{type} @b{fixnum}.

@IGindex{float}
@item @b{float}
 @i{n.}
  an @i{object} of @i{type} @b{float}.

@IGindex{for-value}
@item @b{for-value}
 @i{adj.} (of a @i{reference} to a @i{binding})
  being a @i{reference} that @i{reads}_1
  the @i{value} of the @i{binding}.

@IGindex{form}
@item @b{form}
 @i{n.}
  1. any @i{object} meant to be @i{evaluated}.
  2.    a @i{symbol},
        a @i{compound form},
     or a @i{self-evaluating object}.
  3. (for an @i{operator}, as in ``<<@i{operator}>> @i{form}'')
     a @i{compound form} having that @i{operator} as its first element.
     {``A @b{quote} form is a constant form.''}

@IGindex{formal argument}
@item @b{formal argument}
 @i{n.} @i{Trad.} 
  a @i{parameter}.

@IGindex{formal parameter}
@item @b{formal parameter}
 @i{n.} @i{Trad.} 
  a @i{parameter}.

@IGindex{format}
@item @b{format}
 @i{v.t.} (a @i{format control} and @i{format arguments})
  to perform output as if by @b{format},
  using the @i{format string} and @i{format arguments}.

@IGindex{format argument}
@item @b{format argument}
 @i{n.}
  an @i{object} which is used as data by functions such as @b{format}
  which interpret @i{format controls}.

@IGindex{format control}
@item @b{format control}
 @i{n.}
     a @i{format string},
  or a @i{function} that obeys the @i{argument} conventions
     for a @i{function} returned by the @b{formatter} @i{macro}.
  See @ref{Compiling Format Strings}.

@IGindex{format directive}
@item @b{format directive}
 @i{n.}
  1. a sequence of @i{characters} in a @i{format string}
     which is introduced by a @i{tilde}, and which is specially 
     interpreted by @i{code} which processes @i{format strings}
     to mean that some special operation should be performed, possibly
     involving data supplied by the @i{format arguments} that 
     accompanied the @i{format string}.  See the @i{function} @b{format}.
     {``In @t{"~D base 10 = ~8R"}, the character
     	       sequences `@t{~D}' and `@t{~8R}' are format directives.''}
  2. the conceptual category of all @i{format directives}_1
     which use the same dispatch character.
     {``Both @t{"~3d"} and @t{"~3,'0D"} are valid uses of the
	       `@t{~D}' format directive.''}

@IGindex{format string}
@item @b{format string}
 @i{n.}
  a @i{string} which can contain both ordinary text and @i{format directives},
  and which is used in conjunction with @i{format arguments} to describe how 
  text output should be formatted by certain functions, such as @b{format}.

@IGindex{free declaration}
@item @b{free declaration}
 @i{n.}
  a declaration that is not a @i{bound declaration}.
  See @b{declare}.

@IGindex{fresh}
@item @b{fresh}
 @i{adj.} 
  1. (of an @i{object} @i{yielded} by a @i{function})
     having been newly-allocated by that @i{function}.
     (The caller of a @i{function} that returns a @i{fresh} @i{object}
      may freely modify the @i{object} without fear that such modification will
      compromise the future correct behavior of that @i{function}.)
  2. (of a @i{binding} for a @i{name})
     newly-allocated; not shared with other @i{bindings} for that @i{name}.

@IGindex{freshline}
@item @b{freshline}
 @i{n.}
  a conceptual operation on a @i{stream}, implemented by the @i{function} @b{fresh-line}
  and by the @i{format directive} @t{~&}, which advances the display position
  to the beginning of the next line (as if a @i{newline} had been typed, or 
  the @i{function} @b{terpri} had been called)
  unless the @i{stream} is already known to be positioned at the beginning of a line.
  Unlike @i{newline}, @i{freshline} is not a @i{character}.

@IGindex{funbound}
@item @b{funbound}
 pronounced 'ef unbaund @i{n.} (of a @i{function name})
  not @i{fbound}.

@IGindex{function}
@item @b{function}
 @i{n.}

  1. an @i{object} representing code,
     which can be @i{called} with zero or more @i{arguments},
     and which produces zero or more @i{values}.
  2. an @i{object} of @i{type} @b{function}.

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

@IGindex{function cell}
@item @b{function cell}
 @i{n.} @i{Trad.} (of a @i{symbol})
  The @i{place} which holds the @i{definition} of the
  global @i{function} @i{binding}, if any, named by that @i{symbol},
  and which is @i{accessed} by @b{symbol-function}.
  See @i{cell}.

@IGindex{function designator}
@item @b{function designator}
 @i{n.}
  a @i{designator} for a @i{function}; that is,
  an @i{object} that denotes a @i{function}
  and that is one of:
      a @i{symbol} (denoting the @i{function} named by that @i{symbol}
                       in the @i{global environment}),
   or a @i{function} (denoting itself).
  The consequences are undefined if 
  a @i{symbol} is used as a @i{function designator} but
  it does not have a global definition as a @i{function},
  or it has a global definition as a @i{macro} or a @i{special form}.
  See also @i{extended function designator}.

@IGindex{function form}
@item @b{function form}
 @i{n.}
  a @i{form} that is a @i{list} and that has a first element 
  which is the @i{name} of a @i{function} to be called on
  @i{arguments} which are the result of @i{evaluating} subsequent
  elements of the @i{function form}.

@IGindex{function name}
@item @b{function name}
 @i{n.} (in an @i{environment})
  A @i{symbol} or a @i{list} @t{(setf @i{symbol})} 
  that is the @i{name} of a @i{function} in that @i{environment}.

@IGindex{functional evaluation}
@item @b{functional evaluation}
 @i{n.} 
  the process of extracting a @i{functional value} from a @i{function name}
  or a @i{lambda expression}.
  The evaluator performs @i{functional evaluation} 
       implicitly when it encounters a @i{function name} 
 	or a @i{lambda expression}
        in the @i{car} of a @i{compound form}, 
    or explicitly when it encounters a @b{function} @i{special form}.
  Neither a use of a @i{symbol} as a @i{function designator} nor a
  use of the @i{function} @b{symbol-function} to extract the @i{functional value}
  of a @i{symbol} is considered a @i{functional evaluation}.

@IGindex{functional value}
@item @b{functional value}
 @i{n.} 
  1. (of a @i{function name} N in an @i{environment} E)
     The @i{value} of the @i{binding} named N
     in the @i{function} @i{namespace} for @i{environment} E;
     that is, the contents of the @i{function cell} named N in 
     @i{environment} E.
  2. (of an @i{fbound} @i{symbol} S)
     the contents of the @i{symbol}'s @i{function cell}; that is,
     the @i{value} of the @i{binding} named S
     in the @i{function} @i{namespace} of the @i{global environment}.
     (A @i{name} that is a @i{macro name} in the @i{global environment}
      or is a @i{special operator} might or might not be @i{fbound}.
      But if S is such a @i{name} and is @i{fbound}, the specific
      nature of its @i{functional value} is @i{implementation-dependent};
      in particular, it might or might not be a @i{function}.)

@IGindex{further compilation}
@item @b{further compilation}
 @i{n.} 
  @i{implementation-dependent} compilation beyond @i{minimal compilation}.
  Further compilation is permitted to take place at @i{run time}.
  {``Block compilation and generation of machine-specific instructions
            are examples of further compilation.''}  

@end table
@subheading @b{G}
@table @asis

@IGindex{general}
@item @b{general}
 @i{adj.} (of an @i{array})
  having @i{element type} @b{t},
   and consequently able to have any @i{object} as an @i{element}.

@IGindex{generalized boolean}
@item @b{generalized boolean}
 @i{n.} 
  an @i{object} used as a truth value, where the symbol~@b{nil} 
  represents @i{false} and all other @i{objects} represent @i{true}.
  See @i{boolean}.

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

@IGindex{generalized reference}
@item @b{generalized reference}
 @i{n.}
  a reference to a location storing an @i{object} as if to a @i{variable}.
  (Such a reference can be either to @i{read} or @i{write} the location.)
  See @ref{Generalized Reference}.  See also @i{place}.

@IGindex{generalized synonym stream}
@item @b{generalized synonym stream}
 @i{n.} (with a @i{synonym stream symbol})
  1. (to a @i{stream}) 
     a @i{synonym stream} to the @i{stream},
     or a @i{composite stream} which has as a target 
     a @i{generalized synonym stream} to the @i{stream}.
  2. (to a @i{symbol})
     a @i{synonym stream} to the @i{symbol},
     or a @i{composite stream} which has as a target 
     a @i{generalized synonym stream} to the @i{symbol}.

@IGindex{generic function}
@item @b{generic function}
 @i{n.}
  a @i{function} whose behavior depends on the @i{classes} or
  identities of the arguments supplied to it and whose parts include, among
  other things, a set of @i{methods}, a @i{lambda list}, and a
  @i{method combination} type.

@IGindex{generic function lambda list}
@item @b{generic function lambda list}
 @i{n.}
  A @i{lambda list} that is used to describe data flow into a @i{generic function}.
  See @ref{Generic Function Lambda Lists}.

@IGindex{gensym}
@item @b{gensym}
 @i{n.} @i{Trad.} 
  an @i{uninterned} @i{symbol}.
  See the @i{function} @b{gensym}.

@IGindex{global declaration}
@item @b{global declaration}
 @i{n.} 
  a @i{form} that makes certain kinds of information about 
  code globally available; that is, a @b{proclaim} @i{form} 
  or a @b{declaim} @i{form}.

@IGindex{global environment}
@item @b{global environment}
 @i{n.} 
  that part of an @i{environment} that contains @i{bindings}
  with @i{indefinite scope} and @i{indefinite extent}.

@IGindex{global variable}
@item @b{global variable}
 @i{n.}
  a @i{dynamic variable} or a @i{constant variable}.

@IGindex{glyph}
@item @b{glyph}
 @i{n.} 
  a visual representation.
  {``Graphic characters have associated glyphs.''}

@IGindex{go}
@item @b{go}
 @i{v.} 
  to transfer control to a @i{go point}.
  See the @i{special operator} @b{go}.

@IGindex{go point}
@item @b{go point}

  one of possibly several @i{exit points} that are @i{established} 
  by @b{tagbody} (or other abstractions, such as @b{prog}, 
  which are built from @b{tagbody}).

@IGindex{go tag}
@item @b{go tag}
 @i{n.} 
  the @i{symbol} or @i{integer} that, within the @i{lexical scope} 
  of a @b{tagbody} @i{form}, names an @i{exit point}
  @i{established} by that @b{tagbody} @i{form}.

@IGindex{graphic}
@item @b{graphic}
 @i{adj.} (of a @i{character})
  being a ``printing'' or ``displayable'' @i{character} 
  that has a standard visual representation
  as a single @i{glyph}, such as @t{A} or @t{*} or @t{=}.
  @i{Space} is defined to be @i{graphic}.
  Of the @i{standard characters}, all but @i{newline} are @i{graphic}.
  See @i{non-graphic}.

@end table
@subheading @b{H}
@table @asis

@IGindex{handle}
@item @b{handle}
 @i{v.} (of a @i{condition} being @i{signaled})
  to perform a non-local transfer of control, terminating the ongoing
  @i{signaling} of the @i{condition}.

@IGindex{handler}
@item @b{handler}
 @i{n.} 

  a @i{condition handler}.

@IGindex{hash table}
@item @b{hash table}
 @i{n.} 
  an @i{object} of @i{type} @b{hash-table}, 
  which provides a mapping from @i{keys} to @i{values}.

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

@end table
@subheading @b{I}
@table @asis

@IGindex{I/O customization variable}
@item @b{I/O customization variable}
 @i{n.}
  one of the @i{stream variables} in Figure 26--2, 
  or some other (@i{implementation-defined}) @i{stream variable}
      that is defined by the @i{implementation} 
      to be an @i{I/O customization variable}.

@group
@noindent
@w{  *debug-io*        *error-io*         query-io*       }
@w{  *standard-input*  *standard-output*  *trace-output*  }

@noindent
@w{  Figure 26--2: Standardized I/O Customization Variables}

@end group

@IGindex{identical}
@item @b{identical}
 @i{adj.} 
  the @i{same} under @b{eq}.

@IGindex{identifier}
@item @b{identifier}
 @i{n.}        
  1. a @i{symbol} used to identify or to distinguish @i{names}. 
  2. a @i{string} used the same way.            

@IGindex{immutable}
@item @b{immutable}
 @i{adj.}
  not subject to change, either because no @i{operator} is provided which is
  capable of effecting such change or because some constraint exists which 
  prohibits the use of an @i{operator} that might otherwise be capable of
  effecting such a change.  Except as explicitly indicated otherwise,
  @i{implementations} are not required to detect attempts to modify
  @i{immutable} @i{objects} or @i{cells}; the consequences of attempting
  to make such modification are undefined.
  {``Numbers are immutable.''}

@IGindex{implementation}
@item @b{implementation}
 @i{n.} 
  a system, mechanism, or body of @i{code} that implements the semantics of @r{Common Lisp}.

@IGindex{implementation limit}
@item @b{implementation limit}
 @i{n.} 
  a restriction imposed by an @i{implementation}.

@IGindex{implementation-defined}
@item @b{implementation-defined}
 @i{adj.} 
  @i{implementation-dependent}, but required by this specification to be
  defined by each @i{conforming implementation} and to be documented by 
  the corresponding implementor.

@IGindex{implementation-dependent}
@item @b{implementation-dependent}
 @i{adj.} 
  describing a behavior or aspect of @r{Common Lisp} which has been deliberately left
  unspecified, that might be defined in some @i{conforming implementations} 
  but not in others, and whose details may differ between @i{implementations}.
  A @i{conforming implementation} is encouraged (but not required) to 
  document its treatment of each item in this specification which is
  marked @i{implementation-dependent}, although in some cases
  such documentation might simply identify the item as ``undefined.''

@IGindex{implementation-independent}
@item @b{implementation-independent}
 @i{adj.} 
  used to identify or emphasize a behavior or aspect of @r{Common Lisp} which does 
  not vary between @i{conforming implementations}.

@IGindex{implicit block}
@item @b{implicit block}
 @i{n.} 
 a @i{block} introduced by a @i{macro form} 
 rather than by an explicit @b{block} @i{form}.

@IGindex{implicit compilation}
@item @b{implicit compilation}
 @i{n.} 
 @i{compilation} performed during @i{evaluation}.

@IGindex{implicit progn}
@item @b{implicit progn}
 @i{n.} 
  an ordered set of adjacent @i{forms} appearing in another
  @i{form}, and defined by their context in that @i{form}
  to be executed as if within a @b{progn}.

@IGindex{implicit tagbody}
@item @b{implicit tagbody}
 @i{n.} 
  an ordered set of adjacent @i{forms} and/or @i{tags} 
  appearing in another @i{form}, and defined by their context 
  in that @i{form} to be executed as if within a @b{tagbody}.

@IGindex{import}
@item @b{import}
 @i{v.t.} (a @i{symbol} into a @i{package})
  to make the @i{symbol} be @i{present} in the @i{package}.

@IGindex{improper list}
@item @b{improper list}
 @i{n.} 
  a @i{list} which is not a @i{proper list}:  
  a @i{circular list} or a @i{dotted list}.

@IGindex{inaccessible}
@item @b{inaccessible}
 @i{adj.} 
  not @i{accessible}.

@IGindex{indefinite extent}
@item @b{indefinite extent}
 @i{n.} 
  an @i{extent} whose duration is unlimited.
  {``Most Common Lisp objects have indefinite extent.''}

@IGindex{indefinite scope}
@item @b{indefinite scope}
 @i{n.} 
  @i{scope} that is unlimited.

@IGindex{indicator}
@item @b{indicator}
 @i{n.} 
  a @i{property indicator}.

@IGindex{indirect instance}
@item @b{indirect instance}
 @i{n.} (of a @i{class} C_1)
  an @i{object} of @i{class} C_2, 
  where C_2 is a @i{subclass} of C_1.
  {``An integer is an indirect instance of the class @b{number}.''}

@IGindex{inherit}
@item @b{inherit}
 @i{v.t.} 
  1. to receive or acquire a quality, trait, or characteristic; 
     to gain access to a feature defined elsewhere.
  2. (a @i{class}) to acquire the structure and behavior defined
     by a @i{superclass}.
  3. (a @i{package}) to make @i{symbols} @i{exported} by another
     @i{package} @i{accessible} by using @b{use-package}.

@IGindex{initial pprint dispatch table}
@item @b{initial pprint dispatch table}
 @i{n.}
  the @i{value} of @b{*print-pprint-dispatch*} at the time the @i{Lisp image} is started.

@IGindex{initial readtable}
@item @b{initial readtable}
 @i{n.}
  the @i{value} of @b{*readtable*} at the time the @i{Lisp image} is started.

@IGindex{initialization argument list}
@item @b{initialization argument list}
 @i{n.} 
  a @i{property list} of initialization argument @i{names} and @i{values}
  used in the protocol for initializing and reinitializing @i{instances} of @i{classes}.
  See @ref{Object Creation and Initialization}.

@IGindex{initialization form}
@item @b{initialization form}
 @i{n.} 
  a @i{form} used to supply the initial @i{value} for a @i{slot}
  or @i{variable}.
  {``The initialization form for a slot in a @b{defclass} form
            is introduced by the keyword @t{:initform}.''}

@IGindex{input}
@item @b{input}
 @i{adj.} (of a @i{stream})
  supporting input operations (@i{i.e.}, being a ``data source'').
  An @i{input} @i{stream} might also be an @i{output} @i{stream},
  in which case it is sometimes called a @i{bidirectional} @i{stream}.
  See the @i{function} @b{input-stream-p}.

@IGindex{instance}
@item @b{instance}
 @i{n.} 
  1. a @i{direct instance}.
  2. a @i{generalized instance}.
  3. an @i{indirect instance}.

@IGindex{integer}
@item @b{integer}
 @i{n.} 
  an @i{object} of @i{type} @b{integer}, which represents a mathematical integer.

@IGindex{interactive stream}
@item @b{interactive stream}
 @i{n.} 
  a @i{stream} on which it makes sense to perform interactive querying.
  See @ref{Interactive Streams}.

@IGindex{intern}
@item @b{intern}
 @i{v.t.} 
  1. (a @i{string} in a @i{package})
     to look up the @i{string} in the @i{package}, 
     returning either a @i{symbol} with that @i{name}
     which was already @i{accessible} in the @i{package}
     or a newly created @i{internal symbol} of the @i{package} 
     with that @i{name}.
  2. @i{Idiom.} 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.

@IGindex{internal symbol}
@item @b{internal symbol}
 @i{n.} (of a @i{package})
  a symbol which is @i{accessible} in the @i{package},
  but which is not an @i{external symbol} of the @i{package}.

@IGindex{internal time}
@item @b{internal time}
 @i{n.}
  @i{time}, represented as an @i{integer} number of @i{internal time units}.
  @i{Absolute} @i{internal time} is measured as an offset 
  from an arbitrarily chosen, @i{implementation-dependent} base.
  See @ref{Internal Time}.

@IGindex{internal time unit}
@item @b{internal time unit}
 @i{n.} 
  a unit of time equal to 1/n of a second, 
  for some @i{implementation-defined} @i{integer} value of n.
  See the @i{variable} @b{internal-time-units-per-second}.

@IGindex{interned}
@item @b{interned}
 @i{adj.} @i{Trad.} 
  1. (of a @i{symbol}) @i{accessible}_3 in
     any @i{package}.
  2. (of a @i{symbol} in a specific @i{package}) 
     @i{present} in that @i{package}.

@IGindex{interpreted function}
@item @b{interpreted function}
 @i{n.} 
  a @i{function} that is not a @i{compiled function}.
  (It is possible for there to be a @i{conforming implementation} which
   has no @i{interpreted functions}, but a @i{conforming program}
   must not assume that all @i{functions} are @i{compiled functions}.)

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

@IGindex{interval designator}
@item @b{interval designator}
 @i{n.} (of @i{type} T)
  an ordered pair of @i{objects} that describe a @i{subtype} of T
  by delimiting an interval on the real number line.
  See @ref{Interval Designators}.

@IGindex{invalid}
@item @b{invalid}
 @i{n.}, @i{adj.}
  1. @i{n.}
     a possible @i{constituent trait} of a @i{character}
     which if present signifies that the @i{character} 
     cannot ever appear in a @i{token} 
     except under the control of a @i{single escape} @i{character}.
     For details, see @ref{Constituent Characters}.
  2. @i{adj.} (of a @i{character})
     being a @i{character} that has @i{syntax type} @i{constituent}
     in the @i{current readtable} and that has the 
     @i{constituent trait} @i{invalid}_1.
     See @i{Figure~2--8}.

@IGindex{iteration form}
@item @b{iteration form}
 @i{n.}
  a @i{compound form} whose @i{operator} is named in Figure 26--3,
  or a @i{compound form} that has an @i{implementation-defined} @i{operator}
     and that is defined by the @i{implementation} to be an @i{iteration form}.

@group
@noindent
@w{  do              do-external-symbols  dotimes  }
@w{  do*             do-symbols           loop     }
@w{  do-all-symbols  dolist                        }

@noindent
@w{    Figure 26--3: Standardized Iteration Forms  }

@end group

@IGindex{iteration variable}
@item @b{iteration variable}
 @i{n.}
  a @i{variable} V, the @i{binding} for which was created by an
  @i{explicit use} of V in an @i{iteration form}.

@end table
@subheading @b{K}
@table @asis

@IGindex{key}
@item @b{key}
 @i{n.} 
  an @i{object} used for selection during retrieval. 
  See @i{association list}, @i{property list}, and @i{hash table}.
  Also, see @ref{Sequence Concepts}.

@IGindex{keyword}
@item @b{keyword}
 @i{n.} 
  1. a @i{symbol} the @i{home package} of which is the @t{KEYWORD} @i{package}.
  2. any @i{symbol}, usually but not necessarily in the @t{KEYWORD} @i{package},
     that is used as an identifying marker in keyword-style argument passing.
     See @b{lambda}.
  3. @i{Idiom.} a @i{lambda list keyword}.

@IGindex{keyword parameter}
@item @b{keyword parameter}
 @i{n.}
  A @i{parameter} for which a corresponding keyword @i{argument}
  is optional.  (There is no such thing as a required keyword @i{argument}.)
  If the @i{argument} is not supplied, a default value is used.
  See also @i{supplied-p parameter}.

@IGindex{keyword/value pair}
@item @b{keyword/value pair}
 @i{n.} 
  two successive @i{elements} (a @i{keyword} and a @i{value}, 
  respectively) of a @i{property list}.

@end table
@subheading @b{L}
@table @asis

@IGindex{lambda combination}
@item @b{lambda combination}
 @i{n.} @i{Trad.} 
  a @i{lambda form}.

@IGindex{lambda expression}
@item @b{lambda expression}
 @i{n.} 
  a @i{list} which can be used in place of a @i{function name} in 
  certain contexts to denote a @i{function} by directly describing its
  behavior rather than indirectly by referring to the name of an
  @i{established} @i{function}; its name derives from the fact that its
  first element is the @i{symbol} @t{lambda}.
  See @b{lambda}.

@IGindex{lambda form}
@item @b{lambda form}
 @i{n.} 
  a @i{form} that is a @i{list} and that has a first element
  which is a @i{lambda expression} representing a @i{function}
  to be called on @i{arguments} which are the result of @i{evaluating}
  subsequent elements of the @i{lambda form}.

@IGindex{lambda list}
@item @b{lambda list}
 @i{n.} 
  a @i{list} that specifies a set of @i{parameters} 
  (sometimes called @i{lambda variables})
  and a protocol for receiving @i{values} for those @i{parameters};
  that is,
  an @i{ordinary lambda list},
  an @i{extended lambda list},
  or a @i{modified lambda list}.

@IGindex{lambda list keyword}
@item @b{lambda list keyword}
 @i{n.} 
  a @i{symbol} whose @i{name} begins with @i{ampersand}
  and that is specially recognized in a @i{lambda list}.
  Note that no @i{standardized} @i{lambda list keyword} 
  is in the @t{KEYWORD} @i{package}.

@IGindex{lambda variable}
@item @b{lambda variable}
 @i{n.} 
  a @i{formal parameter}, used to emphasize the @i{variable}'s
  relation to the @i{lambda list} that @i{established} it.

@IGindex{leaf}
@item @b{leaf}
 @i{n.} 
  1. an @i{atom} in a @i{tree}_1.
  2. a terminal node of a @i{tree}_2.

@IGindex{leap seconds}
@item @b{leap seconds}
 @i{n.}
  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 @r{Common Lisp} @i{time} representations ignore 
  @i{leap seconds}; every day is assumed to be exactly 86400 seconds 
  long.

@IGindex{left-parenthesis}
@item @b{left-parenthesis}
 @i{n.}
  the @i{standard character} ``@t{(}'',
  that is variously called
      ``left parenthesis''
   or ``open parenthesis''
  See @i{Figure~2--5}.

@IGindex{length}
@item @b{length}
 @i{n.} (of a @i{sequence})
  the number of @i{elements} in the @i{sequence}.
  (Note that if the @i{sequence} is a @i{vector} with a 
   @i{fill pointer}, its @i{length} is the same as the 
   @i{fill pointer} even though the total allocated size of
   the @i{vector} might be larger.)

@IGindex{lexical binding}
@item @b{lexical binding}
 @i{n.} 
  a @i{binding} in a @i{lexical environment}.

@IGindex{lexical closure}
@item @b{lexical closure}
 @i{n.} 
  a @i{function} that, when invoked on @i{arguments}, executes
  the body of a @i{lambda expression} in the @i{lexical environment} 
  that was captured at the time of the creation of the @i{lexical closure},
  augmented by @i{bindings} of the @i{function}'s @i{parameters}
  to the corresponding @i{arguments}.

@IGindex{lexical environment}
@item @b{lexical environment}
 @i{n.} 
  that part of the @i{environment} that contains @i{bindings}
  whose names have @i{lexical scope}. A @i{lexical environment} 
  contains, among other things:
     ordinary @i{bindings} of @i{variable} @i{names} to @i{values},
     lexically @i{established} @i{bindings} of @i{function names}
        to @i{functions},
     @i{macros},
     @i{symbol macros},
     @i{blocks},
     @i{tags},
  and
     @i{local declarations} (see @b{declare}).

@IGindex{lexical scope}
@item @b{lexical scope}
 @i{n.} 
  @i{scope} that is limited to a spatial or textual region within the
  establishing @i{form}.
  {``The names of parameters to a function normally are lexically scoped.''}

@IGindex{lexical variable}
@item @b{lexical variable}
 @i{n.} 
  a @i{variable} the @i{binding} for which is in the
  @i{lexical environment}.

@IGindex{Lisp image}
@item @b{Lisp image}
 @i{n.}
  a running instantiation of a @r{Common Lisp} @i{implementation}.
  A @i{Lisp image} is characterized by a single address space in which any
  @i{object} can directly refer to any another in conformance with this specification,
  and by a single, common, @i{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 @i{Lisp image}
    being defined here.  Depending on the operating system, a single ``process'' 
    might have multiple @i{Lisp images}, and multiple ``processes'' might reside
    in a single @i{Lisp image}.  Hence, it is the idea of a fully shared address
    space for direct reference among all @i{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 @i{objects} are considered
    to be distinct @i{Lisp images}.)

@IGindex{Lisp printer}
@item @b{Lisp printer}
 @i{n.} @i{Trad.} 
  the procedure that prints the character representation of an
  @i{object} onto a @i{stream}. (This procedure is implemented
  by the @i{function} @b{write}.)

@IGindex{Lisp read-eval-print loop}
@item @b{Lisp read-eval-print loop}
 @i{n.} @i{Trad.} 
  an endless loop that @i{reads}_2 a @i{form},
  @i{evaluates} it,
  and prints (@i{i.e.}, @i{writes}_2) the results.
  In many @i{implementations},
  the default mode of interaction with @r{Common Lisp} during program development
  is through such a loop.

@IGindex{Lisp reader}
@item @b{Lisp reader}
 @i{n.} @i{Trad.} 
  the procedure that parses character representations of @i{objects}
  from a @i{stream}, producing @i{objects}.
  (This procedure is implemented by the @i{function} @b{read}.)

@IGindex{list}
@item @b{list}
 @i{n.} 
  1. a chain of @i{conses} in which the @i{car} of each
     @i{cons} is an @i{element} of the @i{list}, 
     and the @i{cdr} of each @i{cons} is either the next
     link in the chain or a terminating @i{atom}.  
     See also @i{proper list},
	    @i{dotted list}, 
         or @i{circular list}.
  2. the @i{type} that is the union of @b{null} and @b{cons}.

@IGindex{list designator}
@item @b{list designator}
 @i{n.}
  a @i{designator} for a @i{list} of @i{objects}; that is,
  an @i{object} that denotes a @i{list} 
  and that is one of:
       a @i{non-nil} @i{atom} 
         (denoting a @i{singleton} @i{list} 
          whose @i{element} is that @i{non-nil} @i{atom})
       or a @i{proper list} (denoting itself).

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

@IGindex{literal}
@item @b{literal}
 @i{adj.} (of an @i{object})
  referenced directly in a program rather than being computed by the program;
  that is,
  appearing as data in a @b{quote} @i{form}, 
  or, if the @i{object} is a @i{self-evaluating object},
  appearing as unquoted data.
  {``In the form @t{(cons "one" '("two"))}, 
            the expressions @t{"one"}, @t{("two")}, and @t{"two"}
            are literal objects.''}

@IGindex{load}
@item @b{load}
 @i{v.t.} (a @i{file})
  to cause the @i{code} contained in the @i{file} to be @i{executed}.
  See the @i{function} @b{load}.

@IGindex{load time}
@item @b{load time}
 @i{n.}
  the duration of time that the loader is @i{loading} @i{compiled code}.

@IGindex{load time value}
@item @b{load time value}
 @i{n.} 
  an @i{object} referred to in @i{code} by a @b{load-time-value} 
  @i{form}.  The @i{value} of such a @i{form} is some specific
  @i{object} which can only be computed in the run-time @i{environment}.
  In the case of @i{file} @i{compilation}, the @i{value} is
  computed once as part of the process of @i{loading} the @i{compiled file},
  and not again.  See the @i{special operator} @b{load-time-value}.

@IGindex{loader}
@item @b{loader}
 @i{n.}
  a facility that is part of Lisp and that @i{loads} a @i{file}.
  See the @i{function} @b{load}.

@IGindex{local declaration}
@item @b{local declaration}
 @i{n.} 
  an @i{expression} which may appear only in specially designated
  positions of certain @i{forms}, and which provides information about
  the code contained within the containing @i{form}; 
  that is, a @b{declare} @i{expression}.

@IGindex{local precedence order}
@item @b{local precedence order}
 @i{n.} (of a @i{class})
  a @i{list} consisting of the @i{class} followed by its
  @i{direct superclasses} in the order mentioned in the defining
  @i{form} for the @i{class}.

@IGindex{local slot}
@item @b{local slot}
 @i{n.} (of a @i{class})
  a @i{slot} @i{accessible} in only one @i{instance}, 
  namely the @i{instance} in which the @i{slot} is allocated.

@IGindex{logical block}
@item @b{logical block}
 @i{n.}
  a conceptual grouping of related output used by the @i{pretty printer}.
  See the @i{macro} @b{pprint-logical-block} and @ref{Dynamic Control of the Arrangement of Output}.

@IGindex{logical host}
@item @b{logical host}
 @i{n.}
  an @i{object} of @i{implementation-dependent} nature 
  that is used as the representation of a ``host'' in a @i{logical pathname},
  and that has an associated set of translation rules for converting
  @i{logical pathnames} belonging to that host into @i{physical pathnames}.
  See @ref{Logical Pathnames}.

@IGindex{logical host designator}
@item @b{logical host designator}
 @i{n.}
  a @i{designator} for a @i{logical host}; that is,
  an @i{object} that denotes a @i{logical host} 
  and that is one of:
       a @i{string} (denoting the @i{logical host} that it names),
    or a @i{logical host} (denoting itself).
  (Note that because the representation of a @i{logical host} 
   is @i{implementation-dependent},
   it is possible that an @i{implementation} might represent 
   a @i{logical host} as the @i{string} that names it.)

@IGindex{logical pathname}
@item @b{logical pathname}
 @i{n.} 
  an @i{object} of @i{type} @b{logical-pathname}.

@IGindex{long float}
@item @b{long float}
 @i{n.} 
  an @i{object} of @i{type} @b{long-float}.

@IGindex{loop keyword}
@item @b{loop keyword}
 @i{n.} @i{Trad.}
  a symbol that is a specially recognized part of the syntax of 
  an extended @b{loop} @i{form}.  Such symbols are recognized by their
  @i{name} (using @b{string=}), not by their identity; as such, they
  may be in any package.  A @i{loop keyword} is not a @i{keyword}.

@IGindex{lowercase}
@item @b{lowercase}
 @i{adj.} (of a @i{character})
     being among @i{standard characters} corresponding to
     the small letters @t{a} through @t{z},
  or being some other @i{implementation-defined} @i{character}
      that is defined by the @i{implementation} to be @i{lowercase}.
  See @ref{Characters With Case}.

@end table
@subheading @b{M}
@table @asis

@IGindex{macro}
@item @b{macro}
 @i{n.} 
  1. a @i{macro form}
  2. a @i{macro function}.
  3. a @i{macro name}.

@IGindex{macro character}
@item @b{macro character}
 @i{n.} 
  a @i{character} which, when encountered by the @i{Lisp reader} 
  in its main dispatch loop, introduces a @i{reader macro}_1.
  (@i{Macro characters} have nothing to do with @i{macros}.)

@IGindex{macro expansion}
@item @b{macro expansion}
 @i{n.} 
  1. the process of translating a @i{macro form} into another
     @i{form}.
  2. the @i{form} resulting from this process.

@IGindex{macro form}
@item @b{macro form}
 @i{n.} 
  a @i{form} that stands for another @i{form} 
  (@i{e.g.}, for the purposes of abstraction, information hiding, 
       or syntactic convenience);
  that is, 
    either a @i{compound form} whose first element is a @i{macro name}, 
    or     a @i{form} that is a @i{symbol} that names a 
             @i{symbol macro}.

@IGindex{macro function}
@item @b{macro function}
 @i{n.} 
  a @i{function} of two arguments, a @i{form} and an 
  @i{environment}, that implements @i{macro expansion} by
  producing a @i{form} to be evaluated in place of the original
  argument @i{form}.

@IGindex{macro lambda list}
@item @b{macro lambda list}
 @i{n.}
  an @i{extended lambda list} used in @i{forms} that @i{establish}
  @i{macro} definitions, such as @b{defmacro} and @b{macrolet}.
  See @ref{Macro Lambda Lists}.

@IGindex{macro name}
@item @b{macro name}
 @i{n.} 
  a @i{name} for which @b{macro-function} returns @i{true}
  and which when used as the first element of a @i{compound form}
  identifies that @i{form} as a @i{macro form}.

@IGindex{macroexpand hook}
@item @b{macroexpand hook}
 @i{n.}
  the @i{function} that is the @i{value} of @b{*macroexpand-hook*}.

@IGindex{mapping}
@item @b{mapping}
 @i{n.} 
  1. a type of iteration in which a @i{function} is successively 
     applied to @i{objects} taken from corresponding entries in
     collections such as @i{sequences} or @i{hash tables}.
  2. @i{Math.} 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'').

@IGindex{metaclass}
@item @b{metaclass}
 @i{n.} 
  1. a @i{class} whose instances are @i{classes}.
  2. (of an @i{object}) the @i{class} of the @i{class} of the @i{object}.

@IGindex{Metaobject Protocol}
@item @b{Metaobject Protocol}
 @i{n.}
  one of many possible descriptions of how a @i{conforming implementation}
  might implement various aspects of the object system.  This description is beyond
  the scope of this document, and no @i{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 @i{implementation} adhere to it where possible.
  It is described in detail in @i{The Art of the Metaobject Protocol}.

@IGindex{method}
@item @b{method}
 @i{n.} 
  an @i{object} that is part of a @i{generic function} and which
  provides information about how that @i{generic function} should 
  behave when its @i{arguments} are @i{objects} of certain
  @i{classes} or with certain identities.

@IGindex{method combination}
@item @b{method combination}
 @i{n.} 
  1. generally, the composition of a set of @i{methods} to produce an
     @i{effective method} for a @i{generic function}.
  2. an object of @i{type} @b{method-combination}, which represents the details
     of how the @i{method combination}_1 for one or more 
     specific @i{generic functions} is to be performed.

@IGindex{method-defining form}
@item @b{method-defining form}
 @i{n.} 
  a @i{form} that defines a @i{method} for a @i{generic function},
  whether explicitly or implicitly.  
  See @ref{Introduction to Generic Functions}.

@IGindex{method-defining operator}
@item @b{method-defining operator}
 @i{n.}
  an @i{operator} corresponding to a @i{method-defining} @i{form}.
  See @i{Figure~7--1}.

@IGindex{minimal compilation}
@item @b{minimal compilation}
 @i{n.}
  actions the @i{compiler} must take at compile time. 
  See @ref{Compilation Semantics}.

@IGindex{modified lambda list}
@item @b{modified lambda list}
 @i{n.} 
  a list resembling an @i{ordinary lambda list} in form and purpose, 
  but which deviates in syntax or functionality from the definition of an 
  @i{ordinary lambda list}.
  See @i{ordinary lambda list}.
  {``@b{deftype} uses a modified lambda list.''}

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

@IGindex{multiple escape}
@item @b{multiple escape}
 @i{n.}, @i{adj.}
  1. @i{n.} the @i{syntax type} of a @i{character} 
     that is used in pairs  to indicate that the enclosed @i{characters}
     are to be treated as @i{alphabetic}_2 @i{characters}
     with their @i{case} preserved.
     For details, see @ref{Multiple Escape Characters}.
  2. @i{adj.} (of a @i{character}) 
     having the @i{multiple escape} @i{syntax type}.
  3. @i{n.} a @i{multiple escape}_2 @i{character}.
     (In the @i{standard readtable},
      @i{vertical-bar} is a @i{multiple escape} @i{character}.)

@IGindex{multiple values}
@item @b{multiple values}
 @i{n.} 
  1. more than one @i{value}.
     {``The function @b{truncate} returns multiple values.''}
  2. a variable number of @i{values}, possibly including zero or one.
     {``The function @b{values} returns multiple values.''}
  3. a fixed number of values other than one.
     {``The macro @b{multiple-value-bind} is among the few
	       operators in @r{Common Lisp} which can detect and manipulate
 	       multiple values.''}

@end table
@subheading @b{N}
@table @asis

@IGindex{name}
@item @b{name}
 @i{n.}, @i{v.t.} 
  1. @i{n.} an @i{identifier} by which an @i{object},
     a @i{binding}, or an @i{exit point}
     is referred to by association using a @i{binding}.
  2. @i{v.t.} to give a @i{name} to.
  3. @i{n.} (of an @i{object} having a name component) 
     the @i{object} which is that component.  
     {``The string which is a symbol's name is returned
	       by @b{symbol-name}.''}
  4. @i{n.} (of a @i{pathname})
     a. the name component, returned by @b{pathname-name}.
     b. the entire namestring, returned by @b{namestring}.
  5. @i{n.} (of a @i{character})
     a @i{string} that names the @i{character}
     and that has @i{length} greater than one.
     (All @i{non-graphic} @i{characters} are required to have @i{names}
      unless they have some @i{implementation-defined} @i{attribute}
      which is not @i{null}.  Whether or not other @i{characters}
      have @i{names} is @i{implementation-dependent}.)

@IGindex{named constant}
@item @b{named constant}
 @i{n.} 
  a @i{variable} that is defined by @r{Common Lisp},
				    by the @i{implementation},
  				 or by user code (see the @i{macro} @b{defconstant})
  to always @i{yield} the same @i{value} when @i{evaluated}.
  {``The value of a named constant may not be changed
            by assignment or by binding.''}

@IGindex{namespace}
@item @b{namespace}
 @i{n.} 
  1. @i{bindings} whose denotations are restricted to a particular kind.
     {``The bindings of names to tags is the tag namespace.''}
  2. any @i{mapping} whose domain is a set of @i{names}.
     {``A package defines a namespace.''}

@IGindex{namestring}
@item @b{namestring}
 @i{n.} 
  a @i{string} that represents a @i{filename}
  using either the @i{standardized} notation for naming @i{logical pathnames}
         described in @ref{Syntax of Logical Pathname Namestrings},
     or some @i{implementation-defined} notation for naming a @i{physical pathname}.

@IGindex{newline}
@item @b{newline}
 @i{n.}
  the @i{standard character} <@i{Newline}>,
  notated for the @i{Lisp reader} as @t{#\Newline}.

@IGindex{next method}
@item @b{next method}
 @i{n.} 
  the next @i{method} to be invoked with respect to a given
  @i{method} for a particular set of arguments or argument
  @i{classes}.  
  See @ref{Applying method combination to the sorted list of applicable methods}.

@IGindex{nickname}
@item @b{nickname}
 @i{n.} (of a @i{package})
  one of possibly several @i{names} that can be used to refer to
  the @i{package} but that is not the primary @i{name} 
  of the @i{package}.

@IGindex{nil}
@item @b{nil}
 @i{n.} 
  the @i{object} that is at once
        the @i{symbol} named @t{"NIL"} in the @t{COMMON-LISP} @i{package},
        the @i{empty list},
        the @i{boolean} (or @i{generalized boolean}) representing @i{false},
    and the @i{name} of the @i{empty type}.

@IGindex{non-atomic}
@item @b{non-atomic}
 @i{adj.} 
  being other than an @i{atom}; @i{i.e.}, being a @i{cons}.

@IGindex{non-constant variable}
@item @b{non-constant variable}
 @i{n.}
  a @i{variable} that is not a @i{constant variable}.

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

@IGindex{non-empty}
@item @b{non-empty}
 @i{adj.}
  having at least one @i{element}.

@IGindex{non-generic function}
@item @b{non-generic function}
 @i{n.} 
  a @i{function} that is not a @i{generic function}.

@IGindex{non-graphic}
@item @b{non-graphic}
 @i{adj.} (of a @i{character})
  not @i{graphic}.
  See @ref{Graphic Characters}.

@IGindex{non-list}
@item @b{non-list}
 @i{n.}, @i{adj.} 
  other than a @i{list}; @i{i.e.}, a @i{non-nil} @i{atom}.

@IGindex{non-local exit}
@item @b{non-local exit}
 @i{n.} 
  a transfer of control (and sometimes @i{values}) to 
  an @i{exit point} for reasons other than a @i{normal return}.
  {``The operators @b{go}, @b{throw}, 
	    and @b{return-from} cause a non-local exit.''}

@IGindex{non-nil}
@item @b{non-nil}
 @i{n.}, @i{adj.} 
  not @b{nil}.  Technically, any @i{object} which is not @b{nil} can be
  referred to as @i{true}, but that would tend to imply a unique view
  of the @i{object} as a @i{generalized boolean}.
  Referring to such an @i{object} as @i{non-nil} avoids this implication.

@IGindex{non-null lexical environment}
@item @b{non-null lexical environment}
 @i{n.} 
  a @i{lexical environment} that has additional information not present in
  the @i{global environment}, such as one or more @i{bindings}.

@IGindex{non-simple}
@item @b{non-simple}
 @i{adj.}
  not @i{simple}.

@IGindex{non-terminating}
@item @b{non-terminating}
 @i{adj.} (of a @i{macro character})
  being such that it is treated as a constituent @i{character}
  when it appears in the middle of an extended token.
  See @ref{Reader Algorithm}.

@IGindex{non-top-level form}
@item @b{non-top-level form}
 @i{n.} 
  a @i{form} that, by virtue of its position as a @i{subform}
  of another @i{form}, is not a @i{top level form}.
  See @ref{Processing of Top Level Forms}.

@IGindex{normal return}
@item @b{normal return}
 @i{n.} 
  the natural transfer of control and @i{values} which occurs after
  the complete @i{execution} of a @i{form}.

@IGindex{normalized}
@item @b{normalized}
 @i{adj.}, @i{ANSI}, @i{IEEE} (of a @i{float})
  conforming to the description of ``normalized'' as described by {IEEE Standard for Binary Floating-Point Arithmetic}.
  See @i{denormalized}.

@IGindex{null}
@item @b{null}
 @i{adj.}, @i{n.} 
  1. @i{adj.} 
     a. (of a @i{list}) having no @i{elements}: empty.  See @i{empty list}.
     b. (of a @i{string}) having a @i{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 @i{null} @i{string}'' even though no attempt is made to
	 @i{intern}_2 null strings.  The phrase 
         ``a @i{null} @i{string}'' is technically more correct, 
	 but is generally considered awkward by most Lisp programmers.  
	 As such, the phrase ``the @i{null} @i{string}'' 
         should be treated as an indefinite reference in all cases 
	 except for anaphoric references.)
      c. (of an @i{implementation-defined} @i{attribute} of a @i{character})
	 An @i{object} to which the value of that @i{attribute} defaults 
	 if no specific value was requested.
  2. @i{n.} an @i{object} of @i{type} @b{null} (the only such @i{object} being @b{nil}).

@IGindex{null lexical environment}
@item @b{null lexical environment}
 @i{n.} 
  the @i{lexical environment} which has no @i{bindings}.

@IGindex{number}
@item @b{number}
 @i{n.}
  an @i{object} of @i{type} @b{number}.

@IGindex{numeric}
@item @b{numeric}
 @i{adj.} (of a @i{character})
     being one of the @i{standard characters} @t{0} through @i{9},
  or being some other @i{graphic} @i{character}
     defined by the @i{implementation} to be @i{numeric}.

@end table
@subheading @b{O}
@table @asis

@IGindex{object}
@item @b{object}
 @i{n.} 
  1. any Lisp datum. 
     {``The function @b{cons} creates an object which refers
               to two other objects.''}
  2. (immediately following the name of a @i{type})
     an @i{object} which is of that @i{type}, used to emphasize that the
     @i{object} is not just a @i{name} for an object of that @i{type}
     but really an @i{element} of the @i{type} in cases where @i{objects}
     of that @i{type} (such as @b{function} or @b{class}) are commonly
     referred to by @i{name}.
     {``The function @b{symbol-function} takes a function name 
	       and returns a function object.''}

@IGindex{object-traversing}
@item @b{object-traversing}
 @i{adj.} 
  operating in succession on components of an @i{object}.
  {``The operators @b{mapcar}, @b{maphash}, 
	    @b{with-package-iterator} and @b{count}
 	    perform object-traversing operations.''}

@IGindex{open}
@item @b{open}
 @i{adj.}, @i{v.t.} (a @i{file})
  1. @i{v.t.} to create and return a @i{stream} to the @i{file}.
  2. @i{adj.} (of a @i{stream})
     having been @i{opened}_1, but not yet @i{closed}.

@IGindex{operator}
@item @b{operator}
 @i{n.} 
  1. a @i{function}, @i{macro}, or @i{special operator}.
  2. a @i{symbol} that names
     such a @i{function}, @i{macro}, or @i{special operator}.
  3. (in a @b{function} @i{special form})
     the @i{cadr} of the @b{function} @i{special form}, which 
     might be either an @i{operator}_2 or a @i{lambda expression}.
  4. (of a @i{compound form})
     the @i{car} of the @i{compound form}, which might be 
     either an @i{operator}_2
     or a @i{lambda expression}, and which is never @t{(setf @i{symbol})}.

@IGindex{optimize quality}
@item @b{optimize quality}
 @i{n.} 
  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 @b{optimize} @i{declaration}.
  The @i{standardized} @i{optimize qualities} are
    @t{compilation-speed} (speed of the compilation process), 

    @t{debug} (ease of debugging),

    @t{safety} (run-time error checking),
    @t{space} (both code size and run-time space),
  and
    @t{speed} (of the object code).
  @i{Implementations} may define additional @i{optimize qualities}.

@IGindex{optional parameter}
@item @b{optional parameter}
 @i{n.}
  A @i{parameter} for which a corresponding positional @i{argument}
  is optional.  If the @i{argument} is not supplied, a default value
  is used.  See also @i{supplied-p parameter}.

@IGindex{ordinary function}
@item @b{ordinary function}
 @i{n.} 
  a @i{function} that is not a @i{generic function}.

@IGindex{ordinary lambda list}
@item @b{ordinary lambda list}
 @i{n.} 
  the kind of @i{lambda list} used by @b{lambda}.
  See @i{modified lambda list} and @i{extended lambda list}.
  {``@b{defun} uses an ordinary lambda list.''}

@IGindex{otherwise inaccessible part}
@item @b{otherwise inaccessible part}
 @i{n.} (of an @i{object}, O_1)
  an @i{object}, O_2, which would be made @i{inaccessible} if 
  O_1 were made @i{inaccessible}.  (Every @i{object} is an
  @i{otherwise inaccessible part} of itself.)

@IGindex{output}
@item @b{output}
 @i{adj.} (of a @i{stream})
  supporting output operations (@i{i.e.}, being a ``data sink'').
  An @i{output} @i{stream} might also be an @i{input} @i{stream},
  in which case it is sometimes called a @i{bidirectional} @i{stream}.
  See the @i{function} @b{output-stream-p}.

@end table
@subheading @b{P}
@table @asis

@IGindex{package}
@item @b{package}
 @i{n.} 
  an @i{object} of @i{type} @b{package}.

@IGindex{package cell}
@item @b{package cell}
 @i{n.} @i{Trad.} (of a @i{symbol})
  The @i{place} in a @i{symbol} that holds one of
  possibly several @i{packages} in which the @i{symbol} is 
  @i{interned}, called the @i{home package}, or which holds
  @b{nil} if no such @i{package} exists or is known.
  See the @i{function} @b{symbol-package}.

@IGindex{package designator}
@item @b{package designator}
 @i{n.}
  a @i{designator} for a @i{package}; that is,
  an @i{object} that denotes a @i{package}
  and that is one of:
      a @i{string designator} 
		      (denoting the @i{package} that has the @i{string}
		       that it designates as its @i{name} 
		       or as one of its @i{nicknames}),
   or a @i{package} (denoting itself).

@IGindex{package marker}
@item @b{package marker}
 @i{n.} 
  a character which is used in the textual notation for a symbol 
  to separate the package name from the symbol name, and which
  is @i{colon} in the @i{standard readtable}.
  See @ref{Character Syntax}.

@IGindex{package prefix}
@item @b{package prefix}
 @i{n.} 
  a notation preceding the @i{name} of a @i{symbol} in text that is
  processed by the @i{Lisp reader}, which uses a @i{package} @i{name}
  followed by one or more @i{package markers}, and which indicates that
  the symbol is looked up in the indicated @i{package}.

@IGindex{package registry}
@item @b{package registry}
 @i{n.}
  A mapping of @i{names} to @i{package} @i{objects}.
  It is possible for there to be a @i{package} @i{object} which is not
  in this mapping; such a @i{package} is called an @i{unregistered package}.
  @i{Operators} such as @b{find-package} consult this mapping in order
  to find a @i{package} from its @i{name}.
  @i{Operators} such as @b{do-all-symbols}, @b{find-all-symbols}, 
  and @b{list-all-packages} operate only on @i{packages} that exist
  in the @i{package registry}.

@IGindex{pairwise}
@item @b{pairwise}
 @i{adv.} (of an adjective on a set)
  applying individually to all possible pairings of elements of the set.
  {``The types A, B, and C are pairwise disjoint if 
            A and B are disjoint,
            B and C are disjoint, and
            A and C are disjoint.''}

@IGindex{parallel}
@item @b{parallel}
 @i{adj.} @i{Trad.} (of @i{binding} or @i{assignment})
  done in the style of @b{psetq}, @b{let}, or @b{do};
  that is, first evaluating all of the @i{forms} that produce @i{values},
  and only then @i{assigning} or @i{binding} the @i{variables} (or @i{places}).
  Note that this does not imply traditional computational ``parallelism'' 
  since the @i{forms} that produce @i{values} are evaluated @i{sequentially}.
  See @i{sequential}.

@IGindex{parameter}
@item @b{parameter}
 @i{n.} 
  1. (of a @i{function})
     a @i{variable} in the definition of a @i{function}
       which takes on the @i{value} of a corresponding @i{argument}
       (or of a @i{list} of corresponding arguments)
       to that @i{function} when it is called,
     or
       which in some cases is given a default value because there
       is no corresponding @i{argument}.
  2. (of a @i{format directive})
     an @i{object} received as data flow by a @i{format directive}
     due to a prefix notation within the @i{format string} at the 
     @i{format directive}'s point of use.
     See @ref{Formatted Output}.
     {``In @t{"~3,'0D"}, the number @t{3} and the character
	       @t{#\0} are parameters to the @t{~D} format directive.''}

@IGindex{parameter specializer}
@item @b{parameter specializer}
 @i{n.} 
  1. (of a @i{method}) an @i{expression} which constrains the
     @i{method} to be applicable only to @i{argument} sequences
     in which the corresponding @i{argument} matches the
     @i{parameter specializer}.
  2. a @i{class},
     or a @i{list} @t{(eql @i{object})}.

@IGindex{parameter specializer name}
@item @b{parameter specializer name}
 @i{n.} 
  1. (of a @i{method} definition) an expression used in code to
     name a @i{parameter specializer}. 
     See @ref{Introduction to Methods}.
  2. a @i{class},

     a @i{symbol} naming a @i{class},

     or a @i{list} @t{(eql @i{form})}.

@IGindex{pathname}
@item @b{pathname}
 @i{n.} 
  an @i{object} of @i{type} @b{pathname}, which is a structured representation 
  of the name of a @i{file}.  A @i{pathname} has six components:
    a ``host,''
    a ``device,''
    a ``directory,''
    a ``name,''
    a ``type,'' and
    a ``version.''

@IGindex{pathname designator}
@item @b{pathname designator}
 @i{n.}
  a @i{designator} for a @i{pathname}; that is,
  an @i{object} that denotes a @i{pathname}
  and that is one of:

       a @i{pathname} @i{namestring} 

           (denoting the corresponding @i{pathname}),

       a @i{stream associated with a file} 
         (denoting the @i{pathname} used to open the @i{file};
	  this may be, but is not required to be, the actual name of the @i{file}),
    or a @i{pathname} (denoting itself).
  See @ref{File Operations on Open and Closed Streams}.

@IGindex{physical pathname}
@item @b{physical pathname}
 @i{n.}
  a @i{pathname} that is not a @i{logical pathname}.

[Editorial Note by 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.]

@IGindex{place}
@item @b{place}
 @i{n.} 
  1. a @i{form} which is suitable for use as a @i{generalized reference}.
  2. the conceptual location referred to by such a @i{place}_1.

@IGindex{plist}
@item @b{plist}
 pronounced 'p\=e ,list  @i{n.} 
  a @i{property list}.

@IGindex{portable}
@item @b{portable}
 @i{adj.} (of @i{code})
  required to produce equivalent results and observable side effects
  in all @i{conforming implementations}.

@IGindex{potential copy}
@item @b{potential copy}
 @i{n.} (of an @i{object} O_1 subject to constriants)
  an @i{object} O_2 that if the specified constraints are satisfied
  by O_1 without any modification might or might not be @i{identical}
  to O_1, or else that must be a @i{fresh} @i{object} that
  resembles a @i{copy} of O_1 except that it has been modified as
  necessary to satisfy the constraints.

@IGindex{potential number}
@item @b{potential number}
 @i{n.} 
  A textual notation that might be parsed by the @i{Lisp reader} 
  in some @i{conforming implementation} as a @i{number} 
  but is not required to be parsed as a @i{number}.
  No @i{object} is a @i{potential number}---either an @i{object} is
  a @i{number} or it is not.
  See @ref{Potential Numbers as Tokens}.

@IGindex{pprint dispatch table}
@item @b{pprint dispatch table}
 @i{n.} 
  an @i{object} that can be the @i{value} of @b{*print-pprint-dispatch*} 
  and hence can control how @i{objects} are printed when
  @b{*print-pretty*} is @i{true}.
  See @ref{Pretty Print Dispatch Tables}.

@IGindex{predicate}
@item @b{predicate}
 @i{n.} 
  a @i{function} that returns a @i{generalized boolean}
  as its first value.

@IGindex{present}
@item @b{present}
 @i{n.}
  1. (of a @i{feature} in a @i{Lisp image})
     a state of being that is in effect if and only if the @i{symbol} 
     naming the @i{feature} is an @i{element} of the @i{features list}.
  2. (of a @i{symbol} in a @i{package})
     being accessible in that @i{package} directly,
     rather than being inherited from another @i{package}.

@IGindex{pretty print}
@item @b{pretty print}
 @i{v.t.} (an @i{object})
  to invoke the @i{pretty printer} on the @i{object}.

@IGindex{pretty printer}
@item @b{pretty printer}
 @i{n.} 
  the procedure that prints the character representation of an
  @i{object} onto a @i{stream} when the @i{value} of
  @b{*print-pretty*} is @i{true}, 
  and that uses layout techniques (@i{e.g.}, indentation) that
  tend to highlight the structure of the @i{object} in a way that
  makes it easier for human readers to parse visually.
  See the @i{variable} @b{*print-pprint-dispatch*} and @ref{The Lisp Pretty Printer}.

@IGindex{pretty printing stream}
@item @b{pretty printing stream}
 @i{n.} 
  a @i{stream} that does pretty printing.  Such streams are created by
  the @i{function} @b{pprint-logical-block} as a link between the output stream 
  and the logical block.

@IGindex{primary method}
@item @b{primary method}
 @i{n.} 
  a member of one of two sets of @i{methods} 
  (the set of @i{auxiliary methods} is the other)
  that form an exhaustive partition of the set of @i{methods}
  on the @i{method}'s @i{generic function}.
  How these sets are determined is dependent on the @i{method combination} type;
  see @ref{Introduction to Methods}.

@IGindex{primary value}
@item @b{primary value}
 @i{n.} (of @i{values} resulting from the
				   @i{evaluation} of a @i{form})
  the first @i{value}, if any, or else @b{nil} if there are no @i{values}.
  {``The primary value returned by @b{truncate} is an
            integer quotient, truncated toward zero.''}

@IGindex{principal}
@item @b{principal}
 @i{adj.} (of a value returned by a @r{Common Lisp} @i{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 @i{value} which the corresponding
  @r{Common Lisp} @i{function} has been defined to return.

@IGindex{print name}
@item @b{print name}
 @i{n.} @i{Trad.} (usually of a @i{symbol})
  a @i{name}_3.

@IGindex{printer control variable}
@item @b{printer control variable}
 @i{n.} 
  a @i{variable} whose specific purpose is to control some action
  of the @i{Lisp printer}; that is, one of the @i{variables}
  in @i{Figure~22--1},
  or else some @i{implementation-defined} @i{variable} which is
     defined by the @i{implementation} to be a @i{printer control variable}.

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

@IGindex{printing}
@item @b{printing}
 @i{adj.} (of a @i{character})
  being a @i{graphic} @i{character} other than @i{space}.

@IGindex{process}
@item @b{process}
 @i{v.t.} (a @i{form} by the @i{compiler})
  to perform @i{minimal compilation}, determining the time of 
  evaluation for a @i{form}, and possibly @i{evaluating} that
  @i{form} (if required).

@IGindex{processor}
@item @b{processor}
 @i{n.}, @i{ANSI}
  an @i{implementation}.

@IGindex{proclaim}
@item @b{proclaim}
 @i{v.t.} (a @i{proclamation})
  to @i{establish} that @i{proclamation}.

@IGindex{proclamation}
@item @b{proclamation}
 @i{n.} 
  a @i{global declaration}.

@IGindex{prog tag}
@item @b{prog tag}
 @i{n.} @i{Trad.} 
  a @i{go tag}.

@IGindex{program}
@item @b{program}
 @i{n.} @i{Trad.} 
  @r{Common Lisp} @i{code}.

@IGindex{programmer}
@item @b{programmer}
 @i{n.}
  an active entity, typically a human, that writes a @i{program},
  and that might or might not also be a @i{user} of the @i{program}.

@IGindex{programmer code}
@item @b{programmer code}
 @i{n.} 
  @i{code} that is supplied by the programmer;
  that is, @i{code} that is not @i{system code}.

@IGindex{proper list}
@item @b{proper list}
 @i{n.} 
  A @i{list} terminated by the @i{empty list}.
  (The @i{empty list} is a @i{proper list}.)
  See @i{improper list}.

@IGindex{proper name}
@item @b{proper name}
 @i{n.} (of a @i{class})
  a @i{symbol} that @i{names} the @i{class} whose @i{name}
  is that @i{symbol}. 
  See the @i{functions} @b{class-name} and @b{find-class}.

@IGindex{proper sequence}
@item @b{proper sequence}
 @i{n.} 
  a @i{sequence} which is not an @i{improper list}; 
  that is, a @i{vector} or a @i{proper list}.

@IGindex{proper subtype}
@item @b{proper subtype}
 @i{n.} (of a @i{type})
  a @i{subtype} of the @i{type} which is not the @i{same} @i{type}
  as the @i{type} (@i{i.e.}, its @i{elements} are a ``proper subset'' of the 
  @i{type}).

@IGindex{property}
@item @b{property}
 @i{n.} (of a @i{property list})
  1. a conceptual pairing of a @i{property indicator} and its
     associated @i{property value} on a @i{property list}.
  2. a @i{property value}.

@IGindex{property indicator}
@item @b{property indicator}
 @i{n.} (of a @i{property list}) 
  the @i{name} part of a @i{property}, used as a @i{key}
  when looking up a @i{property value} on a @i{property list}. 

@IGindex{property list}
@item @b{property list}
 @i{n.} 

  1.  a @i{list} containing an even number of @i{elements} that are
      alternating @i{names}  (sometimes called @i{indicators} 
      or @i{keys}) and @i{values} (sometimes called @i{properties}).
      When there is more than one @i{name} and @i{value} pair with
      the @i{identical} @i{name} in a @i{property list},
      the first such pair determines the @i{property}.

  2. (of a @i{symbol})
     the component of the @i{symbol} containing a @i{property list}.

@IGindex{property value}
@item @b{property value}
 @i{n.} (of a @i{property indicator} on 
				  a @i{property list})
  the @i{object} associated with the @i{property indicator}
  on the @i{property list}.

@IGindex{purports to conform}
@item @b{purports to conform}
 @i{v.}
  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 @i{implementation} of this specification with bugs
  might not be a @i{conforming implementation}, it can still
  @i{purport to conform}.  This is an important distinction in
  certain specific cases; @i{e.g.}, see the @i{variable} @b{*features*}.

@end table
@subheading @b{Q}
@table @asis

@IGindex{qualified method}
@item @b{qualified method}
 @i{n.} 
  a @i{method} that has one or more @i{qualifiers}.

@IGindex{qualifier}
@item @b{qualifier}
 @i{n.} (of a @i{method} for a @i{generic function})
  one of possibly several @i{objects} used to annotate the @i{method} 
  in a way that identifies its role in the @i{method combination}.  
  The @i{method combination} @i{type} determines 
   how many @i{qualifiers} are permitted for each @i{method}, 
   which @i{qualifiers} are permitted,
  and
   the semantics of those @i{qualifiers}.

@IGindex{query I/O}
@item @b{query I/O}
 @i{n.} 
  the @i{bidirectional} @i{stream}
  that is the @i{value} of the @i{variable} @b{*query-io*}.

@IGindex{quoted object}
@item @b{quoted object}
 @i{n.} 
  an @i{object} which is the second element of a
  @b{quote} @i{form}.

@end table
@subheading @b{R}
@table @asis

@IGindex{radix}
@item @b{radix}
 @i{n.}
  an @i{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 n valid digit characters for any given @i{radix} n,
   and those digits are the first n digits in the sequence
   @t{0}, @t{1}, ..., @t{9}, @t{A}, @t{B}, ..., @t{Z},
   which have the weights   
   @t{0}, @t{1}, ..., @t{9}, @t{10}, @t{11}, ..., @t{35},
   respectively.
   Case is not significant in parsing numbers of radix greater
   than @t{10}, so ``9b8a'' and ``9B8A'' denote the same @i{radix}
   @t{16} number.)

@IGindex{random state}
@item @b{random state}
 @i{n.} 
  an @i{object} of @i{type} @b{random-state}.

@IGindex{rank}
@item @b{rank}
 @i{n.} 
  a non-negative @i{integer} indicating the number of
  @i{dimensions} of an @i{array}.

@IGindex{ratio}
@item @b{ratio}
 @i{n.} 
  an @i{object} of @i{type} @b{ratio}.

@IGindex{ratio marker}
@item @b{ratio marker}
 @i{n.} 
  a character which is used in the textual notation for a @i{ratio}
  to separate the numerator from the denominator, and which
  is @i{slash} in the @i{standard readtable}.
  See @ref{Character Syntax}.

@IGindex{rational}
@item @b{rational}
 @i{n.} 
  an @i{object} of @i{type} @b{rational}.

@IGindex{read}
@item @b{read}
 @i{v.t.} 

  1. (a @i{binding} or @i{slot} or component)
     to obtain the @i{value} of the @i{binding} or @i{slot}.

  2. (an @i{object} from a @i{stream})
     to parse an @i{object} from its representation on the @i{stream}.

@IGindex{readably}
@item @b{readably}
 @i{adv.} (of a manner of printing an @i{object} O_1)
  in such a way as to permit the @i{Lisp Reader} to later @i{parse}
  the printed output into an @i{object} O_2 that is @i{similar} to O_1.

@IGindex{reader}
@item @b{reader}
 @i{n.}
  1. a @i{function} that @i{reads}_1 a @i{variable} or @i{slot}.
  2. the @i{Lisp reader}.

@IGindex{reader macro}
@item @b{reader macro}
 @i{n.}
  1. a textual notation introduced by dispatch on one or two @i{characters} 
     that defines special-purpose syntax for use by the @i{Lisp reader},
     and that is implemented by a @i{reader macro function}.
     See @ref{Reader Algorithm}.
  2. the @i{character} or @i{characters} that introduce
     a @i{reader macro}_1; that is,
        a @i{macro character}
     or the conceptual pairing of a @i{dispatching macro character} and the
          @i{character} that follows it.
  (A @i{reader macro} is not a kind of @i{macro}.)

@IGindex{reader macro function}
@item @b{reader macro function}
 @i{n.}
  a @i{function} @i{designator} that denotes a @i{function}
  that implements a @i{reader macro}_2.
  See the @i{functions} @b{set-macro-character} and @b{set-dispatch-macro-character}.

@IGindex{readtable}
@item @b{readtable}
 @i{n.}
  an @i{object} of @i{type} @b{readtable}.

@IGindex{readtable case}
@item @b{readtable case}
 @i{n.}
  an attribute of a @i{readtable}
  whose value is a @i{case sensitivity mode},
  and that selects the manner in which @i{characters}
       in a @i{symbol}'s @i{name} are to be treated by
            the @i{Lisp reader}
        and the @i{Lisp printer}.
  See @ref{Effect of Readtable Case on the Lisp Reader} and @ref{Effect of Readtable Case on the Lisp Printer}.

@IGindex{readtable designator}
@item @b{readtable designator}
 @i{n.}
  a @i{designator} for a @i{readtable}; that is,
  an @i{object} that denotes a @i{readtable}
  and that is one of:
       @b{nil} (denoting the @i{standard readtable}),
    or a @i{readtable} (denoting itself).

@IGindex{recognizable subtype}
@item @b{recognizable subtype}
 @i{n.} (of a @i{type})
  a @i{subtype} of the @i{type} which can be reliably detected 
  to be such by the @i{implementation}.
  See the @i{function} @b{subtypep}.

@IGindex{reference}
@item @b{reference}
 @i{n.}, @i{v.t.} 
  1. @i{n.} an act or occurrence of referring to an @i{object},
     a @i{binding}, an @i{exit point}, a @i{tag}, 
     or an @i{environment}.
  2. @i{v.t.} to refer to an @i{object}, a @i{binding}, an
     @i{exit point}, a @i{tag}, or an @i{environment},
     usually by @i{name}.

@IGindex{registered package}
@item @b{registered package}
 @i{n.}
  a @i{package} @i{object} that is installed in the @i{package registry}.
  (Every @i{registered package} has a @i{name} that is a @i{string},
   as well as zero or more @i{string} nicknames.
   All @i{packages} that are initially specified by @r{Common Lisp} 
   or created by @b{make-package} or @b{defpackage}
   are @i{registered packages}.  @i{Registered packages} can be turned into
   @i{unregistered packages} by @b{delete-package}.)

@IGindex{relative}
@item @b{relative}
 @i{adj.}
  1. (of a @i{time})
     representing an offset from an @i{absolute} @i{time}
     in the units appropriate to that time.
     For example, 
     a @i{relative} @i{internal time} is the difference between
     two @i{absolute} @i{internal times}, and is measured in
     @i{internal time units}.
  2. (of a @i{pathname})
     representing a position in a directory hierarchy by motion 
     from a position other than the root, which might therefore vary.
     {``The notation @t{#P"../foo.text"} denotes a relative
	       pathname if the host file system is Unix.''}
  See @i{absolute}.

@IGindex{repertoire}
@item @b{repertoire}
 @i{n.}, @i{ISO}
  a @i{subtype} of @b{character}.  See @ref{Character Repertoires}.

@IGindex{report}
@item @b{report}
 @i{n.} (of a @i{condition})
  to @i{call} the @i{function} @b{print-object} on the @i{condition} 
  in an @i{environment} where the @i{value} of @b{*print-escape*} is @i{false}.

@IGindex{report message}
@item @b{report message}
 @i{n.}
  the text that is output by a @i{condition reporter}.

@IGindex{required parameter}
@item @b{required parameter}
 @i{n.}
  A @i{parameter} for which a corresponding positional @i{argument}
  must be supplied when @i{calling} the @i{function}.

@IGindex{rest list}
@item @b{rest list}
 @i{n.} (of a @i{function} having a @i{rest parameter})
  The @i{list} to which the @i{rest parameter} is @i{bound} on some
  particular @i{call} to the @i{function}.

@IGindex{rest parameter}
@item @b{rest parameter}
 @i{n.}
  A @i{parameter} which was introduced by @b{&rest}.

@IGindex{restart}
@item @b{restart}
 @i{n.} 
  an @i{object} of @i{type} @b{restart}.

@IGindex{restart designator}
@item @b{restart designator}
 @i{n.}
  a @i{designator} for a @i{restart}; that is,
  an @i{object} that denotes a @i{restart}
  and that is one of:
       a @i{non-nil} @i{symbol} 
	 (denoting the most recently established @i{active}
	  @i{restart} whose @i{name} is that @i{symbol}),
    or a @i{restart} (denoting itself).

@IGindex{restart function}
@item @b{restart function}
 @i{n.}
  a @i{function} that invokes a @i{restart}, as if by @b{invoke-restart}.
  The primary purpose of a @i{restart function} is to provide an alternate
  interface. By convention, a @i{restart function} usually has the same name 
  as the @i{restart} which it invokes. Figure 26--4 shows a list of the
  @i{standardized} @i{restart functions}.

@group
@noindent
@w{  abort     muffle-warning  use-value  }
@w{  continue  store-value                }

@noindent
@w{  Figure 26--4: Standardized Restart Functions}

@end group

@IGindex{return}
@item @b{return}
 @i{v.t.} (of @i{values})
  1. (from a @i{block}) to transfer control and @i{values} from the @i{block};
     that is, to cause the @i{block} to @i{yield} the @i{values} immediately
     without doing any further evaluation of the @i{forms} in its body.
  2. (from a @i{form}) to @i{yield} the @i{values}.

@IGindex{return value}
@item @b{return value}
 @i{n.} @i{Trad.} 
  a @i{value}_1

@IGindex{right-parenthesis}
@item @b{right-parenthesis}
 @i{n.}
  the @i{standard character} ``@t{)}'',
  that is variously called
      ``right parenthesis''
   or ``close parenthesis''
  See @i{Figure~2--5}.

@IGindex{run time}
@item @b{run time}
 @i{n.}
  1. @i{load time}
  2. @i{execution time}

@IGindex{run-time compiler}
@item @b{run-time compiler}
 @i{n.}
  refers to the @b{compile} function or to @i{implicit compilation}, 
  for which the compilation and run-time @i{environments} are maintained 
  in the same @i{Lisp image}.

@IGindex{run-time definition}
@item @b{run-time definition}
 @i{n.}
  a definition in the @i{run-time environment}.

@IGindex{run-time environment}
@item @b{run-time environment}
 @i{n.}
  the @i{environment} in which a program is @i{executed}.

@end table
@subheading @b{S}
@table @asis

@IGindex{safe}
@item @b{safe}
 @i{adj.} 
  1. (of @i{code})
     processed in a @i{lexical environment} where the the highest
     @b{safety} level (@t{3}) was in effect. 
     See @b{optimize}.
  2. (of a @i{call}) a @i{safe call}.

@IGindex{safe call}
@item @b{safe call}
 @i{n.}
  a @i{call} in which 
        the @i{call},
        the @i{function} being @i{called},
    and the point of @i{functional evaluation}
  are all @i{safe}_1 @i{code}.
  For more detailed information, see @ref{Safe and Unsafe Calls}.

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

@IGindex{satisfy the test}
@item @b{satisfy the test}
 @i{v.} 
       (of an @i{object} being considered by a @i{sequence function})
  1. (for a one @i{argument} test)
     to be in a state such that the @i{function} which is the
     @i{predicate} @i{argument} to the @i{sequence function}
     returns @i{true} when given a single @i{argument} that is the
     result of calling the @i{sequence function}'s @i{key} @i{argument}
     on the @i{object} being considered.  
     See @ref{Satisfying a One-Argument Test}.
  2. (for a two @i{argument} test)
     to be in a state such that the two-place @i{predicate} 
     which is the @i{sequence function}'s 
     @i{test} @i{argument}
     returns @i{true} when given a first @i{argument} that 
     is
     the @i{object} being considered, 
     and when given a second @i{argument}
     that is the result of calling the @i{sequence function}'s 
     @i{key} @i{argument} on an @i{element} of the
     @i{sequence function}'s @i{sequence} @i{argument} 
     which is being tested for equality;
     or to be in a state such that the @i{test-not} @i{function}
     returns @i{false} given the same @i{arguments}.
     See @ref{Satisfying a Two-Argument Test}.

@IGindex{scope}
@item @b{scope}
 @i{n.} 
  the structural or textual region of code in which @i{references} 
  to an @i{object}, a @i{binding}, an @i{exit point}, 
  a @i{tag}, or an @i{environment} (usually by @i{name}) 
  can occur.

@IGindex{script}
@item @b{script}
 @i{n.} @i{ISO}
  one of possibly several sets that form an @i{exhaustive partition}
  of the type @b{character}.  See @ref{Character Scripts}.

@IGindex{secondary value}
@item @b{secondary value}
 @i{n.} (of @i{values} resulting from the
				   @i{evaluation} of a @i{form})
  the second @i{value}, if any, 
  or else @b{nil} if there are fewer than two @i{values}.
  {``The secondary value returned by @b{truncate} is a remainder.''}

@IGindex{section}
@item @b{section}
 @i{n.}
  a partitioning of output by a @i{conditional newline} on a @i{pretty printing stream}.
  See @ref{Dynamic Control of the Arrangement of Output}.

@IGindex{self-evaluating object}
@item @b{self-evaluating object}
 @i{n.}
  an @i{object} that is neither a @i{symbol} nor a
  @i{cons}.
  If a @i{self-evaluating object} is @i{evaluated},
  it @i{yields} itself as its only @i{value}.
  {``Strings are self-evaluating objects.''}

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

@IGindex{semicolon}
@item @b{semicolon}
 @i{n.}
  the @i{standard character} that is called ``semicolon'' (@t{;}).
  See @i{Figure~2--5}.

@IGindex{sequence}
@item @b{sequence}
 @i{n.} 
  1. an ordered collection of elements
  2. a @i{vector} or a @i{list}.

@IGindex{sequence function}
@item @b{sequence function}
 @i{n.}
  one of the @i{functions} in @i{Figure~17--1},
  or an @i{implementation-defined} @i{function} 
     that operates on one or more @i{sequences}.
     and that is defined by the @i{implementation} to be a @i{sequence function}.

@IGindex{sequential}
@item @b{sequential}
 @i{adj.} @i{Trad.} (of @i{binding} or @i{assignment})
  done in the style of @b{setq}, @b{let*}, or @b{do*};
  that is, interleaving the evaluation of the @i{forms} that produce @i{values}
  with the @i{assignments} or @i{bindings} of the @i{variables} (or @i{places}).
  See @i{parallel}.

@IGindex{sequentially}
@item @b{sequentially}
 @i{adv.}
  in a @i{sequential} way.

@IGindex{serious condition}
@item @b{serious condition}
 @i{n.} 
  a @i{condition} of @i{type} @b{serious-condition}, 
  which represents a @i{situation} that is generally sufficiently 
  severe that entry into the @i{debugger} should be expected if 
  the @i{condition} is @i{signaled} but not @i{handled}.

@IGindex{session}
@item @b{session}
 @i{n.}
  the conceptual aggregation of events in a @i{Lisp image} from the time
  it is started to the time it is terminated.

@IGindex{set}
@item @b{set}
 @i{v.t.} @i{Trad.} (any @i{variable}
				     or a @i{symbol} that 
				        is the @i{name} of a @i{dynamic variable})
  to @i{assign} the @i{variable}.

@IGindex{setf expander}
@item @b{setf expander}
 @i{n.} 
  a function used by @b{setf} to compute the @i{setf expansion}
  of a @i{place}.

@IGindex{setf expansion}
@item @b{setf expansion}
 @i{n.} 
  a set of five @i{expressions}_1 that, taken together, describe 
       how to store into a @i{place} 
   and which @i{subforms} of the macro call associated with the
       @i{place} are evaluated.
  See @ref{Setf Expansions}.

@IGindex{setf function}
@item @b{setf function}
 @i{n.}
  a @i{function} whose @i{name} is @t{(setf @i{symbol})}.

@IGindex{setf function name}
@item @b{setf function name}
 @i{n.} (of a @i{symbol} @i{S})
  the @i{list} @t{(setf @i{S})}.

@IGindex{shadow}
@item @b{shadow}
 @i{v.t.} 
  1. to override the meaning of.
     {``That binding of @t{X} shadows an outer one.''} 
  2. to hide the presence of.
     {``That @b{macrolet} of @t{F} shadows the
               outer @b{flet} of @t{F}.''}
  3. to replace.
     {``That package shadows the symbol @t{cl:car} with
               its own symbol @t{car}.''}

@IGindex{shadowing symbol}
@item @b{shadowing symbol}
 @i{n.} (in a @i{package})
  an @i{element} of the @i{package}'s @i{shadowing symbols list}.

@IGindex{shadowing symbols list}
@item @b{shadowing symbols list}
 @i{n.} (of a @i{package})
  a @i{list}, associated with the @i{package}, 
  of @i{symbols} that are to be exempted from `symbol conflict errors'
  detected when packages are @i{used}.
  See the @i{function} @b{package-shadowing-symbols}.

@IGindex{shared slot}
@item @b{shared slot}
 @i{n.} (of a @i{class}) 
  a @i{slot} @i{accessible} in more than one @i{instance} 
  of a @i{class}; specifically, such a @i{slot} is @i{accessible}
  in all @i{direct instances} of the @i{class} and in those 
  @i{indirect instances} whose @i{class} does not 
  @i{shadow}_1 the @i{slot}.

@IGindex{sharpsign}
@item @b{sharpsign}
 @i{n.}
  the @i{standard character} that is variously called ``number sign,'' ``sharp,''
  or ``sharp sign'' (@t{#}).
  See @i{Figure~2--5}.

@IGindex{short float}
@item @b{short float}
 @i{n.} 
  an @i{object} of @i{type} @b{short-float}.

@IGindex{sign}
@item @b{sign}
 @i{n.} 
  one of the @i{standard characters} ``@t{+}'' or ``@t{-}''.

@IGindex{signal}
@item @b{signal}
 @i{v.} 
  to announce, using a standard protocol, that a particular situation,
  represented by a @i{condition}, has been detected.  
  See @ref{Condition System Concepts}.

@IGindex{signature}
@item @b{signature}
 @i{n.} (of a @i{method})
  a description of the @i{parameters} and
  @i{parameter specializers} for the @i{method} which 
  determines the @i{method}'s applicability for a given set of
  required @i{arguments}, and which also describes the
  @i{argument} conventions for its other, non-required 
  @i{arguments}.

@IGindex{similar}
@item @b{similar}
 @i{adj.} (of two @i{objects})
  defined to be equivalent under the @i{similarity} relationship.

@IGindex{similarity}
@item @b{similarity}
 @i{n.}
  a two-place conceptual equivalence predicate, 
  which is independent of the @i{Lisp image} 
  so that two @i{objects} in different @i{Lisp images} 
  can be understood to be equivalent under this predicate.
  See @ref{Literal Objects in Compiled Files}.

@IGindex{simple}
@item @b{simple}
 @i{adj.}
  1. (of an @i{array}) being of @i{type} @b{simple-array}.
  2. (of a @i{character})
     having no @i{implementation-defined} @i{attributes},
     or else having @i{implementation-defined} @i{attributes}
      each of which has the @i{null} value for that @i{attribute}.

@IGindex{simple array}
@item @b{simple array}
 @i{n.} 
  an @i{array} of @i{type} @b{simple-array}.

@IGindex{simple bit array}
@item @b{simple bit array}
 @i{n.}
  a @i{bit array} that is a @i{simple array};
  that is, an @i{object} of @i{type} @t{(simple-array bit)}.

@IGindex{simple bit vector}
@item @b{simple bit vector}
 @i{n.} 
  a @i{bit vector} of @i{type} @b{simple-bit-vector}.

@IGindex{simple condition}
@item @b{simple condition}
 @i{n.} 
  a @i{condition} of @i{type} @b{simple-condition}.

@IGindex{simple general vector}
@item @b{simple general vector}
 @i{n.} 
  a @i{simple vector}.

@IGindex{simple string}
@item @b{simple string}
 @i{n.} 
  a @i{string} of @i{type} @b{simple-string}.

@IGindex{simple vector}
@item @b{simple vector}
 @i{n.}
  a @i{vector} of @i{type} @b{simple-vector},
  sometimes called a ``@i{simple general vector}.''
  Not all @i{vectors} that are @i{simple} are @i{simple vectors}---only
  those that have @i{element type} @b{t}.

@IGindex{single escape}
@item @b{single escape}
 @i{n.}, @i{adj.}
  1. @i{n.} the @i{syntax type} of a @i{character} 
     that indicates that the next @i{character} is 
     to be treated as an @i{alphabetic}_2 @i{character}
     with its @i{case} preserved.
     For details, see @ref{Single Escape Character}.
  2. @i{adj.} (of a @i{character})
     having the @i{single escape} @i{syntax type}.
  3. @i{n.} a @i{single escape}_2 @i{character}.
     (In the @i{standard readtable},
      @i{slash} is the only @i{single escape}.)

@IGindex{single float}
@item @b{single float}
 @i{n.} 
  an @i{object} of @i{type} @b{single-float}.

@IGindex{single-quote}
@item @b{single-quote}
 @i{n.}
  the @i{standard character} that is variously called
      ``apostrophe,''
      ``acute accent,''
      ``quote,''
   or ``single quote'' (@t{'}).
  See @i{Figure~2--5}.

@IGindex{singleton}
@item @b{singleton}
 @i{adj.} (of a @i{sequence})
  having only one @i{element}.
  {``@t{(list 'hello)} returns a singleton list.''}

@IGindex{situation}
@item @b{situation}
 @i{n.} 
  the @i{evaluation} of a @i{form} in a specific @i{environment}.

@IGindex{slash}
@item @b{slash}
 @i{n.}
  the @i{standard character} that is variously called
       ``solidus'' 
    or ``slash'' (@t{/}).
  See @i{Figure~2--5}.

@IGindex{slot}
@item @b{slot}
 @i{n.} 
  a component of an @i{object} that can store a @i{value}.

@IGindex{slot specifier}
@item @b{slot specifier}
 @i{n.}
  a representation of a @i{slot} 
  that includes the @i{name} of the @i{slot} and zero or more @i{slot} options.
  A @i{slot} option pertains only to a single @i{slot}.

@IGindex{source code}
@item @b{source code}
 @i{n.} 
  @i{code} representing @i{objects} suitable for @i{evaluation}
  (@i{e.g.}, @i{objects} created by @b{read}, 
       by @i{macro expansion}, 

    or by @i{compiler macro expansion}).

@IGindex{source file}
@item @b{source file}
 @i{n.} 
  a @i{file} which contains a textual representation of @i{source code},
  that can be edited, @i{loaded}, or @i{compiled}.

@IGindex{space}
@item @b{space}
 @i{n.}
  the @i{standard character} <@i{Space}>,
  notated for the @i{Lisp reader} as @t{#\Space}.

@IGindex{special form}
@item @b{special form}
 @i{n.} 
  a @i{list}, other than a @i{macro form}, which is a
  @i{form} with special syntax or special @i{evaluation} 
  rules or both, possibly manipulating the @i{evaluation} 
  @i{environment} or control flow or both.  The first element of
  a @i{special form} is a @i{special operator}.

@IGindex{special operator}
@item @b{special operator}
 @i{n.} 
  one of a fixed set of @i{symbols}, 
  enumerated in @i{Figure~3--2},
  that may appear in the @i{car} of
  a @i{form} in order to identify the @i{form} as a @i{special form}.

@IGindex{special variable}
@item @b{special variable}
 @i{n.} @i{Trad.}
  a @i{dynamic variable}.

@IGindex{specialize}
@item @b{specialize}
 @i{v.t.} (a @i{generic function})
  to define a @i{method} for the @i{generic function}, or in other words,
  to refine the behavior of the @i{generic function} by giving it a specific
  meaning for a particular set of @i{classes} or @i{arguments}. 

@IGindex{specialized}
@item @b{specialized}
 @i{adj.} 
  1. (of a @i{generic function})
     having @i{methods} which @i{specialize} the @i{generic function}.
  2. (of an @i{array})
     having an @i{actual array element type}
     that is a @i{proper subtype} of the @i{type} @b{t};
     see @ref{Array Elements}.
     {``@t{(make-array 5 :element-type 'bit)} makes an array of length
	       five that is specialized for bits.''}

@IGindex{specialized lambda list}
@item @b{specialized lambda list}
 @i{n.}
  an @i{extended lambda list} used in @i{forms} that @i{establish}
  @i{method} definitions, such as @b{defmethod}.
  See @ref{Specialized Lambda Lists}.

@IGindex{spreadable argument list designator}
@item @b{spreadable argument list designator}
 @i{n.}
  a @i{designator} for a @i{list} of @i{objects}; that is,
  an @i{object} that denotes a @i{list} 
  and that is a @i{non-null} @i{list} L1 of length n,
  whose last element is a @i{list} L2 of length m
  (denoting a list L3 of length m+n-1 whose @i{elements} are
   L1_i for i < n-1 followed by L2_j for j < m).
  {``The list (1 2 (3 4 5)) is a spreadable argument list designator for
	    the list (1 2 3 4 5).''}

@IGindex{stack allocate}
@item @b{stack allocate}
 @i{v.t.} @i{Trad.} 
  to allocate in a non-permanent way, such as on a stack.  Stack-allocation
  is an optimization technique used in some @i{implementations} for
  allocating certain kinds of @i{objects} that have @i{dynamic extent}.
  Such @i{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 @i{types} (if any) can have @i{dynamic extent} can vary
  from @i{implementation} to @i{implementation}.  No
  @i{implementation} is ever required to perform stack-allocation.

@IGindex{stack-allocated}
@item @b{stack-allocated}
 @i{adj.} @i{Trad.} 
  having been @i{stack allocated}.

@IGindex{standard character}
@item @b{standard character}
 @i{n.} 
  a @i{character} of @i{type} @b{standard-char}, which is one of a fixed set of 96
  such @i{characters} required to be present in all @i{conforming implementations}.
  See @ref{Standard Characters}.

@IGindex{standard class}
@item @b{standard class}
 @i{n.} 
  a @i{class} that is a @i{generalized instance} of @i{class} @b{standard-class}.

@IGindex{standard generic function}
@item @b{standard generic function}

  a @i{function} of @i{type} @b{standard-generic-function}.

@IGindex{standard input}
@item @b{standard input}
 @i{n.} 
  the @i{input} @i{stream} which is the @i{value} of the @i{dynamic variable}
  @b{*standard-input*}.

@IGindex{standard method combination}
@item @b{standard method combination}
 @i{n.} 
  the @i{method combination} named @b{standard}.

@IGindex{standard object}
@item @b{standard object}
 @i{n.} 
  an @i{object} that is 
  a @i{generalized instance} 
  of @i{class} @b{standard-object}.

@IGindex{standard output}
@item @b{standard output}
 @i{n.} 
  the @i{output} @i{stream} which is the @i{value} of the @i{dynamic variable}
  @b{*standard-output*}.

@IGindex{standard pprint dispatch table}
@item @b{standard pprint dispatch table}
 @i{n.}
  A @i{pprint dispatch table} that is @i{different} from 
  the @i{initial pprint dispatch table},
  that implements @i{pretty printing} as described in this specification,
  and that, unlike other @i{pprint dispatch tables},
  must never be modified by any program.
  (Although the definite reference ``the @i{standard pprint dispatch table}''
   is generally used
   within this document, it is actually @i{implementation-dependent} whether a
   single @i{object} fills the role of the @i{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 @i{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.)

@IGindex{standard readtable}
@item @b{standard readtable}
 @i{n.}
  A @i{readtable} that is @i{different} from the @i{initial readtable},
  that implements the @i{expression} syntax defined in this specification,
  and that, unlike other @i{readtables}, must never be modified by any program.
  (Although the definite reference ``the @i{standard readtable}'' is generally used
   within this document, it is actually @i{implementation-dependent} whether a
   single @i{object} fills the role of the @i{standard readtable},
   or whether there might be multiple such objects, any one of which could be used on any
   given occasion where ``the @i{standard readtable}'' is called for.
   As such, this phrase should be seen as an indefinite reference 
   in all cases except for anaphoric references.)

@IGindex{standard syntax}
@item @b{standard syntax}
 @i{n.}
  the syntax represented by the @i{standard readtable} 
  and used as a reference syntax throughout this document.
  See @ref{Character Syntax}.

@IGindex{standardized}
@item @b{standardized}
 @i{adj.} (of a @i{name}, @i{object}, or definition)
  having been defined by @r{Common Lisp}.
  {``All standardized variables that are required to 
	    hold bidirectional streams have ``@t{-io*}'' in their name.''}

@IGindex{startup environment}
@item @b{startup environment}
 @i{n.}
  the @i{global environment} of the running @i{Lisp image} 
  from which the @i{compiler} was invoked.

@IGindex{step}
@item @b{step}
 @i{v.t.}, @i{n.} 
  1. @i{v.t.} (an iteration @i{variable}) to @i{assign} the @i{variable}
     a new @i{value} at the end of an iteration, in preparation for a new iteration.
  2. @i{n.} the @i{code} that identifies how the next value in an iteration
     is to be computed.
  3. @i{v.t.} (@i{code}) to specially execute the @i{code}, pausing at
     intervals to allow user confirmation or intervention, usually for debugging.

@IGindex{stream}
@item @b{stream}
 @i{n.} 
  an @i{object} that can be used with an input or output function to
  identify an appropriate source or sink of @i{characters} or 
  @i{bytes} for that operation.

@IGindex{stream associated with a file}
@item @b{stream associated with a file}
 @i{n.} 
  a @i{file stream}, or a @i{synonym stream} the @i{target} 
  of which is a @i{stream associated with a file}.
  Such a @i{stream} cannot be created with
      @b{make-two-way-stream}, 
      @b{make-echo-stream},
      @b{make-broadcast-stream}, 
      @b{make-concatenated-stream},
      @b{make-string-input-stream},
   or @b{make-string-output-stream}.

@IGindex{stream designator}
@item @b{stream designator}
 @i{n.}
  a @i{designator} for a @i{stream}; that is,
  an @i{object} that denotes a @i{stream} 
  and that is one of:
      @b{t} (denoting the @i{value} of @b{*terminal-io*}), 
      @b{nil} (denoting the @i{value} of @b{*standard-input*}
             for @i{input} @i{stream designators}
             or denoting the @i{value} of @b{*standard-output*}
             for @i{output} @i{stream designators}),
   or a @i{stream} (denoting itself).

@IGindex{stream element type}
@item @b{stream element type}
 @i{n.} (of a @i{stream})
  the @i{type} of data for which the @i{stream} is specialized.

@IGindex{stream variable}
@item @b{stream variable}
 @i{n.}
  a @i{variable} whose @i{value} must be a @i{stream}.

@IGindex{stream variable designator}
@item @b{stream variable designator}
 @i{n.}
  a @i{designator} for a @i{stream variable}; that is,
  a @i{symbol} that denotes a @i{stream variable} 
  and that is one of:
      @b{t} (denoting @b{*terminal-io*}), 
      @b{nil} (denoting @b{*standard-input*}
             for @i{input} @i{stream variable designators}
             or denoting @b{*standard-output*}
             for @i{output} @i{stream variable designators}),
   or some other @i{symbol} (denoting itself).

@IGindex{string}
@item @b{string}
 @i{n.} 
  a specialized @i{vector} that is of @i{type} @b{string},
  and whose elements are of @i{type} @b{character} or a @i{subtype} of @i{type} @b{character}.

@IGindex{string designator}
@item @b{string designator}
 @i{n.}
  a @i{designator} for a @i{string}; that is,
  an @i{object} that denotes a @i{string} 
  and that is one of:
       a @i{character} (denoting a @i{singleton} @i{string}
			   that has the @i{character} as its only @i{element}),
       a @i{symbol} (denoting the @i{string} that is its @i{name}),
    or a @i{string} (denoting itself).

  The intent is that this term be consistent with the behavior of @b{string};
  @i{implementations} that extend @b{string} must extend the meaning of 
  this term in a compatible way.

@IGindex{string equal}
@item @b{string equal}
 @i{adj.} 
  the @i{same} under @b{string-equal}.

@IGindex{string stream}
@item @b{string stream}
 @i{n.} 
  a @i{stream} of @i{type} @b{string-stream}.

@IGindex{structure}
@item @b{structure}
 @i{n.} 
  an @i{object} of @i{type} @b{structure-object}.

@IGindex{structure class}
@item @b{structure class}
 @i{n.} 
  a @i{class} that is a @i{generalized instance} of @i{class} @b{structure-class}.

@IGindex{structure name}
@item @b{structure name}
 @i{n.}
  a @i{name} defined with @b{defstruct}.
  Usually, such a @i{type} is also a @i{structure class},
  but there may be @i{implementation-dependent} situations 
  in which this is not so, if the @t{:type} option to @b{defstruct} is used.

@IGindex{style warning}
@item @b{style warning}
 @i{n.}
  a @i{condition} of @i{type} @b{style-warning}.

@IGindex{subclass}
@item @b{subclass}
 @i{n.} 
  a @i{class} that @i{inherits} from another @i{class}, 
  called a @i{superclass}.
  (No @i{class} is a @i{subclass} of itself.)

@IGindex{subexpression}
@item @b{subexpression}
 @i{n.} (of an @i{expression})
  an @i{expression} that is contained within the @i{expression}. 
  (In fact, the state of being a @i{subexpression} is not an attribute 
   of the @i{subexpression}, but really an attribute of the containing
   @i{expression} since the @i{same} @i{object} can at once be
   a @i{subexpression} in one context, and not in another.)

@IGindex{subform}
@item @b{subform}
 @i{n.} (of a @i{form})
  an @i{expression} that is a @i{subexpression} of the @i{form},
  and which by virtue of its position in that @i{form} is also a
  @i{form}.
  {``@t{(f x)} and @t{x}, but not @t{exit}, are subforms of
	    @t{(return-from exit (f x))}.''}

@IGindex{subrepertoire}
@item @b{subrepertoire}
 @i{n.} 
  a subset of a @i{repertoire}.

@IGindex{subtype}
@item @b{subtype}
 @i{n.} 
  a @i{type} whose membership is the same as or a proper subset of the
  membership of another @i{type}, called a @i{supertype}.
  (Every @i{type} is a @i{subtype} of itself.)

@IGindex{superclass}
@item @b{superclass}
 @i{n.} 
  a @i{class} from which another @i{class} 
  (called a @i{subclass}) @i{inherits}.
  (No @i{class} is a @i{superclass} of itself.)
  See @i{subclass}.

@IGindex{supertype}
@item @b{supertype}
 @i{n.} 
  a @i{type} whose membership is the same as or a proper superset
  of the membership of another @i{type}, called a @i{subtype}.
  (Every @i{type} is a @i{supertype} of itself.)
  See @i{subtype}.

@IGindex{supplied-p parameter}
@item @b{supplied-p parameter}
 @i{n.}
  a @i{parameter} which recieves its @i{generalized boolean} value
  implicitly due to the presence or absence of an @i{argument} 
  corresponding to another @i{parameter} 
  (such as an @i{optional parameter} or a @i{rest parameter}).
  See @ref{Ordinary Lambda Lists}.

@IGindex{symbol}
@item @b{symbol}
 @i{n.} 
  an @i{object} of @i{type} @b{symbol}.

@IGindex{symbol macro}
@item @b{symbol macro}
 @i{n.} 
  a @i{symbol} that stands for another @i{form}.
  See the @i{macro} @b{symbol-macrolet}.

@IGindex{synonym stream}
@item @b{synonym stream}
 @i{n.} 
  1. a @i{stream} of @i{type} @b{synonym-stream}, 
     which is consequently a @i{stream} that is an alias for another @i{stream},
     which is the @i{value} of a @i{dynamic variable}
     whose @i{name} is the @i{synonym stream symbol} of the @i{synonym stream}.
     See the @i{function} @b{make-synonym-stream}.
  2. (to a @i{stream})
     a @i{synonym stream} which has the @i{stream} as the @i{value}
     of its @i{synonym stream symbol}.
  3. (to a @i{symbol})
     a @i{synonym stream} which has the @i{symbol} as its
     @i{synonym stream symbol}.

@IGindex{synonym stream symbol}
@item @b{synonym stream symbol}
 @i{n.} (of a @i{synonym stream})
  the @i{symbol} which names the @i{dynamic variable} which has as its
  @i{value} another @i{stream} for which the @i{synonym stream}
  is an alias.

@IGindex{syntax type}
@item @b{syntax type}
 @i{n.} (of a @i{character})
  one of several classifications, enumerated in @i{Figure~2--6},
  that are used for dispatch during parsing by the @i{Lisp reader}.
  See @ref{Character Syntax Types}.

@IGindex{system class}
@item @b{system class}
 @i{n.} 
  a @i{class} that may be of @i{type} @b{built-in-class} in a @i{conforming implementation}
  and hence cannot be inherited by @i{classes} defined by @i{conforming programs}.

@IGindex{system code}
@item @b{system code}
 @i{n.} 
  @i{code} supplied by the @i{implementation} to implement this specification
  (@i{e.g.}, the definition of @b{mapcar})
  or generated automatically in support of this specification
  (@i{e.g.}, during method combination);
  that is, @i{code} that is not @i{programmer code}.

@end table
@subheading @b{T}
@table @asis

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

@IGindex{tag}
@item @b{tag}
 @i{n.} 
  1. a @i{catch tag}.
  2. a @i{go tag}.

@IGindex{tail}
@item @b{tail}
 @i{n.} (of a @i{list})
  an @i{object} that is the @i{same} as either some @i{cons}
  which makes up that @i{list} or the @i{atom} (if any) which terminates
  the @i{list}.
  {``The empty list is a tail of every proper list.''}

@IGindex{target}
@item @b{target}
 @i{n.} 
  1. (of a @i{constructed stream}) 
     a @i{constituent} of the @i{constructed stream}.
     {``The target of a synonym stream is 
	       the value of its synonym stream symbol.''}
  2. (of a @i{displaced array})
     the @i{array} to which the @i{displaced array} is displaced.
  (In the case of a chain of @i{constructed streams} or @i{displaced arrays},
   the unqualified term ``@i{target}'' always refers to the immediate 
   @i{target} of the first item in the chain, not the immediate target
   of the last item.)

@IGindex{terminal I/O}
@item @b{terminal I/O}
 @i{n.} 
  the @i{bidirectional} @i{stream}
  that is the @i{value} of the @i{variable} @b{*terminal-io*}.

@IGindex{terminating}
@item @b{terminating}
 @i{n.} (of a @i{macro character})
  being such that, if it appears while parsing a token, it terminates that token.
  See @ref{Reader Algorithm}.

@IGindex{tertiary value}
@item @b{tertiary value}
 @i{n.} (of @i{values} resulting from the
				   @i{evaluation} of a @i{form})
  the third @i{value}, if any,
  or else @b{nil} if there are fewer than three @i{values}.

@IGindex{throw}
@item @b{throw}
 @i{v.} 
  to transfer control and @i{values} to a @i{catch}.
  See the @i{special operator} @b{throw}.

@IGindex{tilde}
@item @b{tilde}
 @i{n.}
  the @i{standard character} that is called ``tilde'' (@t{~}).
  See @i{Figure~2--5}.

@IGindex{time}
@item @b{time}

  a representation of a point (@i{absolute} @i{time}) 
		   or an interval (@i{relative} @i{time})
  on a time line.
  See @i{decoded time}, @i{internal time}, and @i{universal time}.

@IGindex{time zone}
@item @b{time zone}
 @i{n.}
  a @i{rational} multiple of @t{1/3600} between @t{-24} (inclusive)
  and @t{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 @t{5},
       California, U.S.A. is time zone @t{8},
   and Moscow, Russia is time zone @i{-3}.
   (When ``daylight savings time'' is separately represented
    as an @i{argument} or @i{return value}, the @i{time zone}
    that accompanies it does not depend on whether daylight savings time
    is in effect.)

@IGindex{token}
@item @b{token}
 @i{n.}
  a textual representation for a @i{number} or a @i{symbol}.
  See @ref{Interpretation of Tokens}.

@IGindex{top level form}
@item @b{top level form}
 @i{n.} 
  a @i{form} which is processed specially by @b{compile-file} for
  the purposes of enabling @i{compile time} @i{evaluation} of that
  @i{form}.  
  @i{Top level forms} include those @i{forms} which 
  are not @i{subforms} of any other @i{form},
  and certain other cases.  See @ref{Processing of Top Level Forms}.

@IGindex{trace output}
@item @b{trace output}
 @i{n.} 
  the @i{output} @i{stream} which is the @i{value} of the @i{dynamic variable}
  @b{*trace-output*}.

@IGindex{tree}
@item @b{tree}
 @i{n.} 
  1. a binary recursive data structure made up of @i{conses} and
     @i{atoms}:  the @i{conses} are themselves also @i{trees}
     (sometimes called ``subtrees'' or ``branches''), and the @i{atoms}
     are terminal nodes (sometimes called @i{leaves}). Typically,
     the @i{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 @i{leaves}.

@IGindex{tree structure}
@item @b{tree structure}
 @i{n.} (of a @i{tree}_1)
  the set of @i{conses} that make up the @i{tree}.
  Note that while the @i{car}_@{1b@} component of each such @i{cons}
  is part of the @i{tree structure}, 
  the @i{objects} that are the @i{cars}_2 of each @i{cons}
  in the @i{tree}
  are not themselves part of its @i{tree structure} 
  unless they are also @i{conses}.

@IGindex{true}
@item @b{true}
 @i{n.} 
  any @i{object} 
      that is not @i{false}
  and that is used to represent the success of a @i{predicate} test.
  See @i{t}_1.

@IGindex{truename}
@item @b{truename}
 @i{n.} 
  1. the canonical @i{filename} of a @i{file} in the @i{file system}.
     See @ref{Truenames}.
  2. a @i{pathname} representing a @i{truename}_1.

@IGindex{two-way stream}
@item @b{two-way stream}
 @i{n.} 
  a @i{stream} of @i{type} @b{two-way-stream},
  which is a @i{bidirectional} @i{composite stream} that 
       receives its input  from an associated @i{input}  @i{stream} 
   and sends    its output to   an associated @i{output} @i{stream}.

@IGindex{type}
@item @b{type}
 @i{n.} 
  1. a set of @i{objects}, usually with common structure, behavior, or purpose.
     (Note that the expression ``@i{X} is of type @i{S_a}'' 
      naturally implies that ``@i{X} is of type @i{S_b}'' if 
      @i{S_a} is a @i{subtype} of @i{S_b}.)
  2. (immediately following the name of a @i{type})
     a @i{subtype} of that @i{type}.
     {``The type @b{vector} is an array type.''}

@IGindex{type declaration}
@item @b{type declaration}
 @i{n.} 
  a @i{declaration} that asserts that every reference to a 
  specified @i{binding} within the scope of the @i{declaration}
  results in some @i{object} of the specified @i{type}.

@IGindex{type equivalent}
@item @b{type equivalent}
 @i{adj.} (of two @i{types} X and Y)
  having the same @i{elements};
  that is, X is a @i{subtype} of Y 
       and Y is a @i{subtype} of X.

@IGindex{type expand}
@item @b{type expand}
 @i{n.}
  to fully expand a @i{type specifier}, removing any references to
  @i{derived types}.  (@r{Common Lisp} provides no program interface to cause
  this to occur, but the semantics of @r{Common Lisp} are such that every
  @i{implementation} must be able to do this internally, and some
  situations involving @i{type specifiers} are most easily described
  in terms of a fully expanded @i{type specifier}.)

@IGindex{type specifier}
@item @b{type specifier}
 @i{n.} 
  an @i{expression} that denotes a @i{type}.
  {``The symbol @t{random-state}, the list @t{(integer 3 5)},
            the list @t{(and list (not null))}, and the class named
            @t{standard-class} are type specifiers.''}

@end table
@subheading @b{U}
@table @asis

@IGindex{unbound}
@item @b{unbound}
 @i{adj.} 
  not having an associated denotation in a @i{binding}.
  See @i{bound}.

@IGindex{unbound variable}
@item @b{unbound variable}
 @i{n.}
  a @i{name} that is syntactically plausible as the name of a
  @i{variable} but which is not @i{bound} 
  in the @i{variable} @i{namespace}.

@IGindex{undefined function}
@item @b{undefined function}
 @i{n.}
  a @i{name} that is syntactically plausible as the name of a
  @i{function} but which is not @i{bound}
  in the @i{function} @i{namespace}.

@IGindex{unintern}
@item @b{unintern}
 @i{v.t.} (a @i{symbol} in a @i{package})
  to make the @i{symbol} not be @i{present} in that @i{package}.
  (The @i{symbol} might continue to be @i{accessible} by inheritance.)

@IGindex{uninterned}
@item @b{uninterned}
 @i{adj.} (of a @i{symbol}) 
  not @i{accessible} in any @i{package}; @i{i.e.}, not @i{interned}_1.

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

@IGindex{unqualified method}
@item @b{unqualified method}
 @i{n.} 
  a @i{method} with no @i{qualifiers}.

@IGindex{unregistered package}
@item @b{unregistered package}
 @i{n.}
  a @i{package} @i{object} that is not present in the @i{package registry}.
  An @i{unregistered package} has no @i{name}; @i{i.e.}, its @i{name} is @b{nil}.
  See the @i{function} @b{delete-package}.

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

@IGindex{unsafe call}
@item @b{unsafe call}
 @i{n.}
  a @i{call} that is not a @i{safe call}.
  For more detailed information, see @ref{Safe and Unsafe Calls}.

@IGindex{upgrade}
@item @b{upgrade}
 @i{v.t.} (a declared @i{type} to an actual @i{type})
  1. (when creating an @i{array})
     to substitute an @i{actual array element type} 
     for an @i{expressed array element type}
     when choosing an appropriately @i{specialized} @i{array} representation.
     See the @i{function} @b{upgraded-array-element-type}.
  2. (when creating a @i{complex})
     to substitute an @i{actual complex part type} 
     for an @i{expressed complex part type}
     when choosing an appropriately @i{specialized} @i{complex} representation.
     See the @i{function} @b{upgraded-complex-part-type}.

@IGindex{upgraded array element type}
@item @b{upgraded array element type}
 @i{n.} (of a @i{type})
  a @i{type} that is a @i{supertype} of the @i{type}
  and that is used instead of the @i{type} whenever the
  @i{type} is used as an @i{array element type} 
  for object creation or type discrimination.
  See @ref{Array Upgrading}.

@IGindex{upgraded complex part type}
@item @b{upgraded complex part type}
 @i{n.} (of a @i{type})
  a @i{type} that is a @i{supertype} of the @i{type}
  and that is used instead of the @i{type} whenever the
  @i{type} is used as a @i{complex part type} 
  for object creation or type discrimination.
  See the @i{function} @b{upgraded-complex-part-type}.

@IGindex{uppercase}
@item @b{uppercase}
 @i{adj.} (of a @i{character})
     being among @i{standard characters} corresponding to
     the capital letters @t{A} through @t{Z},
  or being some other @i{implementation-defined} @i{character}
      that is defined by the @i{implementation} to be @i{uppercase}.
  See @ref{Characters With Case}.

@IGindex{use}
@item @b{use}
 @i{v.t.} (a @i{package} P_1)
  to @i{inherit} the @i{external symbols} of P_1.
  (If a package P_2 uses P_1,
   the @i{external symbols} of P_1
   become @i{internal symbols} of P_2 
   unless they are explicitly @i{exported}.)
  {``The package @t{CL-USER} uses the package @t{CL}.''}

@IGindex{use list}
@item @b{use list}
 @i{n.} (of a @i{package})
  a (possibly empty) @i{list} associated with each @i{package}
  which determines what other @i{packages} are currently being
  @i{used} by that @i{package}.

@IGindex{user}
@item @b{user}
 @i{n.} 
  an active entity, typically a human, that invokes or interacts with a
  @i{program} at run time, but that is not necessarily a @i{programmer}.

@end table
@subheading @b{V}
@table @asis

@IGindex{valid array dimension}
@item @b{valid array dimension}
 @i{n.} 
  a @i{fixnum} suitable for use as an @i{array} @i{dimension}.
  Such a @i{fixnum} must be greater than or equal to zero, 
  and less than the @i{value} of @b{array-dimension-limit}.
  When multiple @i{array} @i{dimensions} are to be used together to specify a 
  multi-dimensional @i{array}, there is also an implied constraint 
  that the product of all of the @i{dimensions} be less than the @i{value} of 
  @b{array-total-size-limit}.

@IGindex{valid array index}
@item @b{valid array index}
 @i{n.} (of an @i{array})
  a @i{fixnum} suitable for use as one of possibly several indices needed
  to name an @i{element} of the @i{array} according to a multi-dimensional
  Cartesian coordinate system. Such a @i{fixnum} must
  be greater than or equal to zero,
  and must be less than the corresponding @i{dimension}_1
  of the @i{array}.
  (Unless otherwise explicitly specified, 
   the phrase ``a @i{list} of @i{valid array indices}'' further implies
   that the @i{length} of the @i{list} must be the same as the
   @i{rank} of the @i{array}.)
  {``For a @t{2} by~@t{3} array,
	    valid array indices for the first  dimension are @t{0} and~@t{1}, and
	    valid array indices for the second dimension are @t{0}, @t{1} and~@t{2}.''}

@IGindex{valid array row-major index}
@item @b{valid array row-major index}
 @i{n.} (of an @i{array},
					     which might have any number 
					     of @i{dimensions}_2)
  a single @i{fixnum} suitable for use in naming any @i{element}
  of the @i{array}, by viewing the array's storage as a linear
  series of @i{elements} in row-major order.
  Such a @i{fixnum} must be greater than or equal to zero,
  and less than the @i{array total size} of the @i{array}.

@IGindex{valid fill pointer}
@item @b{valid fill pointer}
 @i{n.} (of an @i{array})
  a @i{fixnum} suitable for use as a @i{fill pointer} for the @i{array}.
  Such a @i{fixnum} must be greater than or equal to zero, 
  and less than or equal to the @i{array total size} of the @i{array}.

[Editorial Note by KMP: The ``valid pathname xxx'' definitions were taken from 
		 text found in make-pathname, but look wrong to me.
		 I'll fix them later.]

@IGindex{valid logical pathname host}
@item @b{valid logical pathname host}
 @i{n.}
  a @i{string} that has been defined as the name of a @i{logical host}.
  See the @i{function} @b{load-logical-pathname-translations}.

@IGindex{valid pathname device}
@item @b{valid pathname device}
 @i{n.}
     a @i{string},
     @b{nil},
     @t{:unspecific}, 
  or some other @i{object} defined by the @i{implementation} 
      to be a @i{valid pathname device}.

@IGindex{valid pathname directory}
@item @b{valid pathname directory}
 @i{n.}
     a @i{string},
     a @i{list} of @i{strings},
     @b{nil},

     @t{:wild},

     @t{:unspecific},
  or some other @i{object} defined by the @i{implementation} 
      to be a @i{valid directory component}.

@IGindex{valid pathname host}
@item @b{valid pathname host}
 @i{n.}
     a @i{valid physical pathname host}
  or a @i{valid logical pathname host}.

@IGindex{valid pathname name}
@item @b{valid pathname name}
 @i{n.}
     a @i{string},
     @b{nil},
     @t{:wild},
     @t{:unspecific},
  or some other @i{object} defined by the @i{implementation} 
     to be a @i{valid pathname name}.

@IGindex{valid pathname type}
@item @b{valid pathname type}
 @i{n.}
     a @i{string},
     @b{nil},
     @t{:wild},
     @t{:unspecific}.

@IGindex{valid pathname version}
@item @b{valid pathname version}
 @i{n.}
     a non-negative @i{integer},
     or one of @t{:wild},
               @t{:newest},
 	       @t{:unspecific},
   	    or @b{nil}.
 The symbols @t{:oldest}, @t{:previous}, and @t{:installed} are
 @i{semi-standard} special version symbols.

@IGindex{valid physical pathname host}
@item @b{valid physical pathname host}
 @i{n.}
   any of
     a @i{string},
     a @i{list} of @i{strings},
     or the symbol @t{:unspecific},
   that is recognized by the implementation as the name of a host.

@IGindex{valid sequence index}
@item @b{valid sequence index}
 @i{n.} (of a @i{sequence})
  an @i{integer} suitable for use to name an @i{element} 
  of the @i{sequence}.  Such an @i{integer} must 
  be greater than or equal to zero,
  and must be less than the @i{length} of the @i{sequence}.

  (If the @i{sequence} is an @i{array},
   the @i{valid sequence index} is further constrained to be a @i{fixnum}.)

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

@IGindex{value cell}
@item @b{value cell}
 @i{n.} @i{Trad.} (of a @i{symbol})
  The @i{place} which holds the @i{value}, if any, of the
  @i{dynamic variable} named by that @i{symbol},
  and which is @i{accessed} by @b{symbol-value}.
  See @i{cell}.

@IGindex{variable}
@item @b{variable}
 @i{n.} 
  a @i{binding} in which a @i{symbol} is the @i{name}
  used to refer to an @i{object}.

@IGindex{vector}
@item @b{vector}
 @i{n.} 
  a one-dimensional @i{array}.

@IGindex{vertical-bar}
@item @b{vertical-bar}
 @i{n.}
  the @i{standard character} that is called ``vertical bar'' (@t{|}).
  See @i{Figure~2--5}.

@end table
@subheading @b{W}
@table @asis

@IGindex{whitespace}
@item @b{whitespace}
 @i{n.} 
  1. one or more @i{characters} that are
      either the @i{graphic} @i{character} @t{#\Space}
          or else @i{non-graphic} characters such as @t{#\Newline} 
                  that only move the print position.
  2. a. @i{n.} the @i{syntax type} of a @i{character} 
         that is a @i{token} separator.
         For details, see @ref{Whitespace Characters}.
     b. @i{adj.} (of a @i{character})
        having the @i{whitespace}_@{2a@} @i{syntax type}_2.
     c. @i{n.} a @i{whitespace}_@{2b@} @i{character}.

@IGindex{wild}
@item @b{wild}
 @i{adj.}
  1. (of a @i{namestring}) using an @i{implementation-defined}
     syntax for naming files, which might ``match'' any of possibly several
     possible @i{filenames}, and which can therefore be used to refer to 
     the aggregate of the @i{files} named by those @i{filenames}.
  2. (of a @i{pathname}) a structured representation of a name which
     might ``match'' any of possibly several @i{pathnames}, and which can
     therefore be used to refer to the aggregate of the @i{files} named by those
     @i{pathnames}.  The set of @i{wild} @i{pathnames} includes, but
     is not restricted to, @i{pathnames} which have a component which is
     @t{:wild}, or which have a directory component which contains @t{:wild} 
     or @t{:wild-inferors}.
     See the @i{function} @b{wild-pathname-p}.

@IGindex{write}
@item @b{write}
 @i{v.t.} 

  1. (a @i{binding} or @i{slot} or component)
     to change the @i{value} of the @i{binding} or @i{slot}.

  2. (an @i{object} to a @i{stream})
     to output a representation of the @i{object} to the @i{stream}.

@IGindex{writer}
@item @b{writer}
 @i{n.}
  a @i{function} that @i{writes}_1 a @i{variable} or @i{slot}.

@end table
@subheading @b{Y}
@table @asis

@IGindex{yield}
@item @b{yield}
 @i{v.t.} (@i{values})
  to produce the @i{values} as the result of @i{evaluation}.
  {``The form @t{(+ 2 3)} yields @t{5}.''}

@end table

@end table

@c end of including concept-glossary

@c %**end of chapter