

@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

@c @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} @i{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{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 
  @i{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.''

@format
@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
@end format

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

@format
@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
@end format

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

@format
@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
@end format

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

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

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

@end group
@end format

@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

@c @end table

@c end of including concept-glossary

@c %**end of chapter

