gcl.info-53

This is Info file gcl.info, produced by Makeinfo-1.55 from the input file
gcl.texi.

This is a Texinfo GNU Common Lisp Manual based on the draft ANSI standard
for Common Lisp.

Copyright 1994 William F. Schelter


File: gcl.info,  Node: Glossary,  Prev: Glossary (Glossary),  Up: Glossary (Glossary)

Glossary
========

Each entry in this glossary has the following parts:

*
     the term being defined, set in boldface.

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

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

*
     one or more definitions, organized as follows:

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

    -
          an optional part of speech, set in italics, present if the term
          is one of several parts of speech.

    -
          an optional discipline, set in italics, present if the term has
          a standard definition being repeated. For example, "Math."

    -
          an optional context, present if this definition is meaningful
          only in that context. For example, "(of a symbol)".

    -
          the definition.

    -
          an optional example sentence. For example, "This is an example
          of an example."

    -
          optional cross references.

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 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, "complex float" refers to a single glossary entry for
"complex float" rather than the combined meaning of the glossary terms
"complex" and "float."

Subscript notation, as in "something_n" means that the nth definition of
"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
adj.
     adjective

adv.
     adverb

ANSI
     compatible with one or more ANSI standards

Comp.
     computers

Idiom.
     idiomatic

IEEE
     compatible with one or more IEEE standards

ISO
     compatible with one or more ISO standards

Math.
     mathematics

Trad.
     traditional

n.
     noun

v.
     verb

v.t.
     transitive verb

Non-alphabetic
--------------

    ()
          pronounced 'nil , n.  an alternative notation for writing the
          symbol~nil, used to emphasize the use of nil as an empty list.

A
-

    absolute
          adj.  1. (of a time) representing a specific point in time.  2.
          (of a pathname) representing a specific position in a directory
          hierarchy.  See relative.

    access
          n., v.t.  1. v.t. (a place, or array) to read_1 or write_1 the
          value of the place or an element of the array.  2. n. (of a
          place) an attempt to access_1 the value of the place.

    accessibility
          n.  the state of being accessible.

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

    accessor
          n.  an operator that performs an access.  See reader and writer.

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

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

    actual argument
          n. Trad.  an argument.

    actual array element type
          n. (of an array) the type for which the array is actually
          specialized, which is the upgraded array element type of the
          expressed array element type of the array.  See the function
          array-element-type.

    actual complex part type
          n. (of a complex) the type in which the real and imaginary parts
          of the complex are actually represented, which is the upgraded
          complex part type of the expressed complex part type of the
          complex.

    actual parameter
          n. Trad.  an argument.

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

    adjustability
          n. (of an array) 1. expressed adjustability.  2. actual
          adjustability.

    adjustable
          adj. (of an array) 1. expressly adjustable.  2. actually
          adjustable.

    after method
          n.  a method having the qualifier :after.

    alist
          pronounced '\=a ,list , n.  an association list.

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

    alphanumeric
          adj. (of a character) being either an alphabetic_1 character or
          a numeric character.

    ampersand
          n.  the standard character that is called "ampersand" (&).  See
          Figure~2-5.

    anonymous
          adj.  1. (of a class or function) having no name 2. (of a
          restart) having a name of nil.

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

    applicable
          adj.  1. (of a handler) being an applicable handler.  2. (of a
          method) being an applicable method.  3. (of a restart) being an
          applicable restart.

    applicable handler
          n. (for a condition being signaled) an active handler for which
          the associated type contains the condition.

    applicable method
          n. (of a generic function called with arguments) a method of the
          generic function for which the arguments satisfy the parameter
          specializers of that method.  See *Note Selecting the Applicable
          Methods::.

    applicable restart
          n.  1. (for a condition) an active handler for which the
          associated test returns true when given the condition as an
          argument.  2. (for no particular condition) an active handler
          for which the associated test returns true when given nil as an
          argument.

    apply
          v.t. (a function to a list) to call the function with arguments
          that are the elements of the list.  "Applying the function + to
          a list of integers returns the sum of the elements of that list."

    argument
          n.  1. (of a function) an object which is offered as data to the
          function when it is called.

          2. (of a format control) a format argument.

    argument evaluation order
          n.  the order in which arguments are evaluated in a function
          call.  "The argument evaluation order for Common Lisp is left to
          right." See *Note Evaluation::.

    argument precedence order
          n.  the order in which the arguments to a generic function are
          considered when sorting the applicable methods into precedence
          order.

    around method
          n.  a method having the qualifier :around.

    array
          n.  an object of type array, which serves as a container for
          other objects arranged in a Cartesian coordinate system.

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

    array total size
          n.  the total number of elements in an array, computed by taking
          the product of the dimensions of the array.  (The size of a
          zero-dimensional array is therefore one.)

    assign
          v.t. (a variable) to change the value of the variable in a
          binding that has already been established.  See the special
          operator setq.

    association list
          n.  a list of conses representing an association of keys with
          values, where the car of each cons is the key and the cdr is the
          value associated with that key.

    asterisk
          n.  the standard character that is variously called ``asterisk"
          or "star" (*).  See Figure~2-5.

    at-sign
          n.  the standard character that is variously called ``commercial
          at" or "at sign" (@).  See Figure~2-5.

    atom
          n.  any object that is not a cons.  "A vector is an atom."

    atomic
          adj.  being an atom.  "The number 3, the symbol foo, and nil are
          atomic."

    atomic type specifier
          n.  a type specifier that is atomic.  For every atomic type
          specifier, x, there is an equivalent compound type specifier
          with no arguments supplied, (x).

    attribute
          n. (of a character) a program-visible aspect of the character.
          The only standardized attribute of a character is its code_2,
          but implementations are permitted to have additional
          implementation-defined attributes.  See *Note 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."

    aux variable
          n.  a variable that occurs in the part of a lambda list that was
          introduced by &aux.  Unlike all other variables introduced by a
          lambda-list, aux variables are not parameters.

    auxiliary method
          n.  a member of one of two sets of methods (the set of primary
          methods is the other) that form an exhaustive partition of the
          set of methods on the method's generic function.  How these sets
          are determined is dependent on the method combination type; see
          *Note Introduction to Methods::.

B
-

    backquote
          n.  the standard character that is variously called ``grave
          accent" or "backquote" (`).  See Figure~2-5.

    backslash
          n.  the standard character that is variously called ``reverse
          solidus" or "backslash" (\).  See Figure~2-5.

    base character
          n.  a character

          of type base-char.

    base string
          n.  a string of type base-string.

    before method
          n.  a method having the qualifier :before.

    bidirectional
          adj. (of a stream) being both an input stream and an output
          stream.

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

    bind
          v.t. (a variable) to establish a binding for the variable.

    binding
          n.  an association between a name and that which the name
          denotes.  "A lexical binding is a lexical association between a
          name and its value."

    bit
          n.  an object of type bit; that is, the integer 0 or the integer
          1.

    bit array
          n.  a specialized array that is of type (array bit), and whose
          elements are of type bit.

    bit vector
          n.  a specialized vector that is of type bit-vector, and whose
          elements are of type bit.

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

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

    block tag
          n.  the symbol that, within the lexical scope of a block form,
          names the block established by that block form.  See return or
          return-from.

    boa lambda list
          n.  a lambda list that is syntactically like an ordinary lambda
          list, but that is processed in "by order of argument" style.
          See *Note Boa Lambda Lists::.

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

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

    boolean equivalent
          n. (of an object O_1) any object O_2 that has the same truth
          value as O_1 when both O_1 and O_2 are viewed as generalized
          booleans.

    bound
          adj., v.t.  1. adj. having an associated denotation in a binding.
          "The variables named by a let are bound within its body." See
          unbound.  2. adj. having a local binding which shadows_2 another.
          "The variable *print-escape* is bound while in the princ
          function." 3. v.t. the past tense of bind.

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

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

    bounding index
          n. (of a sequence with length n) either of a conceptual pair of
          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 sequence bounded by i_{start} and i_{end}.

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

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

    broadcast stream
          n.  an output stream of type broadcast-stream.

    built-in class
          n.  a class that is a generalized instance of class
          built-in-class.

    built-in type
          n.  one of the types in Figure~4-2.

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

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

C
-

    cadr
          pronounced 'ka ,de r , n. (of an object) the car of the cdr of
          that object.

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

    captured initialization form
          n.  an initialization form along with the lexical environment in
          which the form that defined the initialization form was
          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 defclass form for the new class."

    car
          n.  1. a. (of a cons) the component of a cons corresponding to
          the first argument to cons; the other component is the cdr.
          "The function rplaca modifies the car of a cons." b. (of a list)
          the first element of the list, or nil if the list is the empty
          list.  2. the object that is held in the car_1.  "The function
          car returns the car of a cons."

    case
          n. (of a character) the property of being either uppercase or
          lowercase.  Not all characters have case.  "The characters #\A
          and #\a have case, but the character #\$ has no case." See *Note
          Characters With Case:: and the function both-case-p.

    case sensitivity mode
          n.  one of the symbols :upcase, :downcase, :preserve, or :invert.

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

    catch tag
          n.  an object which names an active catch.  (If more than one
          catch is active with the same catch tag, it is only possible to
          throw to the innermost such catch because the outer one is
          shadowed_2.)

    cddr
          pronounced 'kud e ,de r  or pronounced 'ke ,dude r , n.  (of an
          object) the cdr of the cdr of that object.

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

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

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

    character code
          n.  1. one of possibly several attributes of a character.  2. a
          non-negative integer less than the value of char-code-limit that
          is suitable for use as a character code_1.

    character designator
          n.  a designator for a character; that is, an object that
          denotes a character and that is one of: a designator for a
          string of length one (denoting the character that is its only
          element),

          or a character (denoting itself).

    circular
          adj.  1. (of a list) a circular list.  2. (of an arbitrary
          object) having a component, element, constituent_2, or
          subexpression (as appropriate to the context) that is the object
          itself.

    circular list
          n.  a chain of conses that has no termination because some cons
          in the chain is the cdr of a later cons.

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

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

    class precedence list
          n.  a unique total ordering on a class and its superclasses that
          is consistent with the local precedence orders for the class and
          its superclasses.  For detailed information, see *Note
          Determining the Class Precedence List::.

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

    closed
          adj. (of a stream) having been closed (see close).  Some (but
          not all) operations that are valid on open streams are not valid
          on closed streams.  See *Note File Operations on Open and Closed
          Streams::.

    closure
          n.  a lexical closure.

    coalesce
          v.t. (literal objects that are similar) to consolidate the
          identity of those objects, such that they become the same object.
          See *Note Compiler Terminology::.

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

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

    colon
          n.  the standard character that is called "colon" (:).  See
          Figure~2-5.

    comma
          n.  the standard character that is called "comma" (,).  See
          Figure~2-5.

    compilation
          n.  the process of compiling code by the compiler.

    compilation environment
          n.  1. An environment that represents information known by the
          compiler about a form that is being compiled.  See *Note
          Compiler Terminology::.  2. An object that represents the
          compilation environment_1 and that is used as a second argument
          to a macro function (which supplies a value for any &environment
          parameter in the macro function's definition).

    compilation unit
          n.  an interval during which a single unit of compilation is
          occurring.  See the macro with-compilation-unit.

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

    compile time
          n.  the duration of time that the compiler is processing source
          code.

    compile-time definition
          n.  a definition in the compilation environment.

    compiled code
          n.  1. compiled functions.  2. code that represents compiled
          functions, such as the contents of a compiled file.

    compiled file
          n.  a file which represents the results of compiling the forms
          which appeared in a corresponding source file, and which can be
          loaded.  See the function compile-file.

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

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

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

    compiler macro expansion
          n.  1. the process of translating a form into another form by a
          compiler macro.  2. the form resulting from this process.

    compiler macro form
          n.  a function form or macro form whose operator has a
          definition as a compiler macro, or a funcall form whose first
          argument is a function form whose argument is the name of a
          function that has a definition as a compiler macro.

    compiler macro function
          n.  a function of two arguments, a form and an environment, that
          implements compiler macro expansion by producing either a form
          to be used in place of the original argument form or else nil,
          indicating that the original form should not be replaced.  See
          *Note Compiler Macros::.

    complex
          n.  an object of type complex.

    complex float
          n.  an object of type complex which has a complex part type that
          is a subtype of float.  A complex float is a complex, but it is
          not a float.

    complex part type
          n. (of a complex) 1. the type which is used to represent both
          the real part and the imaginary part of the complex.  2. the
          actual complex part type of the complex.  3. the expressed
          complex part type of the complex.

    complex rational
          n.  an object of type complex which has a complex part type that
          is a subtype of rational.  A complex rational is a complex, but
          it is not a rational.  No complex rational has an imaginary part
          of zero because such a number is always represented by Common
          Lisp as an object of type rational; see *Note Rule of Canonical
          Representation for Complex Rationals::.

    complex single float
          n.  an object of type complex which has a complex part type that
          is a subtype of single-float.  A complex single float is a
          complex, but it is not a single float.

    composite stream
          n.  a stream that is composed of one or more other streams.
          "make-synonym-stream creates a composite stream."

    compound form
          n.  a non-empty list which is a form: a special form, a lambda
          form, a macro form, or a function form.

    compound type specifier
          n.  a type specifier that is a cons; i.e., a type specifier that
          is not an atomic type specifier.  "(vector single-float) is a
          compound type specifier."

    concatenated stream
          n.  an input stream of type concatenated-stream.

    condition
          n.  1. an object which represents a situation--usually, but not
          necessarily, during signaling.  2. an object of type condition.

    condition designator
          n.  one or more objects that, taken together, denote either an
          existing condition object or a condition object to be implicitly
          created.  For details, see *Note Condition Designators::.

    condition handler
          n.  a function that might be invoked by the act of signaling,
          that receives the condition being signaled as its only argument,
          and that is permitted to handle the condition or to decline.
          See *Note Signaling::.

    condition reporter
          n.  a function that describes how a condition is to be printed
          when the Lisp printer is invoked while *print-escape* is false.
          See *Note Printing Conditions::.

    conditional newline
          n.  a point in output where a newline might be inserted at the
          discretion of the pretty printer.  There are four kinds of
          conditional newlines, called "linear-style," ``fill-style,"
          ``miser-style," and "mandatory-style." See the function
          pprint-newline and *Note Dynamic Control of the Arrangement of
          Output::.

    conformance
          n.  a state achieved by proper and complete adherence to the
          requirements of this specification.  See *Note Conformance::.

    conforming code
          n.  code that is all of part of a conforming program.

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

    conforming processor
          n. ANSI a conforming implementation.

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

    congruent
          n.  conforming to the rules of lambda list congruency, as
          detailed in *Note Congruent Lambda-lists for all Methods of a
          Generic Function::.

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

    constant
          n.  1. a constant form.  2. a constant variable.  3. a constant
          object.  4. a self-evaluating object.

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

    constant object
          n.  an object that is constrained (e.g., by its context in a
          program or by the source from which it was obtained) to be
          immutable.  "A literal object that has been processed by
          compile-file is a constant object."

    constant variable
          n.  a variable, the value of which can never change; that is, a
          keyword_1 or a named constant.  "The symbols t, nil, :direction,
          and most-positive-fixnum are constant variables."

    constituent
          n., adj.  1. a. n. the syntax type of a character that is part
          of a token.  For details, see *Note Constituent Characters::.
          b. adj. (of a character) having the constituent_{1a} syntax
          type_2.  c. n. a constituent_{1b} character.  2. n. (of a
          composite stream) one of possibly several objects that
          collectively comprise the source or sink of that stream.

    constituent trait
          n. (of a character) one of several classifications of a
          constituent character in a readtable.  See *Note Constituent
          Characters::.

    constructed stream
          n.  a stream whose source or sink is a Lisp object.  Note that
          since a stream is another Lisp object, composite streams are
          considered constructed streams.  "A string stream is a
          constructed stream."

    contagion
          n.  a process whereby operations on objects of differing types
          (e.g., arithmetic on mixed types of numbers) produce a result
          whose type is controlled by the dominance of one argument's type
          over the types of the other arguments.  See *Note Contagion in
          Numeric Operations::.

    continuable
          n. (of an error) an error that is correctable by the continue
          restart.

    control form
          n.  1. a form that establishes one or more places to which
          control can be transferred.  2. a form that transfers control.

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

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

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

    correctable
          adj. (of an error) 1. (by a restart other than abort that has
          been associated with the error) capable of being corrected by
          invoking that restart.  "The function cerror signals an error
          that is correctable by the continue restart."

          (Note that correctability is not a property of an error object,
          but rather a property of the dynamic environment that is in
          effect when the error is signaled.  Specifically, the restart is
          "associated with" the error condition object.  See *Note
          Associating a Restart with a Condition::.)

          2. (when no specific restart is mentioned) correctable_1 by at
          least one restart.  "import signals a correctable error of type
          package-error if any of the imported symbols has the same name as
          some distinct symbol already accessible in the package."

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

    current logical block
          n.  the context of the innermost lexically enclosing use of
          pprint-logical-block.

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

    current package
          n. (in a dynamic environment) the package that is the value of
          *package* in that environment, and that is the default package
          employed by the Lisp reader and Lisp printer, and their related
          functions.

    current pprint dispatch table
          n. (in a dynamic environment) the pprint dispatch table that is
          the value of *print-pprint-dispatch* in that environment, and
          that is the default pprint dispatch table employed by the pretty
          printer.

    current random state
          n. (in a dynamic environment) the random state that is the value
          of *random-state* in that environment, and that is the default
          random state employed by random.

    current readtable
          n. (in a dynamic environment) the readtable that is the value of
          *readtable* in that environment, and that affects the way in
          which expressions_2 are parsed into objects by the Lisp reader.

D
-

    data type
          n. Trad.  a type.

    debug I/O
          n.  the bidirectional stream that is the value of the variable
          *debug-io*.

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

    declaration
          n.  a global declaration or local declaration.

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

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

    declare
          v.  to establish a declaration.  See declare, declaim, or
          proclaim.

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

    decoded time
          n.  absolute time, represented as an ordered series of nine
          objects which, taken together, form a description of a point in
          calendar time, accurate to the nearest second (except that leap
          seconds are ignored).  See *Note Decoded Time::.

    default method
          n.  a method having no parameter specializers other than the
          class t.  Such a method is always an applicable method but might
          be shadowed_2 by a more specific method.

    defaulted initialization argument list
          n.  a list of alternating initialization argument names and
          values in which unsupplied initialization arguments are
          defaulted, used in the protocol for initializing and
          reinitializing instances of classes.

    define-method-combination arguments lambda list
          n.  a lambda list used by the :arguments option to
          define-method-combination.  See *Note Define-method-combination
          Arguments Lambda Lists::.

    define-modify-macro lambda list
          n.  a lambda list used by define-modify-macro.  See *Note
          Define-modify-macro Lambda Lists::.

    defined name
          n.  a symbol the meaning of which is defined by Common Lisp.

    defining form
          n.  a form that has the side-effect of establishing a definition.
          "defun and defparameter are defining forms."

    defsetf lambda list
          n.  a lambda list that is like an ordinary lambda list except
          that it does not permit &aux and that it permits use of
          &environment.  See *Note Defsetf Lambda Lists::.

    deftype lambda list
          n.  a lambda list that is like a macro lambda list except that
          the default value for unsupplied optional parameters and keyword
          parameters is the symbol * (rather than nil).  See *Note Deftype
          Lambda Lists::.

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

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

    derived type specifier
          n.  a type specifier for a derived type.

    designator
          n.  an object that denotes another object.  In the dictionary
          entry for an operator if a parameter is described as a
          designator for a type, the description of the operator is
          written in a way that assumes that appropriate coercion to that
          type has already occurred; that is, that the parameter is
          already of the denoted type.  For more detailed information, see
          *Note Designators::.

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

    destructuring lambda list
          n.  an extended lambda list used in destructuring-bind and
          nested within macro lambda lists.  See *Note Destructuring
          Lambda Lists::.

    different
          adj.  not the same "The strings "FOO" and "foo" are different
          under equal but not under equalp."

    digit
          n. (in a radix) a character that is among the possible digits (0
          to 9, A to Z, and a to z) and that is defined to have an
          associated numeric weight as a digit in that radix.  See *Note
          Digits in a Radix::.

    dimension
          n.  1. a non-negative integer indicating the number of objects
          an array can hold along one axis.  If the array is a vector with
          a fill pointer, the fill pointer is ignored.  "The second
          dimension of that array is 7." 2. an axis of an array.  "This
          array has six dimensions."

    direct instance
          n. (of a class C) an object whose class is C itself, rather than
          some subclass of C.  "The function make-instance always returns a
          direct instance of the class which is (or is named by) its first
          argument."

    direct subclass
          n. (of a class C_1) a class C_2, such that C_1 is a direct
          superclass of C_2.

    direct superclass
          n. (of a class C_1) a class C_2 which was explicitly designated
          as a superclass of C_1 in the definition of C_1.

    disestablish
          v.t.  to withdraw the establishment of an object, a  binding, an
          exit point, a  tag, a  handler, a  restart, or an environment.

    disjoint
          n. (of types) having no elements in common.

    dispatching macro character
          n.  a macro character that has an associated table that specifies
          the function to be called for each character that is seen
          following the dispatching macro character.  See the function
          make-dispatch-macro-character.

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

    distinct
          adj.  not identical.

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

    dot
          n.  the standard character that is variously called ``full stop,"
          ``period," or "dot" (.).  See Figure~2-5.

    dotted list
          n.  a list which has a terminating atom that is not nil.  (An
          atom by itself is not a dotted list, however.)

    dotted pair
          n.  1. a cons whose cdr is a non-list.  2. any cons, used to
          emphasize the use of the cons as a symmetric data pair.

    double float
          n.  an object of type double-float.

    double-quote
          n.  the standard character that is variously called ``quotation
          mark" or "double quote" (").  See Figure~2-5.

    dynamic binding
          n.  a binding in a dynamic environment.

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

    dynamic extent
          n.  an extent whose duration is bounded by points of
          establishment and disestablishment within the execution of a
          particular form.  See indefinite extent.  "Dynamic variable
          bindings have dynamic extent."

    dynamic scope
          n.  indefinite scope along with dynamic extent.

    dynamic variable
          n.  a variable the binding for which is in the dynamic
          environment.  See special.

E
-

    echo stream
          n.  a stream of type echo-stream.

    effective method
          n.  the combination of applicable methods that are executed when
          a generic function is invoked with a particular sequence of
          arguments.

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

    element type
          n.  1. (of an array) the array element type of the array.  2.
          (of a stream) the stream element type of the stream.

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

    empty list
          n.  the list containing no elements. See ().

    empty type
          n.  the type that contains no elements, and that is a subtype of
          all types (including itself).  See nil.

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

    environment
          n.  1. a set of bindings. See *Note Introduction to
          Environments::.  2. an environment object.  "macroexpand takes
          an optional environment argument."

    environment object
          n.  an object representing a set of lexical bindings, used in
          the processing of a form to provide meanings for names within
          that form.  "macroexpand takes an optional environment argument."
          (The object nil when used as an environment object denotes the
          null lexical environment; the values of environment parameters
          to macro functions are objects of implementation-dependent
          nature which represent the environment_1 in which the
          corresponding macro form is to be expanded.) See *Note
          Environment Objects::.

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

    error
          n.  1. (only in the phrase "is an error") a situation in which
          the semantics of a program are not specified, and in which the
          consequences are undefined.  2. a condition which represents an
          error situation.  See *Note Error Terminology::.  3. an object
          of type error.

    error output
          n.  the output stream which is the value of the dynamic variable
          *error-output*.

    escape
          n., adj.  1. n. a single escape or a multiple escape.  2. adj.
          single escape or multiple escape.

    establish
          v.t.  to build or bring into being a  binding, a  declaration,
          an exit point, a  tag, a  handler, a restart, or an environment.
          "let establishes lexical bindings."

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

    evaluation
          n.  a model whereby forms are executed, returning zero or more
          values.  Such execution might be implemented directly in one
          step by an interpreter or in two steps by first compiling the
          form and then executing the compiled code; this choice is
          dependent both on context and the nature of the implementation,
          but in any case is not in general detectable by any program.
          The evaluation model is designed in such a way that a conforming
          implementation might legitimately have only a compiler and no
          interpreter, or vice versa.  See *Note The Evaluation Model::.

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

    execute
          v.t. Trad. (code) to perform the imperative actions represented
          by the code.

    execution time
          n.  the duration of time that compiled code is being executed.

    exhaustive partition
          n. (of a type) a set of pairwise disjoint types that form an
          exhaustive union.

    exhaustive union
          n. (of a type) a set of subtypes of the type, whose union
          contains all elements of that type.

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

    explicit return
          n.  the act of transferring control (and possibly values) to a
          block by using return-from (or return).

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

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

            Marker  Meaning                                  
            D or d  double-float                             
            E or e  float (see *read-default-float-format*)  
            F or f  single-float                             
            L or l  long-float                               
            S or s  short-float                              

                     Figure 26-1: Exponent Markers          


    export
          v.t. (a symbol in a package) to add the symbol to the list of
          external symbols of the package.

    exported
          adj. (of a symbol in a package) being an external symbol of the
          package.

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

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

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

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

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

    extended character
          n.  a character

          of type extended-char:

          a character that is not a base character.

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

    extended lambda list
          n.  a list resembling an ordinary lambda list in form and
          purpose, but offering additional syntax or functionality not
          available in an ordinary lambda list.  "defmacro uses extended
          lambda lists."

    extension
          n.  a facility in an implementation of Common Lisp that is not
          specified by this standard.

    extent
          n.  the interval of time during which a reference to an object,
          a  binding, an exit point, a  tag, a  handler, a  restart, or an
          environment is defined.

    external file format
          n.  an object of implementation-dependent nature which determines
          one of possibly several implementation-dependent ways in which
          characters are encoded externally in a character file.

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

    external symbol
          n. (of a package) a symbol that is part of the `external
          interface' to the package and that are inherited_3 by any other
          package that uses the package.  When using the Lisp reader, if a
          package prefix is used, the name of an external symbol is
          separated from the package name by a single package marker while
          the name of an internal symbol is separated from the package
          name by a double package marker; see *Note Symbols as Tokens::.

    externalizable object
          n.  an object that can be used as a literal object in code to be
          processed by the file compiler.

F
-

    false
          n.  the symbol nil, used to represent the failure of a predicate
          test.

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

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

          See the functions fboundp and symbol-function.

    feature
          n.  1. an aspect or attribute of Common Lisp, of the
          implementation, or of the environment.  2. a symbol that names a
          feature_1.  See *Note Features::.  "The :ansi-cl feature is
          present in all conforming implementations."

    feature expression
          n.  A boolean combination of features used by the #+ and #-
          reader macros in order to direct conditional reading of
          expressions by the Lisp reader.  See *Note Feature Expressions::.

    features list
          n.  the list that is the value of *features*.

    file
          n.  a named entry in a file system, having an
          implementation-defined nature.

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

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

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

    file stream
          n.  an object of type file-stream.

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

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

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

    finite
          adj. (of a type) having a finite number of elements.  "The type
          specifier (integer 0 5) denotes a finite type, but the type
          specifiers integer and (integer 0) do not."

    fixnum
          n.  an integer of type fixnum.

    float
          n.  an object of type float.

    for-value
          adj. (of a reference to a binding) being a reference that reads_1
          the value of the binding.

    form
          n.  1. any object meant to be evaluated.  2.    a symbol, a
          compound form, or a self-evaluating object.  3. (for an
          operator, as in "<<operator>> form") a compound form having that
          operator as its first element.  "A quote form is a constant
          form."

    formal argument
          n. Trad.  a parameter.

    formal parameter
          n. Trad.  a parameter.

    format
          v.t. (a format control and format arguments) to perform output
          as if by format, using the format string and format arguments.

    format argument
          n.  an object which is used as data by functions such as format
          which interpret format controls.

    format control
          n.  a format string, or a function that obeys the argument
          conventions for a function returned by the formatter macro.  See
          *Note Compiling Format Strings::.

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

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

    free declaration
          n.  a declaration that is not a bound declaration.  See declare.

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

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

    funbound
          pronounced 'ef unbaund n. (of a function name) not fbound.

    function
          n.

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

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

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

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

    function form
          n.  a form that is a list and that has a first element which is
          the name of a function to be called on arguments which are the
          result of evaluating subsequent elements of the function form.

    function name
          n. (in an environment) A symbol or a list (setf symbol) that is
          the name of a function in that environment.

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

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

    further compilation
          n.  implementation-dependent compilation beyond minimal
          compilation.  Further compilation is permitted to take place at
          run time.  "Block compilation and generation of machine-specific
          instructions are examples of further compilation."

G
-

    general
          adj. (of an array) having element type t, and consequently able
          to have any object as an element.

    generalized boolean
          n.  an object used as a truth value, where the symbol~nil
          represents false and all other objects represent true.  See
          boolean.

    generalized instance
          n. (of a class) an object the class of which is either that
          class itself, or some subclass of that 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 class (or class name) the reverse is also true.  The former
          terminology emphasizes the view of X as a class while the latter
          emphasizes the view of X as a type specifier.)

    generalized reference
          n.  a reference to a location storing an object as if to a
          variable.  (Such a reference can be either to read or write the
          location.) See *Note Generalized Reference::.  See also place.

    generalized synonym stream
          n. (with a synonym stream symbol) 1. (to a stream) a synonym
          stream to the stream, or a composite stream which has as a target
          a generalized synonym stream to the stream.  2. (to a symbol) a
          synonym stream to the symbol, or a composite stream which has as
          a target a generalized synonym stream to the symbol.

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

    generic function lambda list
          n.  A lambda list that is used to describe data flow into a
          generic function.  See *Note Generic Function Lambda Lists::.

    gensym
          n. Trad.  an uninterned symbol.  See the function gensym.

    global declaration
          n.  a form that makes certain kinds of information about code
          globally available; that is, a proclaim form or a declaim form.

    global environment
          n.  that part of an environment that contains bindings with
          indefinite scope and indefinite extent.

    global variable
          n.  a dynamic variable or a constant variable.

    glyph
          n.  a visual representation.  "Graphic characters have
          associated glyphs."

    go
          v.  to transfer control to a go point.  See the special operator
          go.

    go point
          one of possibly several exit points that are established by
          tagbody (or other abstractions, such as prog, which are built
          from tagbody).

    go tag
          n.  the symbol or integer that, within the lexical scope of a
          tagbody form, names an exit point established by that tagbody
          form.

    graphic
          adj. (of a character) being a "printing" or "displayable"
          character that has a standard visual representation as a single
          glyph, such as A or * or =.  Space is defined to be graphic.  Of
          the standard characters, all but newline are graphic.  See
          non-graphic.

H
-

    handle
          v. (of a condition being signaled) to perform a non-local
          transfer of control, terminating the ongoing signaling of the
          condition.

    handler
          n.

          a condition handler.

    hash table
          n.  an object of type hash-table, which provides a mapping from
          keys to values.

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

I
-

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

            *debug-io*        *error-io*         query-io*       
            *standard-input*  *standard-output*  *trace-output*  

            Figure 26-2: Standardized I/O Customization Variables


    identical
          adj.  the same under eq.

    identifier
          n.  1. a symbol used to identify or to distinguish names.  2. a
          string used the same way.

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

    implementation
          n.  a system, mechanism, or body of code that implements the
          semantics of Common Lisp.

    implementation limit
          n.  a restriction imposed by an implementation.

    implementation-defined
          adj.  implementation-dependent, but required by this
          specification to be defined by each conforming implementation
          and to be documented by the corresponding implementor.

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

    implementation-independent
          adj.  used to identify or emphasize a behavior or aspect of
          Common Lisp which does not vary between conforming
          implementations.

    implicit block
          n.  a block introduced by a macro form rather than by an
          explicit block form.

    implicit compilation
          n.  compilation performed during evaluation.

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

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

    import
          v.t. (a symbol into a package) to make the symbol be present in
          the package.

    improper list
          n.  a list which is not a proper list: a circular list or a
          dotted list.

    inaccessible
          adj.  not accessible.

    indefinite extent
          n.  an extent whose duration is unlimited.  "Most Common Lisp
          objects have indefinite extent."

    indefinite scope
          n.  scope that is unlimited.

    indicator
          n.  a property indicator.

    indirect instance
          n. (of a class C_1) an object of class C_2, where C_2 is a
          subclass of C_1.  "An integer is an indirect instance of the
          class number."

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

    initial pprint dispatch table
          n.  the value of *print-pprint-dispatch* at the time the Lisp
          image is started.

    initial readtable
          n.  the value of *readtable* at the time the Lisp image is
          started.

    initialization argument list
          n.  a property list of initialization argument names and values
          used in the protocol for initializing and reinitializing
          instances of classes.  See *Note Object Creation and
          Initialization::.

    initialization form
          n.  a form used to supply the initial value for a slot or
          variable.  "The initialization form for a slot in a defclass form
          is introduced by the keyword :initform."

    input
          adj. (of a stream) supporting input operations (i.e., being a
          "data source").  An input stream might also be an output stream,
          in which case it is sometimes called a bidirectional stream.
          See the function input-stream-p.

    instance
          n.  1. a direct instance.  2. a generalized instance.  3. an
          indirect instance.

    integer
          n.  an object of type integer, which represents a mathematical
          integer.

    interactive stream
          n.  a stream on which it makes sense to perform interactive
          querying.  See *Note Interactive Streams::.

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

    internal symbol
          n. (of a package) a symbol which is accessible in the package,
          but which is not an external symbol of the package.

    internal time
          n.  time, represented as an integer number of internal time
          units.  Absolute internal time is measured as an offset from an
          arbitrarily chosen, implementation-dependent base.  See *Note
          Internal Time::.

    internal time unit
          n.  a unit of time equal to 1/n of a second, for some
          implementation-defined integer value of n.  See the variable
          internal-time-units-per-second.

    interned
          adj. Trad.  1. (of a symbol) accessible_3 in any package.  2.
          (of a symbol in a specific package) present in that package.

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

    interpreted implementation
          n.  an implementation that uses an execution strategy for
          interpreted functions that does not involve a one-time semantic
          analysis pre-pass, and instead uses "lazy" (and sometimes
          repetitious) semantic analysis of forms as they are encountered
          during execution.

    interval designator
          n. (of type T) an ordered pair of objects that describe a
          subtype of T by delimiting an interval on the real number line.
          See *Note Interval Designators::.

    invalid
          n., adj.  1. n.  a possible constituent trait of a character
          which if present signifies that the character cannot ever appear
          in a token except under the control of a single escape character.
          For details, see *Note Constituent Characters::.  2. adj. (of a
          character) being a character that has syntax type constituent in
          the current readtable and that has the constituent trait
          invalid_1.  See Figure~2-8.

    iteration form
          n.  a compound form whose operator is named in Figure 26-3, or a
          compound form that has an implementation-defined operator and
          that is defined by the implementation to be an iteration form.

            do              do-external-symbols  dotimes  
            do*             do-symbols           loop     
            do-all-symbols  dolist                        

              Figure 26-3: Standardized Iteration Forms  


    iteration variable
          n.  a variable V, the binding for which was created by an
          explicit use of V in an iteration form.

K
-

    key
          n.  an object used for selection during retrieval.  See
          association list, property list, and hash table.  Also, see
          *Note Sequence Concepts::.

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

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

    keyword/value pair
          n.  two successive elements (a keyword and a value,
          respectively) of a property list.

L
-

    lambda combination
          n. Trad.  a lambda form.

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

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

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

    lambda list keyword
          n.  a symbol whose name begins with ampersand and that is
          specially recognized in a lambda list.  Note that no
          standardized lambda list keyword is in the KEYWORD package.

    lambda variable
          n.  a formal parameter, used to emphasize the variable's
          relation to the lambda list that established it.

    leaf
          n.  1. an atom in a tree_1.  2. a terminal node of a tree_2.

    leap seconds
          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 Common
          Lisp time representations ignore leap seconds; every day is
          assumed to be exactly 86400 seconds long.

    left-parenthesis
          n.  the standard character "(", that is variously called ``left
          parenthesis" or "open parenthesis" See Figure~2-5.

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

    lexical binding
          n.  a binding in a lexical environment.

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

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

    lexical scope
          n.  scope that is limited to a spatial or textual region within
          the establishing form.  "The names of parameters to a function
          normally are lexically scoped."

    lexical variable
          n.  a variable the binding for which is in the lexical
          environment.

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

    Lisp printer
          n. Trad.  the procedure that prints the character representation
          of an object onto a stream. (This procedure is implemented by
          the function write.)

    Lisp read-eval-print loop
          n. Trad.  an endless loop that reads_2 a form, evaluates it, and
          prints (i.e., writes_2) the results.  In many implementations,
          the default mode of interaction with Common Lisp during program
          development is through such a loop.

    Lisp reader
          n. Trad.  the procedure that parses character representations of
          objects from a stream, producing objects.  (This procedure is
          implemented by the function read.)

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

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

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

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

    load
          v.t. (a file) to cause the code contained in the file to be
          executed.  See the function load.

    load time
          n.  the duration of time that the loader is loading compiled
          code.

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

    loader
          n.  a facility that is part of Lisp and that loads a file.  See
          the function load.

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

    local precedence order
          n. (of a class) a list consisting of the class followed by its
          direct superclasses in the order mentioned in the defining form
          for the class.

    local slot
          n. (of a class) a slot accessible in only one instance, namely
          the instance in which the slot is allocated.

    logical block
          n.  a conceptual grouping of related output used by the pretty
          printer.  See the macro pprint-logical-block and *Note Dynamic
          Control of the Arrangement of Output::.

    logical host
          n.  an object of implementation-dependent nature that is used as
          the representation of a "host" in a logical pathname, and that
          has an associated set of translation rules for converting
          logical pathnames belonging to that host into physical pathnames.
          See *Note Logical Pathnames::.

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

    logical pathname
          n.  an object of type logical-pathname.

    long float
          n.  an object of type long-float.

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

    lowercase
          adj. (of a character) being among standard characters
          corresponding to the small letters a through z, or being some
          other implementation-defined character that is defined by the
          implementation to be lowercase.  See *Note Characters With
          Case::.

M
-

    macro
          n.  1. a macro form 2. a macro function.  3. a macro name.

    macro character
          n.  a character which, when encountered by the Lisp reader in
          its main dispatch loop, introduces a reader macro_1.  (Macro
          characters have nothing to do with macros.)

    macro expansion
          n.  1. the process of translating a macro form into another form.
          2. the form resulting from this process.

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

    macro function
          n.  a function of two arguments, a form and an environment, that
          implements macro expansion by producing a form to be evaluated
          in place of the original argument form.

    macro lambda list
          n.  an extended lambda list used in forms that establish macro
          definitions, such as defmacro and macrolet.  See *Note Macro
          Lambda Lists::.

    macro name
          n.  a name for which macro-function returns true and which when
          used as the first element of a compound form identifies that
          form as a macro form.

    macroexpand hook
          n.  the function that is the value of *macroexpand-hook*.

    mapping
          n.  1. a type of iteration in which a function is successively
          applied to objects taken from corresponding entries in
          collections such as sequences or hash tables.  2. 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").

    metaclass
          n.  1. a class whose instances are classes.  2. (of an object)
          the class of the class of the object.

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

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

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

    method-defining form
          n.  a form that defines a method for a generic function, whether
          explicitly or implicitly.  See *Note Introduction to Generic
          Functions::.

    method-defining operator
          n.  an operator corresponding to a method-defining form.  See
          Figure~7-1.

    minimal compilation
          n.  actions the compiler must take at compile time.  See *Note
          Compilation Semantics::.

    modified lambda list
          n.  a list resembling an ordinary lambda list in form and
          purpose, but which deviates in syntax or functionality from the
          definition of an ordinary lambda list.  See ordinary lambda list.
          "deftype uses a modified lambda list."

    most recent
          adj.  innermost; that is, having been established (and not yet
          disestablished) more recently than any other of its kind.

    multiple escape
          n., adj.  1. n. the syntax type of a character that is used in
          pairs  to indicate that the enclosed characters are to be
          treated as alphabetic_2 characters with their case preserved.
          For details, see *Note Multiple Escape Characters::.  2. adj.
          (of a character) having the multiple escape syntax type.  3. n.
          a multiple escape_2 character.  (In the standard readtable,
          vertical-bar is a multiple escape character.)

    multiple values
          n.  1. more than one value.  "The function truncate returns
          multiple values." 2. a variable number of values, possibly
          including zero or one.  "The function values returns multiple
          values." 3. a fixed number of values other than one.  "The macro
          multiple-value-bind is among the few operators in Common Lisp
          which can detect and manipulate multiple values."

N
-

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

    named constant
          n.  a variable that is defined by Common Lisp, by the
          implementation, or by user code (see the macro defconstant) to
          always yield the same value when evaluated.  "The value of a
          named constant may not be changed by assignment or by binding."

    namespace
          n.  1. bindings whose denotations are restricted to a particular
          kind.  "The bindings of names to tags is the tag namespace." 2.
          any mapping whose domain is a set of names.  "A package defines
          a namespace."

    namestring
          n.  a string that represents a filename using either the
          standardized notation for naming logical pathnames described in
          *Note Syntax of Logical Pathname Namestrings::, or some
          implementation-defined notation for naming a physical pathname.

    newline
          n.  the standard character <Newline>, notated for the Lisp
          reader as #\Newline.

    next method
          n.  the next method to be invoked with respect to a given method
          for a particular set of arguments or argument classes.  See
          *Note Applying method combination to the sorted list of
          applicable methods::.

    nickname
          n. (of a package) one of possibly several names that can be used
          to refer to the package but that is not the primary name of the
          package.

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

    non-atomic
          adj.  being other than an atom; i.e., being a cons.

    non-constant variable
          n.  a variable that is not a constant variable.

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

    non-empty
          adj.  having at least one element.

    non-generic function
          n.  a function that is not a generic function.

    non-graphic
          adj. (of a character) not graphic.  See *Note Graphic
          Characters::.

    non-list
          n., adj.  other than a list; i.e., a non-nil atom.

    non-local exit
          n.  a transfer of control (and sometimes values) to an exit
          point for reasons other than a normal return.  "The operators
          go, throw, and return-from cause a non-local exit."

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

    non-null lexical environment
          n.  a lexical environment that has additional information not
          present in the global environment, such as one or more bindings.

    non-simple
          adj.  not simple.

    non-terminating
          adj. (of a macro character) being such that it is treated as a
          constituent character when it appears in the middle of an
          extended token.  See *Note Reader Algorithm::.

    non-top-level form
          n.  a form that, by virtue of its position as a subform of
          another form, is not a top level form.  See *Note Processing of
          Top Level Forms::.

    normal return
          n.  the natural transfer of control and values which occurs after
          the complete execution of a form.

    normalized
          adj., ANSI, IEEE (of a float) conforming to the description of
          "normalized" as described by IEEE Standard for Binary
          Floating-Point Arithmetic.  See denormalized.

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

    null lexical environment
          n.  the lexical environment which has no bindings.

    number
          n.  an object of type number.

    numeric
          adj. (of a character) being one of the standard characters 0
          through 9, or being some other graphic character defined by the
          implementation to be numeric.

O
-

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

    object-traversing
          adj.  operating in succession on components of an object.  "The
          operators mapcar, maphash, with-package-iterator and count
          perform object-traversing operations."

    open
          adj., v.t. (a file) 1. v.t. to create and return a stream to the
          file.  2. adj. (of a stream) having been opened_1, but not yet
          closed.

    operator
          n.  1. a function, macro, or special operator.  2. a symbol that
          names such a function, macro, or special operator.  3. (in a
          function special form) the cadr of the function special form,
          which might be either an operator_2 or a lambda expression.  4.
          (of a compound form) the car of the compound form, which might be
          either an operator_2 or a lambda expression, and which is never
          (setf symbol).

    optimize quality
          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 optimize
          declaration.  The standardized optimize qualities are
          compilation-speed (speed of the compilation process),

          debug (ease of debugging),

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

    optional parameter
          n.  A parameter for which a corresponding positional argument is
          optional.  If the argument is not supplied, a default value is
          used.  See also supplied-p parameter.

    ordinary function
          n.  a function that is not a generic function.

    ordinary lambda list
          n.  the kind of lambda list used by lambda.  See modified lambda
          list and extended lambda list.  "defun uses an ordinary lambda
          list."

    otherwise inaccessible part
          n. (of an object, O_1) an object, O_2, which would be made
          inaccessible if O_1 were made inaccessible.  (Every object is an
          otherwise inaccessible part of itself.)

    output
          adj. (of a stream) supporting output operations (i.e., being a
          "data sink").  An output stream might also be an input stream,
          in which case it is sometimes called a bidirectional stream.
          See the function output-stream-p.

P
-

    package
          n.  an object of type package.

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

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

    package marker
          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 colon in the standard readtable.  See *Note Character
          Syntax::.

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

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

    pairwise
          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."

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

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

    parameter specializer
          n.  1. (of a method) an expression which constrains the method
          to be applicable only to argument sequences in which the
          corresponding argument matches the parameter specializer.  2. a
          class, or a list (eql object).

    parameter specializer name
          n.  1. (of a method definition) an expression used in code to
          name a parameter specializer.  See *Note Introduction to
          Methods::.  2. a class,

          a symbol naming a class,

          or a list (eql form).

    pathname
          n.  an object of type pathname, which is a structured
          representation of the name of a file.  A pathname has six
          components: a "host," a "device," a "directory," a "name," a
          "type," and a "version."

    pathname designator
          n.  a designator for a pathname; that is, an object that denotes
          a pathname and that is one of:

          a pathname namestring

          (denoting the corresponding pathname),

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

    physical pathname
          n.  a pathname that is not a 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.]

    place
          n.  1. a form which is suitable for use as a generalized
          reference.  2. the conceptual location referred to by such a
          place_1.

    plist
          pronounced 'p\=e ,list  n.  a property list.

    portable
          adj. (of code) required to produce equivalent results and
          observable side effects in all conforming implementations.

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

    potential number
          n.  A textual notation that might be parsed by the Lisp reader
          in some conforming implementation as a number but is not
          required to be parsed as a number.  No object is a potential
          number--either an object is a number or it is not.  See *Note
          Potential Numbers as Tokens::.

    pprint dispatch table
          n.  an object that can be the value of *print-pprint-dispatch*
          and hence can control how objects are printed when
          *print-pretty* is true.  See *Note Pretty Print Dispatch
          Tables::.

    predicate
          n.  a function that returns a generalized boolean as its first
          value.

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

    pretty print
          v.t. (an object) to invoke the pretty printer on the object.

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

    pretty printing stream
          n.  a stream that does pretty printing.  Such streams are
          created by the function pprint-logical-block as a link between
          the output stream and the logical block.

    primary method
          n.  a member of one of two sets of methods (the set of auxiliary
          methods is the other) that form an exhaustive partition of the
          set of methods on the method's generic function.  How these sets
          are determined is dependent on the method combination type; see
          *Note Introduction to Methods::.

    primary value
          n. (of values resulting from the evaluation of a form) the first
          value, if any, or else nil if there are no values.  "The primary
          value returned by truncate is an integer quotient, truncated
          toward zero."

    principal
          adj. (of a value returned by a Common Lisp 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 value which the
          corresponding Common Lisp function has been defined to return.

    print name
          n. Trad. (usually of a symbol) a name_3.

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

    printer escaping
          n.  The combined state of the printer control variables
          *print-escape* and *print-readably*.  If the value of either
          *print-readably* or *print-escape* is true, then printer escaping
          is "enabled"; otherwise (if the values of both *print-readably*
          and *print-escape* are false), then printer escaping is
          "disabled".

    printing
          adj. (of a character) being a graphic character other than space.

    process
          v.t. (a form by the compiler) to perform minimal compilation,
          determining the time of evaluation for a form, and possibly
          evaluating that form (if required).

    processor
          n., ANSI an implementation.

    proclaim
          v.t. (a proclamation) to establish that proclamation.

    proclamation
          n.  a global declaration.

    prog tag
          n. Trad.  a go tag.

    program
          n. Trad.  Common Lisp code.

    programmer
          n.  an active entity, typically a human, that writes a program,
          and that might or might not also be a user of the program.

    programmer code
          n.  code that is supplied by the programmer; that is, code that
          is not system code.

    proper list
          n.  A list terminated by the empty list.  (The empty list is a
          proper list.) See improper list.

    proper name
          n. (of a class) a symbol that names the class whose name is that
          symbol.  See the functions class-name and find-class.

    proper sequence
          n.  a sequence which is not an improper list; that is, a vector
          or a proper list.

    proper subtype
          n. (of a type) a subtype of the type which is not the same type
          as the type (i.e., its elements are a "proper subset" of the
          type).

    property
          n. (of a property list) 1. a conceptual pairing of a property
          indicator and its associated property value on a property list.
          2. a property value.

    property indicator
          n. (of a property list) the name part of a property, used as a
          key when looking up a property value on a property list.

    property list
          n.

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

          2. (of a symbol) the component of the symbol containing a
          property list.

    property value
          n. (of a property indicator on a property list) the object
          associated with the property indicator on the property list.

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

Q
-

    qualified method
          n.  a method that has one or more qualifiers.

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

    query I/O
          n.  the bidirectional stream that is the value of the variable
          *query-io*.

    quoted object
          n.  an object which is the second element of a quote form.

R
-

    radix
          n.  an 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 radix n, and those digits are the first
          n digits in the sequence 0, 1, ..., 9, A, B, ..., Z, which have
          the weights 0, 1, ..., 9, 10, 11, ..., 35, respectively.  Case
          is not significant in parsing numbers of radix greater than 10,
          so "9b8a" and "9B8A" denote the same radix 16 number.)

    random state
          n.  an object of type random-state.

    rank
          n.  a non-negative integer indicating the number of dimensions
          of an array.

    ratio
          n.  an object of type ratio.

    ratio marker
          n.  a character which is used in the textual notation for a ratio
          to separate the numerator from the denominator, and which is
          slash in the standard readtable.  See *Note Character Syntax::.

    rational
          n.  an object of type rational.

    read
          v.t.

          1. (a binding or slot or component) to obtain the value of the
          binding or slot.

          2. (an object from a stream) to parse an object from its
          representation on the stream.

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

    reader
          n.  1. a function that reads_1 a variable or slot.  2. the Lisp
          reader.

    reader macro
          n.  1. a textual notation introduced by dispatch on one or two
          characters that defines special-purpose syntax for use by the
          Lisp reader, and that is implemented by a reader macro function.
          See *Note Reader Algorithm::.  2. the character or characters
          that introduce a reader macro_1; that is, a macro character or
          the conceptual pairing of a dispatching macro character and the
          character that follows it.  (A reader macro is not a kind of
          macro.)

    reader macro function
          n.  a function designator that denotes a function that
          implements a reader macro_2.  See the functions
          set-macro-character and set-dispatch-macro-character.

    readtable
          n.  an object of type readtable.

    readtable case
          n.  an attribute of a readtable whose value is a case
          sensitivity mode, and that selects the manner in which characters
          in a symbol's name are to be treated by the Lisp reader and the
          Lisp printer.  See *Note Effect of Readtable Case on the Lisp
          Reader:: and *Note Effect of Readtable Case on the Lisp
          Printer::.

    readtable designator
          n.  a designator for a readtable; that is, an object that
          denotes a readtable and that is one of: nil (denoting the
          standard readtable), or a readtable (denoting itself).

    recognizable subtype
          n. (of a type) a subtype of the type which can be reliably
          detected to be such by the implementation.  See the function
          subtypep.

    reference
          n., v.t.  1. n. an act or occurrence of referring to an object,
          a binding, an exit point, a tag, or an environment.  2. v.t. to
          refer to an object, a binding, an exit point, a tag, or an
          environment, usually by name.

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

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

    repertoire
          n., ISO a subtype of character.  See *Note Character
          Repertoires::.

    report
          n. (of a condition) to call the function print-object on the
          condition in an environment where the value of *print-escape* is
          false.

    report message
          n.  the text that is output by a condition reporter.

    required parameter
          n.  A parameter for which a corresponding positional argument
          must be supplied when calling the function.

    rest list
          n. (of a function having a rest parameter) The list to which the
          rest parameter is bound on some particular call to the function.

    rest parameter
          n.  A parameter which was introduced by &rest.

    restart
          n.  an object of type restart.

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

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

            abort     muffle-warning  use-value  
            continue  store-value                

            Figure 26-4: Standardized Restart Functions


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

    return value
          n. Trad.  a value_1

    right-parenthesis
          n.  the standard character ")", that is variously called ``right
          parenthesis" or "close parenthesis" See Figure~2-5.

    run time
          n.  1. load time 2. execution time

    run-time compiler
          n.  refers to the compile function or to implicit compilation,
          for which the compilation and run-time environments are
          maintained in the same Lisp image.

    run-time definition
          n.  a definition in the run-time environment.

    run-time environment
          n.  the environment in which a program is executed.

S
-

    safe
          adj.  1. (of code) processed in a lexical environment where the
          the highest safety level (3) was in effect.  See optimize.  2.
          (of a call) a safe call.

    safe call
          n.  a call in which the call, the function being called, and the
          point of functional evaluation are all safe_1 code.  For more
          detailed information, see *Note Safe and Unsafe Calls::.

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

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

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

    script
          n. ISO one of possibly several sets that form an exhaustive
          partition of the type character.  See *Note Character Scripts::.

    secondary value
          n. (of values resulting from the evaluation of a form) the
          second value, if any, or else nil if there are fewer than two
          values.  "The secondary value returned by truncate is a
          remainder."

    section
          n.  a partitioning of output by a conditional newline on a
          pretty printing stream.  See *Note Dynamic Control of the
          Arrangement of Output::.

    self-evaluating object
          n.  an object that is neither a symbol nor a cons.  If a
          self-evaluating object is evaluated, it yields itself as its
          only value.  "Strings are self-evaluating objects."

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

    semicolon
          n.  the standard character that is called "semicolon" (;).  See
          Figure~2-5.

    sequence
          n.  1. an ordered collection of elements 2. a vector or a list.

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

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

    sequentially
          adv.  in a sequential way.

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

    session
          n.  the conceptual aggregation of events in a Lisp image from
          the time it is started to the time it is terminated.

    set
          v.t. Trad. (any variable or a symbol that is the name of a
          dynamic variable) to assign the variable.

    setf expander
          n.  a function used by setf to compute the setf expansion of a
          place.

    setf expansion
          n.  a set of five expressions_1 that, taken together, describe
          how to store into a place and which subforms of the macro call
          associated with the place are evaluated.  See *Note Setf
          Expansions::.

    setf function
          n.  a function whose name is (setf symbol).

    setf function name
          n. (of a symbol S) the list (setf S).

    shadow
          v.t.  1. to override the meaning of.  "That binding of X shadows
          an outer one." 2. to hide the presence of.  "That macrolet of F
          shadows the outer flet of F." 3. to replace.  "That package
          shadows the symbol cl:car with its own symbol car."

    shadowing symbol
          n. (in a package) an element of the package's shadowing symbols
          list.

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

    shared slot
          n. (of a class) a slot accessible in more than one instance of a
          class; specifically, such a slot is accessible in all direct
          instances of the class and in those indirect instances whose
          class does not shadow_1 the slot.

    sharpsign
          n.  the standard character that is variously called "number
          sign," "sharp," or "sharp sign" (#).  See Figure~2-5.

    short float
          n.  an object of type short-float.

    sign
          n.  one of the standard characters "+" or "-".

    signal
          v.  to announce, using a standard protocol, that a particular
          situation, represented by a condition, has been detected.  See
          *Note Condition System Concepts::.

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

    similar
          adj. (of two objects) defined to be equivalent under the
          similarity relationship.

    similarity
          n.  a two-place conceptual equivalence predicate, which is
          independent of the Lisp image so that two objects in different
          Lisp images can be understood to be equivalent under this
          predicate.  See *Note Literal Objects in Compiled Files::.

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

    simple array
          n.  an array of type simple-array.

    simple bit array
          n.  a bit array that is a simple array; that is, an object of
          type (simple-array bit).

    simple bit vector
          n.  a bit vector of type simple-bit-vector.

    simple condition
          n.  a condition of type simple-condition.

    simple general vector
          n.  a simple vector.

    simple string
          n.  a string of type simple-string.

    simple vector
          n.  a vector of type simple-vector, sometimes called a "simple
          general vector." Not all vectors that are simple are simple
          vectors--only those that have element type t.

    single escape
          n., adj.  1. n. the syntax type of a character that indicates
          that the next character is to be treated as an alphabetic_2
          character with its case preserved.  For details, see *Note
          Single Escape Character::.  2. adj. (of a character) having the
          single escape syntax type.  3. n. a single escape_2 character.
          (In the standard readtable, slash is the only single escape.)

    single float
          n.  an object of type single-float.

    single-quote
          n.  the standard character that is variously called
          ``apostrophe," ``acute accent," ``quote," or "single quote" (').
          See Figure~2-5.

    singleton
          adj. (of a sequence) having only one element.  "(list 'hello)
          returns a singleton list."

    situation
          n.  the evaluation of a form in a specific environment.

    slash
          n.  the standard character that is variously called ``solidus"
          or "slash" (/).  See Figure~2-5.

    slot
          n.  a component of an object that can store a value.

    slot specifier
          n.  a representation of a slot that includes the name of the
          slot and zero or more slot options.  A slot option pertains only
          to a single slot.

    source code
          n.  code representing objects suitable for evaluation (e.g.,
          objects created by read, by macro expansion,

          or by compiler macro expansion).

    source file
          n.  a file which contains a textual representation of source
          code, that can be edited, loaded, or compiled.

    space
          n.  the standard character <Space>, notated for the Lisp reader
          as #\Space.

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

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

    special variable
          n. Trad.  a dynamic variable.

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

    specialized
          adj.  1. (of a generic function) having methods which specialize
          the generic function.  2. (of an array) having an actual array
          element type that is a proper subtype of the type t; see *Note
          Array Elements::.  "(make-array 5 :element-type 'bit) makes an
          array of length five that is specialized for bits."

    specialized lambda list
          n.  an extended lambda list used in forms that establish method
          definitions, such as defmethod.  See *Note Specialized Lambda
          Lists::.

    spreadable argument list designator
          n.  a designator for a list of objects; that is, an object that
          denotes a list and that is a non-null list L1 of length n, whose
          last element is a list L2 of length m (denoting a list L3 of
          length m+n-1 whose 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)."

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

    stack-allocated
          adj. Trad.  having been stack allocated.

    standard character
          n.  a character of type standard-char, which is one of a fixed
          set of 96 such characters required to be present in all
          conforming implementations.  See *Note Standard Characters::.

    standard class
          n.  a class that is a generalized instance of class
          standard-class.

    standard generic function
          a function of type standard-generic-function.

    standard input
          n.  the input stream which is the value of the dynamic variable
          *standard-input*.

    standard method combination
          n.  the method combination named standard.

    standard object
          n.  an object that is a generalized instance of class
          standard-object.

    standard output
          n.  the output stream which is the value of the dynamic variable
          *standard-output*.

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

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

    standard syntax
          n.  the syntax represented by the standard readtable and used as
          a reference syntax throughout this document.  See *Note
          Character Syntax::.

    standardized
          adj. (of a name, object, or definition) having been defined by
          Common Lisp.  "All standardized variables that are required to
          hold bidirectional streams have "-io*" in their name."

    startup environment
          n.  the global environment of the running Lisp image from which
          the compiler was invoked.

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

    stream
          n.  an object that can be used with an input or output function
          to identify an appropriate source or sink of characters or bytes
          for that operation.

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

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

    stream element type
          n. (of a stream) the type of data for which the stream is
          specialized.

    stream variable
          n.  a variable whose value must be a stream.

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

    string
          n.  a specialized vector that is of type string, and whose
          elements are of type character or a subtype of type character.

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

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

    string equal
          adj.  the same under string-equal.

    string stream
          n.  a stream of type string-stream.

    structure
          n.  an object of type structure-object.

    structure class
          n.  a class that is a generalized instance of class
          structure-class.

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

    style warning
          n.  a condition of type style-warning.

    subclass
          n.  a class that inherits from another class, called a
          superclass.  (No class is a subclass of itself.)

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

    subform
          n. (of a form) an expression that is a subexpression of the form,
          and which by virtue of its position in that form is also a form.
          "(f x) and x, but not exit, are subforms of (return-from exit (f
          x))."

    subrepertoire
          n.  a subset of a repertoire.

    subtype
          n.  a type whose membership is the same as or a proper subset of
          the membership of another type, called a supertype.  (Every type
          is a subtype of itself.)

    superclass
          n.  a class from which another class (called a subclass)
          inherits.  (No class is a superclass of itself.) See subclass.

    supertype
          n.  a type whose membership is the same as or a proper superset
          of the membership of another type, called a subtype.  (Every
          type is a supertype of itself.) See subtype.

    supplied-p parameter
          n.  a parameter which recieves its generalized boolean value
          implicitly due to the presence or absence of an argument
          corresponding to another parameter (such as an optional
          parameter or a rest parameter).  See *Note Ordinary Lambda
          Lists::.

    symbol
          n.  an object of type symbol.

    symbol macro
          n.  a symbol that stands for another form.  See the macro
          symbol-macrolet.

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

    synonym stream symbol
          n. (of a synonym stream) the symbol which names the dynamic
          variable which has as its value another stream for which the
          synonym stream is an alias.

    syntax type
          n. (of a character) one of several classifications, enumerated
          in Figure~2-6, that are used for dispatch during parsing by the
          Lisp reader.  See *Note Character Syntax Types::.

    system class
          n.  a class that may be of type built-in-class in a conforming
          implementation and hence cannot be inherited by classes defined
          by conforming programs.

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

T
-

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

    tag
          n.  1. a catch tag.  2. a go tag.

    tail
          n. (of a list) an object that is the same as either some cons
          which makes up that list or the atom (if any) which terminates
          the list.  "The empty list is a tail of every proper list."

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

    terminal I/O
          n.  the bidirectional stream that is the value of the variable
          *terminal-io*.

    terminating
          n. (of a macro character) being such that, if it appears while
          parsing a token, it terminates that token.  See *Note Reader
          Algorithm::.

    tertiary value
          n. (of values resulting from the evaluation of a form) the third
          value, if any, or else nil if there are fewer than three values.

    throw
          v.  to transfer control and values to a catch.  See the special
          operator throw.

    tilde
          n.  the standard character that is called "tilde" (~).  See
          Figure~2-5.

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

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

    token
          n.  a textual representation for a number or a symbol.  See
          *Note Interpretation of Tokens::.

    top level form
          n.  a form which is processed specially by compile-file for the
          purposes of enabling compile time evaluation of that form.  Top
          level forms include those forms which are not subforms of any
          other form, and certain other cases.  See *Note Processing of
          Top Level Forms::.

    trace output
          n.  the output stream which is the value of the dynamic variable
          *trace-output*.

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

    tree structure
          n. (of a tree_1) the set of conses that make up the tree.  Note
          that while the car_{1b} component of each such cons is part of
          the tree structure, the objects that are the cars_2 of each cons
          in the tree are not themselves part of its tree structure unless
          they are also conses.

    true
          n.  any object that is not false and that is used to represent
          the success of a predicate test.  See t_1.

    truename
          n.  1. the canonical filename of a file in the file system.  See
          *Note Truenames::.  2. a pathname representing a truename_1.

    two-way stream
          n.  a stream of type two-way-stream, which is a bidirectional
          composite stream that receives its input  from an associated
          input  stream and sends    its output to   an associated output
          stream.

    type
          n.  1. a set of objects, usually with common structure,
          behavior, or purpose.  (Note that the expression "X is of type
          S_a" naturally implies that "X is of type S_b" if S_a is a
          subtype of S_b.) 2. (immediately following the name of a type) a
          subtype of that type.  "The type vector is an array type."

    type declaration
          n.  a declaration that asserts that every reference to a
          specified binding within the scope of the declaration results in
          some object of the specified type.

    type equivalent
          adj. (of two types X and Y) having the same elements; that is, X
          is a subtype of Y and Y is a subtype of X.

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

    type specifier
          n.  an expression that denotes a type.  "The symbol
          random-state, the list (integer 3 5), the list (and list (not
          null)), and the class named standard-class are type specifiers."

U
-

    unbound
          adj.  not having an associated denotation in a binding.  See
          bound.

    unbound variable
          n.  a name that is syntactically plausible as the name of a
          variable but which is not bound in the variable namespace.

    undefined function
          n.  a name that is syntactically plausible as the name of a
          function but which is not bound in the function namespace.

    unintern
          v.t. (a symbol in a package) to make the symbol not be present
          in that package.  (The symbol might continue to be accessible by
          inheritance.)

    uninterned
          adj. (of a symbol) not accessible in any package; i.e., not
          interned_1.

    universal time
          n.  time, represented as a non-negative integer number of
          seconds.  Absolute universal time is measured as an offset from
          the beginning of the year 1900 (ignoring leap seconds).  See
          *Note Universal Time::.

    unqualified method
          n.  a method with no qualifiers.

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

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

    unsafe call
          n.  a call that is not a safe call.  For more detailed
          information, see *Note Safe and Unsafe Calls::.

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

    upgraded array element type
          n. (of a type) a type that is a supertype of the type and that
          is used instead of the type whenever the type is used as an
          array element type for object creation or type discrimination.
          See *Note Array Upgrading::.

    upgraded complex part type
          n. (of a type) a type that is a supertype of the type and that
          is used instead of the type whenever the type is used as a
          complex part type for object creation or type discrimination.
          See the function upgraded-complex-part-type.

    uppercase
          adj. (of a character) being among standard characters
          corresponding to the capital letters A through Z, or being some
          other implementation-defined character that is defined by the
          implementation to be uppercase.  See *Note Characters With
          Case::.

    use
          v.t. (a package P_1) to inherit the external symbols of P_1.
          (If a package P_2 uses P_1, the external symbols of P_1 become
          internal symbols of P_2 unless they are explicitly exported.)
          "The package CL-USER uses the package CL."

    use list
          n. (of a package) a (possibly empty) list associated with each
          package which determines what other packages are currently being
          used by that package.

    user
          n.  an active entity, typically a human, that invokes or
          interacts with a program at run time, but that is not
          necessarily a programmer.

V
-

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

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

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

    valid fill pointer
          n. (of an array) a fixnum suitable for use as a fill pointer for
          the array.  Such a fixnum must be greater than or equal to zero,
          and less than or equal to the array total size of the 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.]

    valid logical pathname host
          n.  a string that has been defined as the name of a logical host.
          See the function load-logical-pathname-translations.

    valid pathname device
          n.  a string, nil, :unspecific, or some other object defined by
          the implementation to be a valid pathname device.

    valid pathname directory
          n.  a string, a list of strings, nil,

          :wild,

          :unspecific, or some other object defined by the implementation
          to be a valid directory component.

    valid pathname host
          n.  a valid physical pathname host or a valid logical pathname
          host.

    valid pathname name
          n.  a string, nil, :wild, :unspecific, or some other object
          defined by the implementation to be a valid pathname name.

    valid pathname type
          n.  a string, nil, :wild, :unspecific.

    valid pathname version
          n.  a non-negative integer, or one of :wild, :newest,
          :unspecific, or nil.  The symbols :oldest, :previous, and
          :installed are semi-standard special version symbols.

    valid physical pathname host
          n.  any of a string, a list of strings, or the symbol
          :unspecific, that is recognized by the implementation as the
          name of a host.

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

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

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

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

    variable
          n.  a binding in which a symbol is the name used to refer to an
          object.

    vector
          n.  a one-dimensional array.

    vertical-bar
          n.  the standard character that is called "vertical bar" (|).
          See Figure~2-5.

W
-

    whitespace
          n.  1. one or more characters that are either the graphic
          character #\Space or else non-graphic characters such as
          #\Newline that only move the print position.  2. a. n. the
          syntax type of a character that is a token separator.  For
          details, see *Note Whitespace Characters::.  b. adj. (of a
          character) having the whitespace_{2a} syntax type_2.  c. n. a
          whitespace_{2b} character.

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

    write
          v.t.

          1. (a binding or slot or component) to change the value of the
          binding or slot.

          2. (an object to a stream) to output a representation of the
          object to the stream.

    writer
          n.  a function that writes_1 a variable or slot.

Y
-

    yield
          v.t. (values) to produce the values as the result of evaluation.
          "The form (+ 2 3) yields 5."