======Glossary====== Each entry in this glossary has the following parts: * the term being defined, set in boldface. * 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 //[[CL:Glossary: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 //[[CL:Glossary|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, "//[[CL:Glossary:complex float]]//" refers to a single glossary entry for "//[[CL:Glossary:complex float]]//" rather than the combined meaning of the glossary terms "//[[CL:Glossary:complex]]//" and "//[[CL:Glossary:float]]//." Subscript notation, as in "//[[CL:Glossary|something<sub>n</sub>]]//" means that the //n//-th definition of "//[[CL:Glossary]]//" 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===== ===()=== //n.// * an alternative notation for writing the symbol **[[CL:Constant Variables:nil]]**, used to emphasize the use of //[[CL:Glossary:nil]]// as an //[[CL:Glossary:empty list]]//. =====A===== ===absolute=== //adj.// * 1. (of a //[[CL:Glossary:time]]//) representing a specific point in time. * 2. (of a //[[CL:Glossary:pathname]]//) representing a specific position in a directory hierarchy. See //[[CL:Glossary:relative]]//. ===access=== //n.//, //v.t.// * 1. //v.t.// (a //[[CL:Glossary:place]]//, or //[[CL:Glossary:array]]//) to //[[CL:Glossary:read|read<sub>1</sub>]]// or //[[CL:Glossary:write|write<sub>1</sub>]]// the //[[CL:Glossary:value]]// of the //[[CL:Glossary:place]]// or an //[[CL:Glossary:element]]// of the //[[CL:Glossary:array]]//. * 2. //n.// (of a //[[CL:Glossary:place]]//) an attempt to //[[CL:Glossary:access|access<sub>1</sub>]]// the //[[CL:Glossary:value]]// of the //[[CL:Glossary:place]]//. ===accessibility=== //n.// * the state of being //[[CL:Glossary:accessible]]//. ===accessible=== //adj.// * 1. (of an //[[CL:Glossary:object]]//) capable of being //[[CL:Glossary:reference|referenced]]//. * 2. (of //[[CL:Glossary:shared slot|shared slots]]// or //[[CL:Glossary:local slot|local slots]]// in an //[[CL:Glossary:instance]]// of a //[[CL:Glossary:class]]//) having been defined by the //[[CL:Glossary:class]]// of the //[[CL:Glossary:instance]]// or //[[CL:Glossary:inherit|inherited]]// from a //[[CL:Glossary:superclass]]// of that //[[CL:Glossary:class]]//. * 3. (of a //[[CL:Glossary:symbol]]// in a //[[CL:Glossary:package]]//) capable of being //[[CL:Glossary:reference|referenced]]// without a //[[CL:Glossary:package prefix]]// when that //[[CL:Glossary:package]]// is current, regardless of whether the //[[CL:Glossary:symbol]]// is //[[CL:Glossary:present]]// in that //[[CL:Glossary:package]]// or is //[[CL:Glossary:inherit|inherited]]//. ===accessor=== //n.// * an //[[CL:Glossary:operator]]// that performs an //[[CL:Glossary:access]]//. See //[[CL:Glossary:reader]]// and //[[CL:Glossary:writer]]//. ===active=== //adj.// * 1. (of a //[[CL:Glossary:handler]]//, a //[[CL:Glossary:restart]]//, or a //[[CL:Glossary:catch tag]]//) having been //[[CL:Glossary:establish|established]]// but not yet //[[CL:Glossary:disestablish|disestablished]]//. * 2. (of an //[[CL:Glossary:element]]// of an //[[CL:Glossary:array]]//) having an index that is greater than or equal to zero, but less than the //[[CL:Glossary:fill pointer]]// (if any). For an //[[CL:Glossary:array]]// that has no //[[CL:Glossary:fill pointer]]//, all //[[CL:Glossary:element|elements]]// are considered //[[CL:Glossary:active]]//. ===actual adjustability=== //n.// * (of an //[[CL:Glossary:array]]//) a //[[CL:Glossary:generalized boolean]]// that is associated with the //[[CL:Glossary:array]]//, representing whether the //[[CL:Glossary:array]]// is //[[CL:Glossary:actually adjustable]]//. See also //[[CL:Glossary:expressed adjustability]]// and **[[CL:Functions:adjustable-array-p]]**. ===actual argument=== //n.//, //Trad.// * an //[[CL:Glossary:argument]]//. ===actual array element type=== //n.// * (of an //[[CL:Glossary:array]]//) the //[[CL:Glossary:type]]// for which the //[[CL:Glossary:array]]// is actually specialized, which is the //[[CL:Glossary:upgraded array element type]]// of the //[[CL:Glossary:expressed array element type]]// of the //[[CL:Glossary:array]]//. See **[[CL:Functions:array-element-type]]**. ===actual complex part type=== //n.// * (of a //[[CL:Glossary:complex]]//) the //[[CL:Glossary:type]]// in which the real and imaginary parts of the //[[CL:Glossary:complex]]// are actually represented, which is the //[[CL:Glossary:upgraded complex part type]]// of the //[[CL:Glossary:expressed complex part type]]// of the //[[CL:Glossary:complex]]//. ===actual parameter=== //n.//, //Trad.// * an //[[CL:Glossary:argument]]//. ===actually adjustable=== //adj.// * (of an //[[CL:Glossary:array]]//) such that **[[CL:Functions:adjust-array]]** can adjust its characteristics by direct modification. A //[[CL:Glossary:conforming program]]// may depend on an //[[CL:Glossary:array]]// being //[[CL:Glossary:actually adjustable]]// only if either that //[[CL:Glossary:array]]// is known to have been //[[CL:Glossary:expressly adjustable]]// or if that //[[CL:Glossary:array]]// has been explicitly tested by **[[CL:Functions:adjustable-array-p]]**. ===adjustability=== //n.// * (of an //[[CL:Glossary:array]]//) 1. //[[CL:Glossary:expressed adjustability]]//. 2. //[[CL:Glossary:actual adjustability]]//. ===adjustable=== //adj.// * (of an //[[CL:Glossary:array]]//) 1. //[[CL:Glossary:expressly adjustable]]//. 2. //[[CL:Glossary:actually adjustable]]//. ===after method=== //n.// * a //[[CL:Glossary:method]]// having the //[[CL:Glossary:qualifier]]// **'':after''**. ===alist=== //n.// * an //[[CL:Glossary:association list]]//. ===alphabetic=== //n.//, //adj.// * 1. //adj.// (of a //[[CL:Glossary:character]]//) being one of the //[[CL:Glossary:standard character|standard characters]]// ''A'' through ''Z'' or ''a'' through ''z'', or being any //[[CL:Glossary:implementation-defined]]// character that has //[[CL:Glossary:case]]//, or being some other //[[CL:Glossary:graphic]]// //[[CL:Glossary:character]]// defined by the //[[CL:Glossary:implementation]]// to be //[[CL:Glossary:alphabetic|alphabetic<sub>1</sub>]]//. * 2. * a. //n.// one of several possible //[[CL:Glossary:constituent trait|constituent traits]]// of a //[[CL:Glossary:character]]//. For details, \seesection\ConstituentChars\ and \secref\ReaderAlgorithm. * b. //adj.// (of a //[[CL:Glossary:character]]//) being a //[[CL:Glossary:character]]// that has //[[CL:Glossary:syntax type]]// //[[CL:Glossary:constituent]]// in the //[[CL:Glossary:current readtable]]// and that has the //[[CL:Glossary:constituent trait]]// //[[CL:Glossary:alphabetic|alphabetic<sub>2a</sub>]]//. \Seefigure\ConstituentTraitsOfStdChars. ===alphanumeric=== //adj.// * (of a //[[CL:Glossary:character]]//) being either an //[[CL:Glossary:alphabetic|alphabetic<sub>1</sub>]]// //[[CL:Glossary:character]]// or a //[[CL:Glossary:numeric]]// //[[CL:Glossary:character]]//. ===ampersand=== //n.// * the //[[CL:Glossary:standard character]]// that is called "ampersand" (''&''). \Seefigure\StdCharsThree. ===anonymous=== //adj.// * 1. (of a //[[CL:Glossary:class]]// or //[[CL:Glossary:function]]//) having no //[[CL:Glossary:name]]// * 2. (of a //[[CL:Glossary:restart]]//) having a //[[CL:Glossary:name]]// of **[[CL:Constant Variables:nil]]**. ===apparently uninterned=== //adj.// * having a //[[CL:Glossary:home package]]// of **[[CL:Constant Variables:nil]]**. (An //[[CL:Glossary:apparently uninterned]]// //[[CL:Glossary:symbol]]// might or might not be an //[[CL:Glossary:uninterned]]// //[[CL:Glossary:symbol]]//. //[[CL:Glossary:uninterned|Uninterned]]// //[[CL:Glossary:symbol|symbol]]// have a //[[CL:Glossary:home package]]// of **[[CL:Constant Variables:nil]]**, but //[[CL:Glossary:symbol|symbols]]// which have been //[[CL:Glossary:uninterned]]// from their //[[CL:Glossary:home package]]// also have a //[[CL:Glossary:home package]]// of **[[CL:Constant Variables:nil]]**, even though they might still be //[[CL:Glossary:interned]]// in some other //[[CL:Glossary:package]]//.) ===applicable=== //adj.// * 1. (of a //[[CL:Glossary:handler]]//) being an //[[CL:Glossary:applicable handler]]//. * 2. (of a //[[CL:Glossary:method]]//) being an //[[CL:Glossary:applicable method]]//. * 3. (of a //[[CL:Glossary:restart]]//) being an //[[CL:Glossary:applicable restart]]//. ===applicable handler=== //n.// * (for a //[[CL:Glossary:condition]]// being //[[CL:Glossary:signal|signaled]]//) an //[[CL:Glossary:active]]// //[[CL:Glossary:handler]]// for which the associated type contains the //[[CL:Glossary:condition]]//. ===applicable method=== //n.// * (of a //[[CL:Glossary:generic function]]// called with //[[CL:Glossary:argument|arguments]]//) a //[[CL:Glossary:method]]// of the //[[CL:Glossary:generic function]]// for which the //[[CL:Glossary:argument|arguments]]// satisfy the //[[CL:Glossary:parameter specializer|parameter specializers]]// of that //[[CL:Glossary:method]]//. \Seesection\SelApplMeth. ===applicable restart=== //n.// * 1. (for a //[[CL:Glossary:condition]]//) an //[[CL:Glossary:active]]// //[[CL:Glossary:handler]]// for which the associated test returns //[[CL:Glossary:true]]// when given the //[[CL:Glossary:condition]]// as an argument. * 2. (for no particular //[[CL:Glossary:condition]]//) an //[[CL:Glossary:active]]// //[[CL:Glossary:handler]]// for which the associated test returns //[[CL:Glossary:true]]// when given **[[CL:Constant Variables:nil]]** as an argument. \issue{CONDITION-RESTARTS:PERMIT-ASSOCIATION} ===apply=== //v.t.// * (a //[[CL:Glossary:function]]// to a //[[CL:Glossary:list]]//) to //[[CL:Glossary:call]]// the //[[CL:Glossary:function]]// with arguments that are the //[[CL:Glossary:element|elements]]// of the //[[CL:Glossary:list]]//. "Applying the function **[[CL:Functions:math-add|+]]** to a list of integers returns the sum of the elements of that list." \issue{CONDITION-RESTARTS:PERMIT-ASSOCIATION} ===argument=== //n.// * 1. (of a //[[CL:Glossary:function]]//) an //[[CL:Glossary:object]]// which is offered as data to the //[[CL:Glossary:function]]// when it is //[[CL:Glossary:call|called]]//. * 2. (of a //[[CL:Glossary:format control]]//) a //[[CL:Glossary:format argument]]//. \issue{FORMAT-STRING-ARGUMENTS:SPECIFY} ===argument evaluation order=== //n.// * the order in which //[[CL:Glossary:argument|arguments]]// are evaluated in a function call. "The argument evaluation order for Common Lisp is left to right." \Seesection\Evaluation. ===argument precedence order=== //n.// * the order in which the //[[CL:Glossary:argument|arguments]]// to a //[[CL:Glossary:generic function]]// are considered when sorting the //[[CL:Glossary:applicable method|applicable methods]]// into precedence order. ===around method=== //n.// * a //[[CL:Glossary:method]]// having the //[[CL:Glossary:qualifier]]// **'':around''**. ===array=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:array]]**, which serves as a container for other //[[CL:Glossary:object|objects]]// arranged in a Cartesian coordinate system. ===array element type=== //n.// (of an //[[CL:Glossary:array]]//) * 1. a //[[CL:Glossary:type]]// associated with the //[[CL:Glossary:array]]//, and of which all //[[CL:Glossary:element|elements]]// of the //[[CL:Glossary:array]]// are constrained to be members. * 2. the //[[CL:Glossary:actual array element type]]// of the //[[CL:Glossary:array]]//. * 3. the //[[CL:Glossary:expressed array element type]]// of the //[[CL:Glossary:array]]//. ===array total size=== //n.// * the total number of //[[CL:Glossary:element|elements]]// in an //[[CL:Glossary:array]]//, computed by taking the product of the //[[CL:Glossary:dimension|dimensions]]// of the //[[CL:Glossary:array]]//. (The size of a zero-dimensional //[[CL:Glossary:array]]// is therefore one.) ===assign=== //v.t.// * (a //[[CL:Glossary:variable]]//) to change the //[[CL:Glossary:value]]// of the //[[CL:Glossary:variable]]// in a //[[CL:Glossary:binding]]// that has already been //[[CL:Glossary:establish|established]]//. See **[[CL:Special Operators:setq]]**. ===association list=== //n.// * a //[[CL:Glossary:list]]// of //[[CL:Glossary:cons|conses]]// representing an association of //[[CL:Glossary:key|keys]]// with //[[CL:Glossary:value|values]]//, where the //[[CL:Glossary:car]]// of each //[[CL:Glossary:cons]]// is the //[[CL:Glossary:key]]// and the //[[CL:Glossary:cdr]]// is the //[[CL:Glossary:value]]// associated with that //[[CL:Glossary:key]]//. ===asterisk=== //n.// * the //[[CL:Glossary:standard character]]// that is variously called "asterisk" or "star" (''*''). \Seefigure\StdCharsThree. ===at-sign=== //n.// * the //[[CL:Glossary:standard character]]// that is variously called "commercial at" or "at sign" (''@''). \Seefigure\StdCharsThree. ===atom=== //n.// * any //[[CL:Glossary:object]]// that is not a //[[CL:Glossary:cons]]//. "A vector is an atom." ===atomic=== //adj.// * being an //[[CL:Glossary:atom]]//. "The number 3, the symbol ''foo'', and **[[CL:Constant Variables:nil]]** are atomic." ===atomic type specifier=== //n.// * a //[[CL:Glossary:type specifier]]// that is //[[CL:Glossary:atomic]]//. For every //[[CL:Glossary:atomic type specifier]]//, //x//, there is an equivalent //[[CL:Glossary:compound type specifier]]// with no arguments supplied, ''(//x//)''. ===attribute=== //n.// * (of a //[[CL:Glossary:character]]//) a program-visible aspect of the //[[CL:Glossary:character]]//. The only //[[CL:Glossary:standardized]]// //[[CL:Glossary:attribute]]// of a //[[CL:Glossary:character]]// is its //[[CL:Glossary:code|code<sub>2</sub>]]//, but //[[CL:Glossary:implementation|implementations]]// are permitted to have additional //[[CL:Glossary:implementation-defined]]// //[[CL:Glossary:attribute|attributes]]//. \Seesection\CharacterAttributes. "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 //[[CL:Glossary:variable]]// that occurs in the part of a //[[CL:Glossary:lambda list]]// that was introduced by ''&body''. Unlike all other //[[CL:Glossary:variable|variables]]// introduced by a //[[CL:Glossary:lambda list]]//, //[[CL:Glossary:aux variable|aux variables]]// are not //[[CL:Glossary:parameter|parameters]]//. ===auxiliary method=== //n.// * a member of one of two sets of //[[CL:Glossary:method|methods]]// (the set of //[[CL:Glossary:primary method|primary methods]]// is the other) that form an exhaustive partition of the set of //[[CL:Glossary:method|methods]]// on the //[[CL:Glossary:method]]//'s //[[CL:Glossary:generic function]]//. How these sets are determined is dependent on the //[[CL:Glossary:method combination]]// type; \seesection\IntroToMethods. =====B===== ===backquote=== //n.// * the //[[CL:Glossary:standard character]]// that is variously called "grave accent" or "backquote" (''`''). \Seefigure\StdCharsThree. ===backslash=== //n.// * the //[[CL:Glossary:standard character]]// that is variously called "reverse solidus" or "backslash" (''\''). \Seefigure\StdCharsThree. ===base character=== //n.// * a //[[CL:Glossary:character]]// \issue{CHARACTER-VS-CHAR:LESS-INCONSISTENT-SHORT} of //[[CL:Glossary:type]]// **[[CL:Types:base-char]]**. ===base string=== //n.// * a //[[CL:Glossary:string]]// of //[[CL:Glossary:type]]// **[[CL:Types:base-string]]**. ===before method=== //n.// * a //[[CL:Glossary:method]]// having the //[[CL:Glossary:qualifier]]// **'':before''**. ===bidirectional=== //adj.// * (of a //[[CL:Glossary:stream]]//) being both an //[[CL:Glossary:input]]// //[[CL:Glossary:stream]]// and an //[[CL:Glossary:output]]// //[[CL:Glossary:stream]]//. ===binary=== //adj.// * 1. (of a //[[CL:Glossary:stream]]//) being a //[[CL:Glossary:stream]]// that has an //[[CL:Glossary:element type]]// that is a //[[CL:Glossary:subtype]]// of **[[CL:Types:integer]]**. The most fundamental operation on a //[[CL:Glossary:binary]]// //[[CL:Glossary:input]]// //[[CL:Glossary:stream]]// is **[[CL:Functions:read-byte]]** and on a //[[CL:Glossary:binary]]// //[[CL:Glossary:output]]// //[[CL:Glossary:stream]]// is **[[CL:Functions:write-byte]]**. See //[[CL:Glossary:character]]//. * 2. (of a //[[CL:Glossary:file]]//) having been created by opening a //[[CL:Glossary:binary]]// //[[CL:Glossary:stream]]//. (It is //[[CL:Glossary:implementation-dependent]]// whether this is an detectable aspect of the //[[CL:Glossary:file]]//, or whether any given //[[CL:Glossary:character]]// //[[CL:Glossary:file]]// can be treated as a //[[CL:Glossary:binary]]// //[[CL:Glossary:file]]//.) ===bind=== //v.t.// (a //[[CL:Glossary:variable]]//) * to establish a //[[CL:Glossary:binding]]// for the //[[CL:Glossary:variable]]//. ===binding=== //n.// * an association between a //[[CL:Glossary:name]]// and that which the //[[CL:Glossary:name]]// denotes. "A lexical binding is a lexical association between a name and its value." When the term //[[CL:Glossary:binding]]// is qualified by the name of a //[[CL:Glossary:name|namespace]]//, such as "variable" or "function," it restricts the binding to the indicated namespace, as in: "**[[CL:Special Operators:let]]** establishes variable bindings." or "**[[CL:Special Operators:let]]** establishes bindings of variables." ===bit=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:bit]]**; that is, the //[[CL:Glossary:integer]]// ''0'' or the //[[CL:Glossary:integer]]// ''1''. ===bit array=== //n.// * a specialized //[[CL:Glossary:array]]// that is of //[[CL:Glossary:type]]// ''([[CL:Types:array]] [[CL:Types:bit]])'', and whose elements are of //[[CL:Glossary:type]]// **[[CL:Types:bit]]**. ===bit vector=== //n.// * a specialized //[[CL:Glossary:vector]]// that is of //[[CL:Glossary:type]]// **[[CL:Types:bit-vector]]**, and whose elements are of //[[CL:Glossary:type]]// **[[CL:Types:bit]]**. ===bit-wise logical operation specifier=== //n.// * an //[[CL:Glossary:object]]// which names one of the sixteen possible bit-wise logical operations that can be performed by the **[[CL:Functions:boole]]** function, and which is the //[[CL:Glossary:value]]// of exactly one of the //[[CL:Glossary:constant variable|constant variables]]// **[[CL:Constant Variables:boole-clr]]**, **[[CL:Constant Variables:boole-set]]**, **[[CL:Constant Variables:boole-1]]**, **[[CL:Constant Variables:boole-2]]**, **[[CL:Constant Variables:boole-c1]]**, **[[CL:Constant Variables:boole-c2]]**, **[[CL:Constant Variables:boole-and]]**, **[[CL:Constant Variables:boole-ior]]**, **[[CL:Constant Variables:boole-xor]]**, **[[CL:Constant Variables:boole-eqv]]**, **[[CL:Constant Variables:boole-nand]]**, **[[CL:Constant Variables:boole-nor]]**, **[[CL:Constant Variables:boole-andc1]]**, **[[CL:Constant Variables:boole-andc2]]**, **[[CL:Constant Variables:boole-orc1]]**, or **[[CL:Constant Variables:boole-orc2]]**. ===block=== //n.// * a named lexical //[[CL:Glossary:exit point]]//, //[[CL:Glossary:establish|established]]// explicitly by **[[CL:Special Operators:block]]** or implicitly by //[[CL:Glossary:operator|operators]]// such as **[[CL:Macros:loop]]**, **[[CL:Macros:do]]** and **[[CL:Macros:prog]]**, to which control and values may be transfered by using a **[[CL:Special Operators:return-from]]** //[[CL:Glossary:form]]// with the name of the //[[CL:Glossary:block]]//. ===block tag=== //n.// * the //[[CL:Glossary:symbol]]// that, within the //[[CL:Glossary:lexical scope]]// of a **[[CL:Special Operators:block]]** //[[CL:Glossary:form]]//, names the //[[CL:Glossary:block]]// //[[CL:Glossary:establish|established]]// by that **[[CL:Special Operators:block]]** //[[CL:Glossary:form]]//. See **[[CL:Macros:return]]** or **[[CL:Special Operators:return-from]]**. ===boa lambda list=== //n.// * a //[[CL:Glossary:lambda list]]// that is syntactically like an //[[CL:Glossary:ordinary lambda list]]//, but that is processed in "**B**y **O**rder of **A**rgument" style. \Seesection\BoaLambdaLists. ===body parameter=== //n.// * a //[[CL:Glossary:parameter]]// available in certain //[[CL:Glossary:lambda list|lambda lists]]// which from the point of view of //[[CL:Glossary:conforming program|conforming programs]]// is like a //[[CL:Glossary:rest parameter]]// in every way except that it is introduced by ''&body'' instead of ''&body''. (//[[CL:Glossary:implementation|Implementations]]// are permitted to provide extensions which distinguish //[[CL:Glossary:body parameter|body parameters]]// and //[[CL:Glossary:rest parameter|rest parameters]]// - e.g. the //[[CL:Glossary:form|forms]]// for //[[CL:Glossary:operator|operators]]// which were defined using a //[[CL:Glossary:body parameter]]// might be pretty printed slightly differently than //[[CL:Glossary:form|forms]]// for //[[CL:Glossary:operator|operators]]// which were defined using //[[CL:Glossary:rest parameter|rest parameters]]//.) ===boolean=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:boolean]]**; that is, one of the following //[[CL:Glossary:object|objects]]//: the symbol **[[CL:Constant Variables:t]]** (representing //[[CL:Glossary:true]]//), or the symbol **[[CL:Constant Variables:nil]]** (representing //[[CL:Glossary:false]]//). See //[[CL:Glossary:generalized boolean]]//. ===boolean equivalent=== //n.// * (of an //[[CL:Glossary:object]]// //O<sub>1</sub>//) any //[[CL:Glossary:object]]// //O<sub>2</sub>// that has the same truth value as //O<sub>1</sub>// when both //O<sub>1</sub>// and //O<sub>2</sub>// are viewed as //[[CL:Glossary:generalized boolean|generalized booleans]]//. ===bound=== //adj.//, //v.t.// * 1. //adj.// having an associated denotation in a //[[CL:Glossary:binding]]//. "The variables named by a **[[CL:Special Operators:let]]** are bound within its body." See //[[CL:Glossary:unbound]]//. * 2. //adj.// having a local //[[CL:Glossary:binding]]// which //[[CL:Glossary:shadow|shadows<sub>2</sub>]]// another. "The variable **[[CL:Variables:star-print-escape-star|*print-escape*]]** is bound while in the **[[CL:Functions:princ]]** function." * 3. //v.t.// the past tense of //[[CL:Glossary:bind]]//. ===bound declaration=== //n.// * a //[[CL:Glossary:declaration]]// that refers to or is associated with a //[[CL:Glossary:variable]]// or //[[CL:Glossary:function]]// and that appears within the //[[CL:Glossary:special form]]// that //[[CL:Glossary:establish|establishes]]// the //[[CL:Glossary:variable]]// or //[[CL:Glossary:function]]//, but before the body of that //[[CL:Glossary:special form]]// (specifically, at the head of that //[[CL:Glossary:form]]//'s body). (If a //[[CL:Glossary:bound declaration]]// refers to a //[[CL:Glossary:function]]// //[[CL:Glossary:binding]]// or a //[[CL:Glossary:lexical variable]]// //[[CL:Glossary:binding]]//, the //[[CL:Glossary:scope]]// of the //[[CL:Glossary:declaration]]// is exactly the //[[CL:Glossary:scope]]// of that //[[CL:Glossary:binding]]//. If the //[[CL:Glossary:declaration]]// refers to a //[[CL:Glossary:dynamic variable]]// //[[CL:Glossary:binding]]//, the //[[CL:Glossary:scope]]// of the //[[CL:Glossary:declaration]]// is what the //[[CL:Glossary:scope]]// of the //[[CL:Glossary:binding]]// would have been if it were lexical rather than dynamic.) ===bounded=== //adj.// * (of a //[[CL:Glossary:sequence]]// //S//, by an ordered pair of //[[CL:Glossary:bounding index|bounding indices]]// //i<sub>start</sub>// and //i<sub>end</sub>//) restricted to a subrange of the //[[CL:Glossary:element|elements]]// of //S// that includes each //[[CL:Glossary:element]]// beginning with (and including) the one indexed by //i<sub>start</sub>// and continuing up to (but not including) the one indexed by //i<sub>end</sub>//. ===bounding index=== //n.// * (of a //[[CL:Glossary:sequence]]// with //[[CL:Glossary:length]]// //n//) either of a conceptual pair of //[[CL:Glossary:integer|integers]]//, //i<sub>start</sub>// and //i<sub>end</sub>//, respectively called the "lower bounding index" and "upper bounding index", such that ''0 <= //i<sub>start</sub>// <= //i<sub>end</sub>// <= n'', and which therefore delimit a subrange of the //[[CL:Glossary:sequence]]// //[[CL:Glossary:bounded]]// by //i<sub>start</sub>// and //i<sub>end</sub>//. ===bounding index designator=== //n.// (for a //[[CL:Glossary:sequence]]//) * one of two //[[CL:Glossary:object|objects]]// that, taken together as an ordered pair, behave as a //[[CL:Glossary:designator]]// for //[[CL:Glossary:bounding index|bounding indices]]// of the //[[CL:Glossary:sequence]]//; that is, they denote //[[CL:Glossary:bounding index|bounding indices]]// of the //[[CL:Glossary:sequence]]//, and are either: an //[[CL:Glossary:integer]]// (denoting itself) and **[[CL:Constant Variables:nil]]** (denoting the //[[CL:Glossary:length]]// of the //[[CL:Glossary:sequence]]//), or two //[[CL:Glossary:integer|integers]]// (each denoting themselves). ===break loop=== //n.// * a variant of the normal //[[CL:Glossary:Lisp read-eval-print loop]]// that is //[[CL:Glossary:recursion|recursively]]// entered, usually because the ongoing //[[CL:Glossary:evaluation]]// of some other //[[CL:Glossary:form]]// has been suspended for the purpose of debugging. Often, a //[[CL:Glossary:break loop]]// provides the ability to exit in such a way as to continue the suspended computation. See **[[CL:Functions:break]]**. ===broadcast stream=== //n.// * an //[[CL:Glossary:output]]// //[[CL:Glossary:stream]]// of //[[CL:Glossary:type]]// **[[CL:Types:broadcast-stream]]**. ===built-in class=== //n.// * a //[[CL:Glossary:class]]// that is a //[[CL:Glossary:generalized instance]]// of //[[CL:Glossary:class]]// **[[CL:Types:built-in-class]]**. ===built-in type=== //n.// * one of the //[[CL:Glossary:type|types]]// in \figref\StandardizedAtomicTypeSpecs. ===byte=== //n.// * 1. adjacent bits within an //[[CL:Glossary:integer]]//. (The specific number of bits can vary from point to point in the program; see //[[CL:Glossary:function]]// **[[CL:Functions:byte]]**.) * 2. an integer in a specified range. (The specific range can vary from point to point in the program; see //[[CL:Glossary:function|functions]]// **[[CL:Functions:open]]** and **[[CL:Functions:write-byte]]**.) ===byte specifier=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:implementation-dependent]]// nature that is returned by the //[[CL:Glossary:function]]// **[[CL:Functions:byte]]** and that specifies the range of bits in an //[[CL:Glossary:integer]]// to be used as a //[[CL:Glossary:byte]]// by //[[CL:Glossary:function|functions]]// such as **[[CL:Functions:ldb]]**. =====C===== ===cadr=== //n.// * (of an //[[CL:Glossary:object]]//) the //[[CL:Glossary:car]]// of the //[[CL:Glossary:cdr]]// of that //[[CL:Glossary:object]]//. ===call=== //v.t.//, //n.// * 1. //v.t.// (a //[[CL:Glossary:function]]// with //[[CL:Glossary:argument|arguments]]//) to cause the //[[CL:Glossary:code]]// represented by that //[[CL:Glossary:function]]// to be //[[CL:Glossary:execute|executed]]// in an //[[CL:Glossary:environment]]// where //[[CL:Glossary:binding|bindings]]// for the //[[CL:Glossary:value|values]]// of its //[[CL:Glossary:parameter|parameters]]// have been //[[CL:Glossary:establish|established]]// based on the //[[CL:Glossary:argument|arguments]]//. "Calling the function **[[CL:Functions:math-add|+]]** with the arguments ''5'' and ''1'' yields a value of ''6''." * 2. //n.// a //[[CL:Glossary:situation]]// in which a //[[CL:Glossary:function]]// is called. ===captured initialization form=== //n.// * an //[[CL:Glossary:initialization form]]// along with the //[[CL:Glossary:lexical environment]]// in which the //[[CL:Glossary:form]]// that defined the //[[CL:Glossary:initialization form]]// was //[[CL:Glossary:evaluate|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 **[[CL:Macros:defclass]]** form for the new class." ===car=== //n.// * 1. a. (of a //[[CL:Glossary:cons]]//) the component of a //[[CL:Glossary:cons]]// corresponding to the first //[[CL:Glossary:argument]]// to **[[CL:Functions:cons]]**; the other component is the //[[CL:Glossary:cdr]]//. "The function **[[CL:Functions:rplaca]]** modifies the car of a cons." b. (of a //[[CL:Glossary:list]]//) the first //[[CL:Glossary:element]]// of the //[[CL:Glossary:list]]//, or **[[CL:Constant Variables:nil]]** if the //[[CL:Glossary:list]]// is the //[[CL:Glossary:empty list]]//. * 2. the //[[CL:Glossary:object]]// that is held in the //[[CL:Glossary:car|car<sub>1</sub>]]//. "The function **[[CL:Functions:car]]** returns the car of a cons." ===case=== //n.// (of a //[[CL:Glossary:character]]//) * the property of being either //[[CL:Glossary:uppercase]]// or //[[CL:Glossary:lowercase]]//. Not all //[[CL:Glossary:character|characters]]// have //[[CL:Glossary:case]]//. "The characters ''#\A'' and ''#\a'' have case, but the character ''#\$'' has no case."\Seesection\CharactersWithCase\ and the //[[CL:Glossary:function]]// **[[CL:Functions:both-case-p]]**. ===case sensitivity mode=== //n.// * one of the //[[CL:Glossary:symbol|symbols]]// **'':upcase''**, **'':downcase''**, **'':preserve''**, or **'':invert''**. ===catch=== //n.// * an //[[CL:Glossary:exit point]]// which is //[[CL:Glossary:establish|established]]// by a **[[CL:Special Operators:catch]]** //[[CL:Glossary:form]]// within the //[[CL:Glossary:dynamic scope]]// of its body, which is named by a //[[CL:Glossary:catch tag]]//, and to which control and //[[CL:Glossary:value|values]]// may be //[[CL:Glossary:throw|thrown]]//. ===catch tag=== //n.// * an //[[CL:Glossary:object]]// which names an //[[CL:Glossary:active]]// //[[CL:Glossary:catch]]//. (If more than one //[[CL:Glossary:catch]]// is active with the same //[[CL:Glossary:catch tag]]//, it is only possible to //[[CL:Glossary:throw]]// to the innermost such //[[CL:Glossary:catch]]// because the outer one is //[[CL:Glossary:shadow|shadowed<sub>2</sub>]]//.) ===cddr=== //n.// (of an //[[CL:Glossary:object]]//) * the //[[CL:Glossary:cdr]]// of the //[[CL:Glossary:cdr]]// of that //[[CL:Glossary:object]]//. ===cdr=== //n.// * 1. a. (of a //[[CL:Glossary:cons]]//) the component of a //[[CL:Glossary:cons]]// corresponding to the second //[[CL:Glossary:argument]]// to **[[CL:Functions:cons]]**; the other component is the //[[CL:Glossary:car]]//. "The function **[[CL:Functions:rplacd]]** modifies the cdr of a cons." b. (of a //[[CL:Glossary:list]]// //L<sub>1</sub>//) either the //[[CL:Glossary:list]]// //L<sub>2</sub>// that contains the //[[CL:Glossary:element|elements]]// of //L<sub>1</sub>// that follow after the first, or else **[[CL:Constant Variables:nil]]** if //L<sub>1</sub>// is the //[[CL:Glossary:empty list]]//. * 2. the //[[CL:Glossary:object]]// that is held in the //[[CL:Glossary:cdr|cdr<sub>1</sub>]]//. "The function **[[CL:Functions:cdr]]** returns the cdr of a cons." ===cell=== //n.//, //Trad.// (of an //[[CL:Glossary:object]]//) * a conceptual //[[CL:Glossary:slot]]// of that //[[CL:Glossary:object]]//. The //[[CL:Glossary:dynamic variable]]// and global //[[CL:Glossary:function]]// //[[CL:Glossary:binding|bindings]]// of a //[[CL:Glossary:symbol]]// are sometimes referred to as its //[[CL:Glossary:value cell]]// and //[[CL:Glossary:function cell]]//, respectively. ===character=== //n.//, //adj.// * 1. //n.// an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:character]]**; that is, an //[[CL:Glossary:object]]// that represents a unitary token in an aggregate quantity of text; \seesection\CharacterConcepts. * 2. //adj.// * a. (of a //[[CL:Glossary:stream]]//) having an //[[CL:Glossary:element type]]// that is a //[[CL:Glossary:subtype]]// of **[[CL:Types:character]]**. The most fundamental operation on a //[[CL:Glossary:character]]// //[[CL:Glossary:input]]// //[[CL:Glossary:stream]]// is **[[CL:Functions:read-char]]** and on a //[[CL:Glossary:character]]// //[[CL:Glossary:output]]// //[[CL:Glossary:stream]]// is **[[CL:Functions:write-char]]**. See //[[CL:Glossary:binary]]//. * b. (of a //[[CL:Glossary:file]]//) having been created by opening a //[[CL:Glossary:character]]// //[[CL:Glossary:stream]]//. (It is //[[CL:Glossary:implementation-dependent]]// whether this is an inspectable aspect of the //[[CL:Glossary:file]]//, or whether any given //[[CL:Glossary:binary]]// //[[CL:Glossary:file]]// can be treated as a //[[CL:Glossary:character]]// //[[CL:Glossary:file]]//.) ===character code=== //n.// * 1. one of possibly several //[[CL:Glossary:attribute|attributes]]// of a //[[CL:Glossary:character]]//. * 2. a non-negative //[[CL:Glossary:integer]]// less than the //[[CL:Glossary:value]]// of **[[CL:Constant Variables:char-code-limit]]** that is suitable for use as a //[[CL:Glossary:character code|character code<sub>1</sub>]]//. ===character designator=== //n.// * a //[[CL:Glossary:designator]]// for a //[[CL:Glossary:character]]//; that is, an //[[CL:Glossary:object]]// that denotes a //[[CL:Glossary:character]]// and that is one of: a //[[CL:Glossary:designator]]// for a //[[CL:Glossary:string]]// of //[[CL:Glossary:length]]// one (denoting the //[[CL:Glossary:character]]// that is its only //[[CL:Glossary:element]]//),or a //[[CL:Glossary:character]]// (denoting itself). \issue{CHARACTER-PROPOSAL:2-1-1} ===circular=== //adj.// * 1. (of a //[[CL:Glossary:list]]//) a //[[CL:Glossary:circular list]]//. * 2. (of an arbitrary //[[CL:Glossary:object]]//) having a //[[CL:Glossary:component]]//, //[[CL:Glossary:element]]//, //[[CL:Glossary:constituent|constituent<sub>2</sub>]]//, or //[[CL:Glossary:subexpression]]// (as appropriate to the context) that is the //[[CL:Glossary:object]]// itself. ===circular list=== //n.// * a chain of //[[CL:Glossary:cons|conses]]// that has no termination because some //[[CL:Glossary:cons]]// in the chain is the //[[CL:Glossary:cdr]]// of a later //[[CL:Glossary:cons]]//. ===class=== //n.// * 1. an //[[CL:Glossary:object]]// that uniquely determines the structure and behavior of a set of other //[[CL:Glossary:object|objects]]// called its //[[CL:Glossary:direct instance|direct instances]]//, that contributes structure and behavior to a set of other //[[CL:Glossary:object|objects]]// called its //[[CL:Glossary:indirect instance|indirect instances]]//, and that acts as a //[[CL:Glossary:type specifier]]// for a set of objects called its //[[CL:Glossary:generalized instance|generalized instances]]//. "The class **[[CL:Types:integer]]** is a subclass of the class **[[CL:Types:number]]**." (Note that the phrase "the //[[CL:Glossary:class]]// ''foo''" is often substituted for the more precise phrase "the //[[CL:Glossary:class]]// named ''foo''" - in both cases, a //[[CL:Glossary:class]]// //[[CL:Glossary:object]]// (not a //[[CL:Glossary:symbol]]//) is denoted.) * 2. (of an //[[CL:Glossary:object]]//) the uniquely determined //[[CL:Glossary:class]]// of which the //[[CL:Glossary:object]]// is a //[[CL:Glossary:direct instance]]//. See **[[CL:Functions:class-of]]**. "The class of the object returned by **[[CL:Functions:gensym]]** is **[[CL:Types:symbol]]**." (Note that with this usage a phrase such as "its //[[CL:Glossary:class]]// is ''foo''" is often substituted for the more precise phrase "its //[[CL:Glossary:class]]// is the //[[CL:Glossary:class]]// named ''foo''" - in both cases, a //[[CL:Glossary:class]]// //[[CL:Glossary:object]]// (not a //[[CL:Glossary:symbol]]//) is denoted.) ===class designator=== //n.// * a //[[CL:Glossary:designator]]// for a //[[CL:Glossary:class]]//; that is, an //[[CL:Glossary:object]]// that denotes a //[[CL:Glossary:class]]// and that is one of: a //[[CL:Glossary:symbol]]// (denoting the //[[CL:Glossary:class]]// named by that //[[CL:Glossary:symbol]]//; see //[[CL:Glossary:function]]// **[[CL:Functions:find-class]]**) or a //[[CL:Glossary:class]]// (denoting itself). ===class precedence list=== //n.// * a unique total ordering on a //[[CL:Glossary:class]]// and its //[[CL:Glossary:superclass|superclasses]]// that is consistent with the //[[CL:Glossary:local precedence order|local precedence orders]]// for the //[[CL:Glossary:class]]// and its //[[CL:Glossary:superclass|superclasses]]//. For detailed information, \seesection\DeterminingtheCPL. ===close=== //v.t.// * (a //[[CL:Glossary:stream]]//) to terminate usage of the //[[CL:Glossary:stream]]// as a source or sink of data, permitting the //[[CL:Glossary:implementation]]// to reclaim its internal data structures, and to free any external resources which might have been locked by the //[[CL:Glossary:stream]]// when it was opened. ===closed=== //adj.// * (of a //[[CL:Glossary:stream]]//) having been //[[CL:Glossary:closed]]// (see //[[CL:Glossary:close]]//). Some (but not all) operations that are valid on //[[CL:Glossary:open]]// //[[CL:Glossary:stream|streams]]// are not valid on //[[CL:Glossary:closed]]// //[[CL:Glossary:stream|streams]]//. \Seesection\OpenAndClosedStreams. ===closure=== //n.// * a //[[CL:Glossary:lexical closure]]//. ===coalesce=== //v.t.// * (//[[CL:Glossary:literal]]// //[[CL:Glossary:object|objects]]// that are //[[CL:Glossary:similar]]//) to consolidate the identity of those //[[CL:Glossary:object|objects]]//, such that they become the //[[CL:Glossary:same]]// //[[CL:Glossary:object]]//. \Seesection\CompilationTerms. ===code=== //n.// * 1. //Trad.// any representation of actions to be performed, whether conceptual or as an actual //[[CL:Glossary:object]]//, such as //[[CL:Glossary:form|forms]]//, //[[CL:Glossary:lambda expression|lambda expressions]]//, //[[CL:Glossary:object|objects]]// of //[[CL:Glossary:type]]// //[[CL:Glossary:function]]//, text in a //[[CL:Glossary:source file]]//, or instruction sequences in a //[[CL:Glossary:compile|compiled file]]//. This is a generic term; the specific nature of the representation depends on its context. * 2. (of a //[[CL:Glossary:character]]//) a //[[CL:Glossary:character code]]//. ===coerce=== //v.t.// * (an //[[CL:Glossary:object]]// to a //[[CL:Glossary:type]]//) to produce an //[[CL:Glossary:object]]// from the given //[[CL:Glossary:object]]//, without modifying that //[[CL:Glossary:object]]//, by following some set of coercion rules that must be specifically stated for any context in which this term is used. The resulting //[[CL:Glossary:object]]// is necessarily of the indicated //[[CL:Glossary:type]]//, except when that type is a //[[CL:Glossary:subtype]]// of **[[CL:Types:complex]]**; in that case, if a //[[CL:Glossary:complex rational]]// with an imaginary part of zero would result, the result is a //[[CL:Glossary:rational]]// rather than a //[[CL:Glossary:complex]]// - \seesection\RuleOfCanonRepForComplexRationals. ===colon=== //n.// * the //[[CL:Glossary:standard character]]// that is called "colon" ('':''). \Seefigure\StdCharsThree. ===comma=== //n.// * the //[[CL:Glossary:standard character]]// that is called "comma" ('',''). \Seefigure\StdCharsThree. ===compilation=== //n.// * the process of //[[CL:Glossary:compile|compiling]]// //[[CL:Glossary:code]]// by the //[[CL:Glossary:compiler]]//. ===compilation environment=== //n.// * 1. An //[[CL:Glossary:environment]]// that represents information known by the //[[CL:Glossary:compiler]]// about a //[[CL:Glossary:form]]// that is being //[[CL:Glossary:compile|compiled]]//. \Seesection\CompilationTerms. * 2. An //[[CL:Glossary:object]]// that represents the //[[CL:Glossary:compilation environment|compilation environment<sub>1</sub>]]// and that is used as a second argument to a //[[CL:Glossary:macro function]]// (which supplies a //[[CL:Glossary:value]]// for any ''&body'' //[[CL:Glossary:parameter]]// in the //[[CL:Glossary:macro function]]//'s definition). ===compilation unit=== //n.// * an interval during which a single unit of compilation is occurring. see //[[CL:Glossary:macro]]// **[[CL:Macros:with-compilation-unit]]**. ===compile=== //v.t.// * 1. (//[[CL:Glossary:code]]//) to perform semantic preprocessing of the //[[CL:Glossary:code]]//, usually optimizing one or more qualities of the code, such as run-time speed of //[[CL:Glossary:execute|execution]]// or run-time storage usage. The minimum semantic requirements of compilation are that it must remove all macro calls and arrange for all //[[CL:Glossary:load time value|load time values]]// to be resolved prior to run time. * 2. (a //[[CL:Glossary:function]]//) to produce a new //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:compiled-function]]** which represents the result of //[[CL:Glossary:compile|compiling]]// the //[[CL:Glossary:code]]// represented by the //[[CL:Glossary:function]]//. See **[[CL:Functions:compile]]**. * 3. (a //[[CL:Glossary:source file]]//) to produce a //[[CL:Glossary:compile|compiled file]]// from a //[[CL:Glossary:source file]]//. See **[[CL:Functions:compile-file]]**. ===compile time=== //n.// * the duration of time that the //[[CL:Glossary:compiler]]// is processing //[[CL:Glossary:source code]]//. ===compile-time definition=== //n.// * a definition in the //[[CL:Glossary:compilation environment]]//. ===compiled code=== //n.// * 1. //[[CL:Glossary:compiled function|compiled functions]]//. * 2. //[[CL:Glossary:code]]// that represents //[[CL:Glossary:compiled function|compiled functions]]//, such as the contents of a //[[CL:Glossary:compile|compiled file]]//. ===compiled file=== //n.// * a //[[CL:Glossary:file]]// which represents the results of //[[CL:Glossary:compile|compiling]]// the //[[CL:Glossary:form|forms]]// which appeared in a corresponding //[[CL:Glossary:source file]]//, and which can be //[[CL:Glossary:load|loaded]]//. See **[[CL:Functions:compile-file]]**. ===compiled function=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:compiled-function]]**, which is a //[[CL:Glossary:function]]// that has been //[[CL:Glossary:compile|compiled]]//, which contains no references to //[[CL:Glossary:macro|macros]]// that must be expanded at run time, and which contains no unresolved references to //[[CL:Glossary:load time value|load time values]]//. \issue{COMPILED-FUNCTION-REQUIREMENTS:TIGHTEN} ===compiler=== //n.// * a facility that is part of Lisp and that translates //[[CL:Glossary:code]]// into an //[[CL:Glossary:implementation-dependent]]// form that might be represented or //[[CL:Glossary:execute|executed]]// efficiently. The functions **[[CL:Functions:compile]]** and **[[CL:Functions:compile-file]]** permit programs to invoke the //[[CL:Glossary:compiler]]//. ===compiler macro=== //n.// * an auxiliary macro definition for a globally defined //[[CL:Glossary:function]]// or //[[CL:Glossary:macro]]// which might or might not be called by any given //[[CL:Glossary:conforming implementation]]// and which must preserve the semantics of the globally defined //[[CL:Glossary:function]]// or //[[CL:Glossary:macro]]// but which might perform some additional optimizations. (Unlike a //[[CL:Glossary:macro]]//, a //[[CL:Glossary:compiler macro]]// does not extend the syntax of Common Lisp; rather, it provides an alternate implementation strategy for some existing syntax or functionality.) \issue{DEFINE-COMPILER-MACRO:X3J13-NOV89} ===compiler macro expansion=== //n.// * 1. the process of translating a //[[CL:Glossary:form]]// into another //[[CL:Glossary:form]]// by a //[[CL:Glossary:compiler macro]]//. * 2. the //[[CL:Glossary:form]]// resulting from this process. ===compiler macro form=== //n.// * a //[[CL:Glossary:function form]]// or //[[CL:Glossary:macro form]]// whose //[[CL:Glossary:operator]]// has a definition as a //[[CL:Glossary:compiler macro]]//, or a **[[CL:Functions:funcall]]** //[[CL:Glossary:form]]// whose first //[[CL:Glossary:argument]]// is a **[[CL:Special Operators:function]]** //[[CL:Glossary:form]]// whose //[[CL:Glossary:argument]]// is the //[[CL:Glossary:name]]// of a //[[CL:Glossary:function]]// that has a definition as a //[[CL:Glossary:compiler macro]]//. ===compiler macro function=== //n.// * a //[[CL:Glossary:function]]// of two arguments, a //[[CL:Glossary:form]]// and an //[[CL:Glossary:environment]]//, that implements //[[CL:Glossary:compiler macro expansion]]// by producing either a //[[CL:Glossary:form]]// to be used in place of the original argument //[[CL:Glossary:form]]// or else **[[CL:Constant Variables:nil]]**, indicating that the original //[[CL:Glossary:form]]// should not be replaced. \Seesection\CompilerMacros. ===complex=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:complex]]**. ===complex float=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:complex]]** which has a //[[CL:Glossary:complex part type]]// that is a //[[CL:Glossary:subtype]]// of **[[CL:Types:float]]**. A //[[CL:Glossary:complex float]]// is a //[[CL:Glossary:complex]]//, but it is not a //[[CL:Glossary:float]]//. ===complex part type=== //n.// (of a //[[CL:Glossary:complex]]//) * 1. the //[[CL:Glossary:type]]// which is used to represent both the real part and the imaginary part of the //[[CL:Glossary:complex]]//. * 2. the //[[CL:Glossary:actual complex part type]]// of the //[[CL:Glossary:complex]]//. * 3. the //[[CL:Glossary:expressed complex part type]]// of the //[[CL:Glossary:complex]]//. ===complex rational=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:complex]]** which has a //[[CL:Glossary:complex part type]]// that is a //[[CL:Glossary:subtype]]// of **[[CL:Types:rational]]**. A //[[CL:Glossary:complex rational]]// is a //[[CL:Glossary:complex]]//, but it is not a //[[CL:Glossary:rational]]//. No //[[CL:Glossary:complex rational]]// has an imaginary part of zero because such a number is always represented by Common Lisp as an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:rational]]**; \seesection\RuleOfCanonRepForComplexRationals. ===complex single float=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:complex]]** which has a //[[CL:Glossary:complex part type]]// that is a //[[CL:Glossary:subtype]]// of **[[CL:Types:single-float]]**. A //[[CL:Glossary:complex single float]]// is a //[[CL:Glossary:complex]]//, but it is not a //[[CL:Glossary:single float]]//. ===composite stream=== //n.// * a //[[CL:Glossary:stream]]// that is composed of one or more other //[[CL:Glossary:stream|streams]]//. "**[[CL:Functions:make-synonym-stream]]** creates a composite stream." ===component=== //n.// * 1. //Idiom.// a constituent part of an //[[CL:Glossary:object]]//. * 2. a constituent part of a //[[CL:Glossary:structure]]//. See **[[CL:Macros:defstruct]]**. * 3. a //[[CL:Glossary:slot]]//. **Editor Note:** //This glossary entry is not a part of the original specification and was added based on context.// ===compound form=== //n.// * a //[[CL:Glossary:non-empty]]// //[[CL:Glossary:list]]// which is a //[[CL:Glossary:form]]//: a //[[CL:Glossary:special form]]//, a //[[CL:Glossary:lambda form]]//, a //[[CL:Glossary:macro form]]//, or a //[[CL:Glossary:function form]]//. ===compound type specifier=== //n.// * a //[[CL:Glossary:type specifier]]// that is a //[[CL:Glossary:cons]]//; i.e. a //[[CL:Glossary:type specifier]]// that is not an //[[CL:Glossary:atomic type specifier]]//. "''([[CL:Types:vector]] [[CL:Types:single-float]])'' is a compound type specifier." ===concatenated stream=== //n.// * an //[[CL:Glossary:input]]// //[[CL:Glossary:stream]]// of //[[CL:Glossary:type]]// **[[CL:Types:concatenated-stream]]**. ===condition=== //n.// * 1. an //[[CL:Glossary:object]]// which represents a //[[CL:Glossary:situation]]// - usually, but not necessarily, during //[[CL:Glossary:signal|signaling]]//. * 2. an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:condition]]**. ===condition designator=== //n.// * one or more //[[CL:Glossary:object|objects]]// that, taken together, denote either an existing //[[CL:Glossary:condition]]// //[[CL:Glossary:object]]// or a //[[CL:Glossary:condition]]// //[[CL:Glossary:object]]// to be implicitly created. For details, \seesection\ConditionDesignators. ===condition handler=== //n.// * a //[[CL:Glossary:function]]// that might be invoked by the act of //[[CL:Glossary:signal|signaling]]//, that receives the //[[CL:Glossary:condition]]// being signaled as its only argument, and that is permitted to //[[CL:Glossary:handle]]// the //[[CL:Glossary:condition]]// or to //[[CL:Glossary:decline]]//. \Seesection\Signaling. ===condition reporter=== //n.// * a //[[CL:Glossary:function]]// that describes how a //[[CL:Glossary:condition]]// is to be printed when the //[[CL:Glossary:Lisp printer]]// is invoked while **[[CL:Variables:star-print-escape-star|*print-escape*]]** is //[[CL:Glossary:false]]//. \Seesection\PrintingConditions. ===conditional newline=== //n.// * a point in output where a //[[CL:Glossary:newline]]// might be inserted at the discretion of the //[[CL:Glossary:pretty printer]]//. There are four kinds of //[[CL:Glossary:conditional newline|conditional newlines]]//, called "linear-style," "fill-style," "miser-style," and "mandatory-style." See **[[CL:Functions:pprint-newline]]** and \secref\DynamicControlofOutput. ===conformance=== //n.// * a state achieved by proper and complete adherence to the requirements of this specification. \Seesection\Conformance. ===conforming code=== //n.// * //[[CL:Glossary:code]]// that is all of part of a //[[CL:Glossary:conforming program]]//. ===conforming implementation=== //n.// * an //[[CL:Glossary:implementation]]//, used to emphasize complete and correct adherance to all conformance criteria. A //[[CL:Glossary:conforming implementation]]// is capable of accepting a //[[CL:Glossary:conforming program]]// as input, preparing that //[[CL:Glossary:program]]// for //[[CL:Glossary:execute|execution]]//, and executing the prepared //[[CL:Glossary:program]]// in accordance with this specification. An //[[CL:Glossary:implementation]]// which has been extended may still be a //[[CL:Glossary:conforming implementation]]// provided that no extension interferes with the correct function of any //[[CL:Glossary:conforming program]]//. ===conforming processor=== //n.//, //ANSI// * a //[[CL:Glossary:conforming implementation]]//. ===conforming program=== //n.// * a //[[CL:Glossary:program]]//, used to emphasize the fact that the //[[CL:Glossary:program]]// depends for its correctness only upon documented aspects of Common Lisp, and can therefore be expected to run correctly in any //[[CL:Glossary:conforming implementation]]//. ===congruent=== //n.// * conforming to the rules of //[[CL:Glossary:lambda list]]// congruency, as detailed in \secref\GFMethodLambdaListCongruency. ===cons=== //n.//, //v.// * 1. //n.// a compound data //[[CL:Glossary:object]]// having two components called the //[[CL:Glossary:car]]// and the //[[CL:Glossary:cdr]]//. * 2. //v.// to create such an //[[CL:Glossary:object]]//. * 3. //v.// //Idiom.// to create any //[[CL:Glossary:object]]//, or to allocate storage. ===constant=== //n.// * 1. a //[[CL:Glossary:constant form]]//. * 2. a //[[CL:Glossary:constant variable]]//. * 3. a //[[CL:Glossary:constant object]]//. * 4. a //[[CL:Glossary:self-evaluating object]]//. ===constant form=== //n.// * any //[[CL:Glossary:form]]// for which //[[CL:Glossary:evaluation]]// always //[[CL:Glossary:yield|yields]]// the same //[[CL:Glossary:value]]//, that neither affects nor is affected by the //[[CL:Glossary:environment]]// in which it is //[[CL:Glossary:evaluate|evaluated]]// (except that it is permitted to refer to the names of //[[CL:Glossary:constant variable|constant variables]]// defined in the //[[CL:Glossary:environment]]//), and that neither affects nor is affected by the state of any //[[CL:Glossary:object]]// except those //[[CL:Glossary:object|objects]]// that are //[[CL:Glossary:otherwise inaccessible part|otherwise inaccessible parts]]// of //[[CL:Glossary:object|objects]]// created by the //[[CL:Glossary:form]]// itself. "A **[[CL:Functions:car]]** form in which the argument is a **[[CL:Special Operators:quote]]** form is a constant form." ===constant object=== //n.// * an //[[CL:Glossary:object]]// that is constrained (e.g. by its context in a //[[CL:Glossary:program]]// or by the source from which it was obtained) to be //[[CL:Glossary:immutable]]//. "A literal object that has been processed by **[[CL:Functions:compile-file]]** is a constant object." ===constant variable=== //n.// * a //[[CL:Glossary:variable]]//, the //[[CL:Glossary:value]]// of which can never change; that is, a //[[CL:Glossary:keyword|keyword<sub>1</sub>]]// or a //[[CL:Glossary:named constant]]//. "The symbols **[[CL:Constant Variables:t]]**, **[[CL:Constant Variables:nil]]**, **'':direction''**, and **[[CL:Constant Variables:most-positive-fixnum]]**\ are constant variables." ===constituent=== //n.//, //adj.// * 1. * a. //n.// the //[[CL:Glossary:syntax type]]// of a //[[CL:Glossary:character]]// that is part of a //[[CL:Glossary:token]]//. For details, \seesection\ConstituentChars. * b. //adj.// (of a //[[CL:Glossary:character]]//) having the //[[CL:Glossary:constituent|constituent<sub>1a</sub>]]// //[[CL:Glossary:syntax type|syntax type<sub>2</sub>]]//. * c. //n.// a //[[CL:Glossary:constituent|constituent<sub>1b</sub>]]// //[[CL:Glossary:character]]//. * 2. //n.// (of a //[[CL:Glossary:composite stream]]//) one of possibly several //[[CL:Glossary:object|objects]]// that collectively comprise the source or sink of that //[[CL:Glossary:stream]]//. ===constituent trait=== //n.// (of a //[[CL:Glossary:character]]//) * one of several classifications of a //[[CL:Glossary:constituent]]// //[[CL:Glossary:character]]// in a //[[CL:Glossary:readtable]]//. \Seesection\ConstituentChars. ===constructed stream=== //n.// * a //[[CL:Glossary:stream]]// whose source or sink is a Lisp //[[CL:Glossary:object]]//. Note that since a //[[CL:Glossary:stream]]// is another Lisp //[[CL:Glossary:object]]//, //[[CL:Glossary:composite stream|composite streams]]// are considered //[[CL:Glossary:constructed stream|constructed streams]]//. "A string stream is a constructed stream." ===contagion=== //n.// * a process whereby operations on //[[CL:Glossary:object|objects]]// of differing //[[CL:Glossary:type|types]]// (e.g. arithmetic on mixed //[[CL:Glossary:type|types]]// of //[[CL:Glossary:number|numbers]]//) produce a result whose //[[CL:Glossary:type]]// is controlled by the dominance of one //[[CL:Glossary:argument]]//'s //[[CL:Glossary:type]]// over the //[[CL:Glossary:type|types]]// of the other //[[CL:Glossary:argument|arguments]]//. \Seesection\NumericContagionRules. ===continuable=== //n.// (of an //[[CL:Glossary:error]]//) * an //[[CL:Glossary:error]]// that is //[[CL:Glossary:correctable]]// by the **[[CL:Restarts:continue]]** restart. ===control form=== //n.// * 1. a //[[CL:Glossary:form]]// that establishes one or more places to which control can be transferred. * 2. a //[[CL:Glossary:form]]// that transfers control. ===copy=== //n.// * 1. (of a //[[CL:Glossary:cons]]// //C//) a //[[CL:Glossary:fresh]]// //[[CL:Glossary:cons]]// with the //[[CL:Glossary:same]]// //[[CL:Glossary:car]]// and //[[CL:Glossary:cdr]]// as //C//. * 2. (of a //[[CL:Glossary:list]]// //L//) a //[[CL:Glossary:fresh]]// //[[CL:Glossary:list]]// with the //[[CL:Glossary:same]]// //[[CL:Glossary:element|elements]]// as //L//. (Only the //[[CL:Glossary:list structure]]// is //[[CL:Glossary:fresh]]//; the //[[CL:Glossary:element|elements]]// are the //[[CL:Glossary:same]]//.) See **[[CL:Functions:copy-list]]**. * 3. (of an //[[CL:Glossary:association list]]// //A// with //[[CL:Glossary:element|elements]]// //A<sub>i</sub>//) a //[[CL:Glossary:fresh]]// //[[CL:Glossary:list]]// //B// with //[[CL:Glossary:element|elements]]// //B<sub>i</sub>//, each of which is **[[CL:Constant Variables:nil]]** if //A<sub>i</sub>// is **[[CL:Constant Variables:nil]]**, or else a //[[CL:Glossary:copy]]// of the //[[CL:Glossary:cons]]// //A<sub>i</sub>//. See **[[CL:Functions:copy-alist]]**. * 4. (of a //[[CL:Glossary:tree]]// //T//) a //[[CL:Glossary:fresh]]// //[[CL:Glossary:tree]]// with the //[[CL:Glossary:same]]// //[[CL:Glossary:leaf|leaves]]// as //T//. See **[[CL:Functions:copy-tree]]**. * 5. (of a //[[CL:Glossary:random state]]// //R//) a //[[CL:Glossary:fresh]]// //[[CL:Glossary:random state]]// that, if used as an argument to to the //[[CL:Glossary:function]]// **[[CL:Functions:random]]** would produce the same series of "random" values as //R// would produce. * 6. (of a //[[CL:Glossary:structure]]// //S//) a //[[CL:Glossary:fresh]]// //[[CL:Glossary:structure]]// that has the same //[[CL:Glossary:type]]// as //S//, and that has slot values, each of which is the //[[CL:Glossary:same]]// as the corresponding slot value of //S//. (Note that since the difference between a //[[CL:Glossary:cons]]//, a //[[CL:Glossary:list]]//, and a //[[CL:Glossary:tree]]// is a matter of "view" or "intention," there can be no general-purpose //[[CL:Glossary:function]]// which, based solely on the //[[CL:Glossary:type]]// of an //[[CL:Glossary: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 //[[CL:Glossary:copy]]// of the given //[[CL:Glossary:list]]//" or "copy of the //[[CL:Glossary:list]]// //x//" imply the second definition.) \issue{DEFSTRUCT-COPIER:ARGUMENT-TYPE} ===correctable=== //adj.// (of an //[[CL:Glossary:error]]//) * 1. (by a //[[CL:Glossary:restart]]// other than **[[CL:Restarts:abort]]** that has been associated with the //[[CL:Glossary:error]]//) capable of being corrected by invoking that //[[CL:Glossary:restart]]//. "The function **[[CL:Functions:cerror]]** signals an error that is correctable by the **[[CL:Restarts:continue]]** //[[CL:Glossary:restart]]//." (Note that correctability is not a property of an //[[CL:Glossary:error]]// //[[CL:Glossary:object]]//, but rather a property of the //[[CL:Glossary:dynamic environment]]// that is in effect when the //[[CL:Glossary:error]]// is //[[CL:Glossary:signal|signaled]]//. Specifically, the //[[CL:Glossary:restart]]// is "associated with" the //[[CL:Glossary:error]]// //[[CL:Glossary:condition]]// //[[CL:Glossary:object]]//. \Seesection\AssocRestartWithCond.) * 2. (when no specific //[[CL:Glossary:restart]]// is mentioned) //[[CL:Glossary:correctable|correctable<sub>1</sub>]]// by at least one //[[CL:Glossary:restart]]//. "**[[CL:Functions:import]]** signals a correctable error of //[[CL:Glossary:type]]// **[[CL:Types:package-error]]** if any of the imported symbols has the same name as some distinct symbol already accessible in the package." \issue{CONDITION-RESTARTS:PERMIT-ASSOCIATION} ===current input base=== //n.// (in a //[[CL:Glossary:dynamic environment]]//) * the //[[CL:Glossary:radix]]// that is the //[[CL:Glossary:value]]// of **[[CL:Variables:star-read-base-star|*read-base*]]** in that //[[CL:Glossary:environment]]//, and that is the default //[[CL:Glossary:radix]]// employed by the //[[CL:Glossary:Lisp reader]]// and its related //[[CL:Glossary:function|functions]]//. ===current logical block=== //n.// * the context of the innermost lexically enclosing use of **[[CL:Macros:pprint-logical-block]]**. ===current output base=== //n.// (in a //[[CL:Glossary:dynamic environment]]//) * the //[[CL:Glossary:radix]]// that is the //[[CL:Glossary:value]]// of **[[CL:Variables:star-print-base-star|*print-base*]]** in that //[[CL:Glossary:environment]]//, and that is the default //[[CL:Glossary:radix]]// employed by the //[[CL:Glossary:Lisp printer]]// and its related //[[CL:Glossary:function|functions]]//. ===current package=== //n.// (in a //[[CL:Glossary:dynamic environment]]//) * the //[[CL:Glossary:package]]// that is the //[[CL:Glossary:value]]// of **[[CL:Variables:star-package-star|*package*]]** in that //[[CL:Glossary:environment]]//, and that is the default //[[CL:Glossary:package]]// employed by the //[[CL:Glossary:Lisp reader]]// and //[[CL:Glossary:Lisp printer]]//, and their related //[[CL:Glossary:function|functions]]//. ===current pprint dispatch table=== //n.// (in a //[[CL:Glossary:dynamic environment]]//) * the //[[CL:Glossary:pprint dispatch table]]// that is the //[[CL:Glossary:value]]// of **[[CL:Variables:star-print-pprint-dispatch-star|*print-pprint-dispatch*]]** in that //[[CL:Glossary:environment]]//, and that is the default //[[CL:Glossary:pprint dispatch table]]// employed by the //[[CL:Glossary:pretty printer]]//. ===current random state=== //n.// (in a //[[CL:Glossary:dynamic environment]]//) * the //[[CL:Glossary:random state]]// that is the //[[CL:Glossary:value]]// of **[[CL:Variables:star-random-state-star|*random-state*]]** in that //[[CL:Glossary:environment]]//, and that is the default //[[CL:Glossary:random state]]// employed by **[[CL:Functions:random]]**. ===current readtable=== //n.// (in a //[[CL:Glossary:dynamic environment]]//) * the //[[CL:Glossary:readtable]]// that is the //[[CL:Glossary:value]]// of **[[CL:Variables:star-readtable-star|*readtable*]]** in that //[[CL:Glossary:environment]]//, and that affects the way in which //[[CL:Glossary:expression|expressions<sub>2</sub>]]// are parsed into //[[CL:Glossary:object|objects]]// by the //[[CL:Glossary:Lisp reader]]//. =====D===== ===data type=== //n.//, //Trad.// * a //[[CL:Glossary:type]]//. ===debug I/O=== //n.// * the //[[CL:Glossary:bidirectional]]// //[[CL:Glossary:stream]]// that is the //[[CL:Glossary:value]]// of the //[[CL:Glossary:variable]]// **[[CL:Variables:star-debug-io-star|*debug-io*]]**. ===debugger=== //n.// * a facility that allows the //[[CL:Glossary:user]]// to handle a //[[CL:Glossary:condition]]// interactively. For example, the //[[CL:Glossary:debugger]]// might permit interactive selection of a //[[CL:Glossary:restart]]// from among the //[[CL:Glossary:active]]// //[[CL:Glossary:restart|restarts]]//, and it might perform additional //[[CL:Glossary:implementation-defined]]// services for the purposes of debugging. ===declaration=== //n.// * a //[[CL:Glossary:global declaration]]// or //[[CL:Glossary:local declaration]]//. ===declaration identifier=== //n.// * one of the //[[CL:Glossary:symbol|symbols]]// **[[CL:Declarations:declaration]]**, **[[CL:Declarations:dynamic-extent]]**, **[[CL:Declarations:ftype]]**, **[[CL:Declarations:ignore]]**, **[[CL:Declarations:inline]]**, **[[CL:Declarations:notinline]]**, **[[CL:Declarations:optimize]]**, **[[CL:Declarations:special]]**, or **[[CL:Declarations:type]]**; or a //[[CL:Glossary:symbol]]// which is the //[[CL:Glossary:name]]// of a //[[CL:Glossary:type]]//; or a //[[CL:Glossary:symbol]]// which has been //[[CL:Glossary:declare|declared]]// to be a //[[CL:Glossary:declaration identifier]]// by using a **[[CL:Declarations:declaration]]** //[[CL:Glossary:declaration]]//. \issue{SYNTACTIC-ENVIRONMENT-ACCESS:RETRACTED-MAR91} ===declaration specifier=== //n.// * an //[[CL:Glossary:expression]]// that can appear at top level of a **[[CL:Symbols:declare]]** expression or a **[[CL:Macros:declaim]]** form, or as the argument to **[[CL:Functions:proclaim]]**, and which has a //[[CL:Glossary:car]]// which is a //[[CL:Glossary:declaration identifier]]//, and which has a //[[CL:Glossary:cdr]]// that is data interpreted according to rules specific to the //[[CL:Glossary:declaration identifier]]//. ===declare=== //v.// * to //[[CL:Glossary:establish]]// a //[[CL:Glossary:declaration]]//. See **[[CL:Symbols:declare]]**, **[[CL:Macros:declaim]]**, or **[[CL:Functions:proclaim]]**. ===decline=== //v.// (of a //[[CL:Glossary:handler]]//) * to return normally without having //[[CL:Glossary:handle|handled]]// the //[[CL:Glossary:condition]]// being //[[CL:Glossary:signal|signaled]]//, permitting the signaling process to continue as if the //[[CL:Glossary:handler]]// had not been present. ===decoded time=== //n.// * //[[CL:Glossary:absolute]]// //[[CL:Glossary:time]]//, represented as an ordered series of nine //[[CL:Glossary:object|objects]]// which, taken together, form a description of a point in calendar time, accurate to the nearest second (except that //[[CL:Glossary:leap seconds]]// are ignored). \Seesection\DecodedTime. ===default method=== //n.// * a //[[CL:Glossary:method]]// having no //[[CL:Glossary:parameter specializer|parameter specializers]]// other than the //[[CL:Glossary:class]]// **[[CL:Types:t]]**. Such a //[[CL:Glossary:method]]// is always an //[[CL:Glossary:applicable method]]// but might be //[[CL:Glossary:shadow|shadowed<sub>2</sub>]]// by a more specific //[[CL:Glossary:method]]//. ===defaulted initialization argument list=== //n.// * a //[[CL:Glossary:list]]// of alternating initialization argument //[[CL:Glossary:name|names]]// and //[[CL:Glossary:value|values]]// in which unsupplied initialization arguments are defaulted, used in the protocol for initializing and reinitializing //[[CL:Glossary:instance|instances]]// of //[[CL:Glossary:class|classes]]//. ===define-method-combination arguments lambda list=== //n.// * a //[[CL:Glossary:lambda list]]// used by the **'':arguments''** option to **[[CL:Macros:define-method-combination]]**. \Seesection\DefMethCombArgsLambdaLists. ===define-modify-macro lambda list=== //n.// * a //[[CL:Glossary:lambda list]]// used by **[[CL:Macros:define-modify-macro]]**. \Seesection\DefineModifyMacroLambdaLists. ===defined name=== //n.// * a //[[CL:Glossary:symbol]]// the meaning of which is defined by Common Lisp. ===defining form=== //n.// * a //[[CL:Glossary:form]]// that has the side-effect of //[[CL:Glossary:establish|establishing]]// a definition. "**[[CL:Macros:defun]]** and **[[CL:Macros:defparameter]]** are defining forms." ===defsetf lambda list=== //n.// * a //[[CL:Glossary:lambda list]]// that is like an //[[CL:Glossary:ordinary lambda list]]// except that it does not permit ''&body'' and that it permits use of ''&body''. \Seesection\DefsetfLambdaLists. ===deftype lambda list=== //n.// * a //[[CL:Glossary:lambda list]]// that is like a //[[CL:Glossary:macro lambda list]]// except that the default //[[CL:Glossary:value]]// for unsupplied //[[CL:Glossary:optional parameter|optional parameters]]// and //[[CL:Glossary:keyword parameter|keyword parameters]]// is the //[[CL:Glossary:symbol]]// **[[CL:Types:wildcard|*]]** (rather than **[[CL:Constant Variables:nil]]**). \Seesection\DeftypeLambdaLists. \issue{DEFTYPE-KEY:ALLOW} \issue{DEFTYPE-DESTRUCTURING:YES} ===denormalized=== //adj.//, //ANSI//, //IEEE// (of a //[[CL:Glossary:float]]//) * conforming to the description of "denormalized" as described by {\IEEEFloatingPoint}. For example, in an //[[CL:Glossary: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 //[[CL:Glossary:normalized]]// representation would call for it to be represented instead as ''1.0e-10'' or ''0.1e-9''. By their nature, //[[CL:Glossary:denormalized]]// //[[CL:Glossary:float|floats]]// generally have less precision than //[[CL:Glossary:normalized]]// //[[CL:Glossary:float|floats]]//. ===derived type=== //n.// * a //[[CL:Glossary:type specifier]]// which is defined in terms of an expansion into another //[[CL:Glossary:type specifier]]//. **[[CL:Macros:deftype]]** defines //[[CL:Glossary:derived type|derived types]]//, and there may be other //[[CL:Glossary:implementation-defined]]// //[[CL:Glossary:operator|operators]]// which do so as well. ===derived type specifier=== //n.// * a //[[CL:Glossary:type specifier]]// for a //[[CL:Glossary:derived type]]//. ===designator=== //n.// * an //[[CL:Glossary:object]]// that denotes another //[[CL:Glossary:object]]//. In the dictionary entry for an //[[CL:Glossary:operator]]// if a //[[CL:Glossary:parameter]]// is described as a //[[CL:Glossary:designator]]// for a //[[CL:Glossary:type]]//, the description of the //[[CL:Glossary:operator]]// is written in a way that assumes that appropriate coercion to that //[[CL:Glossary:type]]// has already occurred; that is, that the //[[CL:Glossary:parameter]]// is already of the denoted //[[CL:Glossary:type]]//. For more detailed information, \seesection\Designators. ===destructive=== //adj.// (of an //[[CL:Glossary:operator]]//) * capable of modifying some program-visible aspect of one or more //[[CL:Glossary:object|objects]]// that are either explicit //[[CL:Glossary:argument|arguments]]// to the //[[CL:Glossary:operator]]// or that can be obtained directly or indirectly from the //[[CL:Glossary:global environment]]// by the //[[CL:Glossary:operator]]//. ===destructuring lambda list=== //n.// * an //[[CL:Glossary:extended lambda list]]// used in **[[CL:Macros:destructuring-bind]]** and nested within //[[CL:Glossary:macro lambda list|macro lambda lists]]//. \Seesection\DestructuringLambdaLists. ===different=== //adj.// * not the //[[CL:Glossary:same]]// "The strings ''"FOO"'' and ''"foo"'' are different under **[[CL:Functions:equal]]** but not under **[[CL:Functions:equalp]]**." ===digit=== //n.// (in a //[[CL:Glossary:radix]]//) * a //[[CL:Glossary: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 //[[CL:Glossary:radix]]//. \Seesection\Digits. ===dimension=== //n.// * 1. a non-negative //[[CL:Glossary:integer]]// indicating the number of //[[CL:Glossary:object|objects]]// an //[[CL:Glossary:array]]// can hold along one axis. If the //[[CL:Glossary:array]]// is a //[[CL:Glossary:vector]]// with a //[[CL:Glossary:fill pointer]]//, the //[[CL:Glossary: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 //[[CL:Glossary:class]]// //C//) * an //[[CL:Glossary:object]]// whose //[[CL:Glossary:class]]// is //C// itself, rather than some //[[CL:Glossary:subclass]]// of //C//. "The function **[[CL:Functions:make-instance]]** always returns a direct instance of the class which is (or is named by) its first argument." ===direct subclass=== //n.// (of a //[[CL:Glossary:class]]// //C<sub>1</sub>//) * a //[[CL:Glossary:class]]// //C<sub>2</sub>//, such that //C<sub>1</sub>// is a //[[CL:Glossary:direct superclass]]// of //C<sub>2</sub>//. ===direct superclass=== //n.// (of a //[[CL:Glossary:class]]// //C<sub>1</sub>//) * a //[[CL:Glossary:class]]// //C<sub>2</sub>// which was explicitly designated as a //[[CL:Glossary:superclass]]// of //C<sub>1</sub>// in the definition of //C<sub>1</sub>//. ===disestablish=== //v.t.// * to withdraw the //[[CL:Glossary:establish|establishment]]// of an //[[CL:Glossary:object]]//, a //[[CL:Glossary:binding]]//, an //[[CL:Glossary:exit point]]//, a //[[CL:Glossary:tag]]//, a //[[CL:Glossary:handler]]//, a //[[CL:Glossary:restart]]//, or an //[[CL:Glossary:environment]]//. ===disjoint=== //n.// (of //[[CL:Glossary:type|types]]//) * having no //[[CL:Glossary:element|elements]]// in common. ===dispatching macro character=== //n.// * a //[[CL:Glossary:macro character]]// that has an associated table that specifies the //[[CL:Glossary:function]]// to be called for each //[[CL:Glossary:character]]// that is seen following the //[[CL:Glossary:dispatching macro character]]//. See **[[CL:Functions:make-dispatch-macro-character]]**. ===displaced array=== //n.// * an //[[CL:Glossary:array]]// which has no storage of its own, but which is instead indirected to the storage of another //[[CL:Glossary:array]]//, called its //[[CL:Glossary:target]]//, at a specified offset, in such a way that any attempt to //[[CL:Glossary:access]]// the //[[CL:Glossary:displaced array]]// implicitly references the //[[CL:Glossary:target]]// //[[CL:Glossary:array]]//. ===distinct=== //adj.// * not //[[CL:Glossary:identical]]//. ===documentation string=== //n.// (in a defining //[[CL:Glossary:form]]//) * a //[[CL:Glossary:literal]]// //[[CL:Glossary:string]]// which because of the context in which it appears (rather than because of some intrinsically observable aspect of the //[[CL:Glossary:string]]//) is taken as documentation. In some cases, the //[[CL:Glossary:documentation string]]// is saved in such a way that it can later be obtained by supplying either an //[[CL:Glossary:object]]//, or by supplying a //[[CL:Glossary:name]]// and a "kind" to the //[[CL:Glossary:function]]// **[[CL:Functions:documentation]]**. "The body of code in a **[[CL:Macros:defmacro]]** form can be preceded by a documentation string of kind **[[CL:Types:function]]**." ===dot=== //n.// * the //[[CL:Glossary:standard character]]// that is variously called "full stop," "period," or "dot" (''.''). \Seefigure\StdCharsThree. ===dotted list=== //n.// * a //[[CL:Glossary:list]]// which has a terminating //[[CL:Glossary:atom]]// that is not **[[CL:Constant Variables:nil]]**. (An //[[CL:Glossary:atom]]// by itself is not a //[[CL:Glossary:dotted list]]//, however.) ===dotted pair=== //n.// * 1. a //[[CL:Glossary:cons]]// whose //[[CL:Glossary:cdr]]// is a //[[CL:Glossary:non-list]]//. * 2. any //[[CL:Glossary:cons]]//, used to emphasize the use of the //[[CL:Glossary:cons]]// as a symmetric data pair. ===double float=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:double-float]]**. ===double-quote=== //n.// * the //[[CL:Glossary:standard character]]// that is variously called "quotation mark" or "double quote" (''"''). \Seefigure\StdCharsThree. ===dynamic binding=== //n.// * a //[[CL:Glossary:binding]]// in a //[[CL:Glossary:dynamic environment]]//. ===dynamic environment=== //n.// * that part of an //[[CL:Glossary:environment]]// that contains //[[CL:Glossary:binding|bindings]]// with //[[CL:Glossary:dynamic extent]]//. A //[[CL:Glossary:dynamic environment]]// contains, among other things: //[[CL:Glossary:exit point|exit points]]// established by **[[CL:Special Operators:unwind-protect]]**, and //[[CL:Glossary:binding|bindings]]// of //[[CL:Glossary:dynamic variable|dynamic variables]]//, //[[CL:Glossary:exit point|exit points]]// established by **[[CL:Special Operators:catch]]**, //[[CL:Glossary:condition handler|condition handlers]]//, and //[[CL:Glossary:restart|restarts]]//. ===dynamic extent=== //n.// * an //[[CL:Glossary:extent]]// whose duration is bounded by points of //[[CL:Glossary:establish|establishment]]// and //[[CL:Glossary:disestablish|disestablishment]]// within the execution of a particular //[[CL:Glossary:form]]//. See //[[CL:Glossary:indefinite extent]]//. "Dynamic variable bindings have dynamic extent." ===dynamic scope=== //n.// * //[[CL:Glossary:indefinite scope]]// along with //[[CL:Glossary:dynamic extent]]//. ===dynamic variable=== //n.// * a //[[CL:Glossary:variable]]// the //[[CL:Glossary:binding]]// for which is in the //[[CL:Glossary:dynamic environment]]//. See **[[CL:Declarations:special]]**. =====E===== ===echo stream=== //n.// * a //[[CL:Glossary:stream]]// of //[[CL:Glossary:type]]// **[[CL:Types:echo-stream]]**. ===effective method=== //n.// * the combination of //[[CL:Glossary:applicable method|applicable methods]]// that are executed when a //[[CL:Glossary:generic function]]// is invoked with a particular sequence of //[[CL:Glossary:argument|arguments]]//. ===element=== //n.// * 1. (of a //[[CL:Glossary:list]]//) an //[[CL:Glossary:object]]// that is the //[[CL:Glossary:car]]// of one of the //[[CL:Glossary:cons|conses]]// that comprise the //[[CL:Glossary:list]]//. * 2. (of an //[[CL:Glossary:array]]//) an //[[CL:Glossary:object]]// that is stored in the //[[CL:Glossary:array]]//. * 3. (of a //[[CL:Glossary:sequence]]//) an //[[CL:Glossary:object]]// that is an //[[CL:Glossary:element]]// of the //[[CL:Glossary:list]]// or //[[CL:Glossary:array]]// that is the //[[CL:Glossary:sequence]]//. * 4. (of a //[[CL:Glossary:type]]//) an //[[CL:Glossary:object]]// that is a member of the set of //[[CL:Glossary:object|objects]]// designated by the //[[CL:Glossary:type]]//. * 5. (of an //[[CL:Glossary:input]]// //[[CL:Glossary:stream]]//) a //[[CL:Glossary:character]]// or //[[CL:Glossary:number]]// (as appropriate to the //[[CL:Glossary:element type]]// of the //[[CL:Glossary:stream]]//) that is among the ordered series of //[[CL:Glossary:object|objects]]// that can be read from the //[[CL:Glossary:stream]]// (using **[[CL:Functions:read-char]]** or **[[CL:Functions:read-byte]]**, as appropriate to the //[[CL:Glossary:stream]]//). * 6. (of an //[[CL:Glossary:output]]// //[[CL:Glossary:stream]]//) a //[[CL:Glossary:character]]// or //[[CL:Glossary:number]]// (as appropriate to the //[[CL:Glossary:element type]]// of the //[[CL:Glossary:stream]]//) that is among the ordered series of //[[CL:Glossary:object|objects]]// that has been or will be written to the //[[CL:Glossary:stream]]// (using **[[CL:Functions:write-char]]** or **[[CL:Functions:write-byte]]**, as appropriate to the //[[CL:Glossary:stream]]//). * 7. (of a //[[CL:Glossary:class]]//) a //[[CL:Glossary:generalized instance]]// of the //[[CL:Glossary:class]]//. ===element type=== //n.// * 1. (of an //[[CL:Glossary:array]]//) the //[[CL:Glossary:array element type]]// of the //[[CL:Glossary:array]]//. * 2. (of a //[[CL:Glossary:stream]]//) the //[[CL:Glossary:stream element type]]// of the //[[CL:Glossary: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 //[[CL:Glossary:glyph]]// in the font, and other characters' widths are typically fractions of an //[[CL:Glossary:em]]//. In implementations providing non-Roman characters with wider characters than "M," it is permissible for another character to be the //[[CL:Glossary:implementation-defined]]// reference character for this measure, and for "M" to be only a fraction of an //[[CL:Glossary:em]]// wide.) In a fixed width font, a line with //n// characters is //n// //[[CL:Glossary:em]]// wide; in a variable width font, //n// //[[CL:Glossary:em]]// is the expected upper bound on the width of such a line. ===empty list=== //n.// * the //[[CL:Glossary:list]]// containing no //[[CL:Glossary:element|elements]]//. See //[[CL:Glossary:()]]//. ===empty type=== //n.// * the //[[CL:Glossary:type]]// that contains no //[[CL:Glossary:element|elements]]//, and that is a //[[CL:Glossary:subtype]]// of all //[[CL:Glossary:type|types]]// (including itself). See //[[CL:Glossary:nil]]//. ===end of file=== //n.// * 1. the point in an //[[CL:Glossary:input]]// //[[CL:Glossary:stream]]// beyond which there is no further data. Whether or not there is such a point on an //[[CL:Glossary:interactive stream]]// is //[[CL:Glossary:implementation-defined]]//. * 2. a //[[CL:Glossary:situation]]// that occurs upon an attempt to obtain data from an //[[CL:Glossary:input]]// //[[CL:Glossary:stream]]// that is at the //[[CL:Glossary:end of file|end of file<sub>1</sub>]]//. ===environment=== //n.// * 1. a set of //[[CL:Glossary:binding|bindings]]//. \Seesection\IntroToEnvs. * 2. an //[[CL:Glossary:environment object]]//. "**[[CL:Functions:macroexpand]]** takes an optional environment argument." ===environment object=== //n.// * an //[[CL:Glossary:object]]// representing a set of //[[CL:Glossary:lexical binding|lexical bindings]]//, used in the processing of a //[[CL:Glossary:form]]// to provide meanings for //[[CL:Glossary:name|names]]// within that //[[CL:Glossary:form]]//. "**[[CL:Functions:macroexpand]]** takes an optional environment argument." (The //[[CL:Glossary:object]]// **[[CL:Constant Variables:nil]]** when used as an //[[CL:Glossary:environment object]]// denotes the //[[CL:Glossary:null lexical environment]]//; the //[[CL:Glossary:value|values]]// of //[[CL:Glossary:environment parameter|environment parameters]]// to //[[CL:Glossary:macro function|macro functions]]// are //[[CL:Glossary:object|objects]]// of //[[CL:Glossary:implementation-dependent]]// nature which represent the //[[CL:Glossary:environment|environment<sub>1</sub>]]// in which the corresponding //[[CL:Glossary:macro form]]// is to be expanded.) \Seesection\EnvObjs. ===environment parameter=== //n.// * a //[[CL:Glossary:parameter]]// in a //[[CL:Glossary:defining form]]// //f// for which there is no corresponding //[[CL:Glossary:argument]]//; instead, this //[[CL:Glossary:parameter]]// receives as its value an //[[CL:Glossary:environment]]// //[[CL:Glossary:object]]// which corresponds to the //[[CL:Glossary:lexical environment]]// in which the //[[CL:Glossary:defining form]]// //f// appeared. ===error=== //n.// * 1. (only in the phrase "is an error") a //[[CL:Glossary:situation]]// in which the semantics of a program are not specified, and in which the consequences are undefined. * 2. a //[[CL:Glossary:condition]]// which represents an //[[CL:Glossary:error]]// //[[CL:Glossary:situation]]//. \Seesection\ErrorTerms. * 3. an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:error]]**. ===error output=== //n.// * the //[[CL:Glossary:output]]// //[[CL:Glossary:stream]]// which is the //[[CL:Glossary:value]]// of the //[[CL:Glossary:dynamic variable]]// **[[CL:Variables:star-error-output-star|*error-output*]]**. ===escape=== //n.//, //adj.// * 1. //n.// a //[[CL:Glossary:single escape]]// or a //[[CL:Glossary:multiple escape]]//. * 2. //adj.// //[[CL:Glossary:single escape]]// or //[[CL:Glossary:multiple escape]]//. ===establish=== //v.t.// * to build or bring into being a //[[CL:Glossary:binding]]//, a //[[CL:Glossary:declaration]]//, an //[[CL:Glossary:exit point]]//, a //[[CL:Glossary:tag]]//, a //[[CL:Glossary:handler]]//, a //[[CL:Glossary:restart]]//, or an //[[CL:Glossary:environment]]//. "**[[CL:Special Operators:let]]** establishes lexical bindings." ===evaluate=== //v.t.// (a //[[CL:Glossary:form]]// or an //[[CL:Glossary:implicit progn]]//) * to //[[CL:Glossary:execute]]// the //[[CL:Glossary:code]]// represented by the //[[CL:Glossary:form]]// (or the series of //[[CL:Glossary:form|forms]]// making up the //[[CL:Glossary:implicit progn]]//) by applying the rules of //[[CL:Glossary:evaluation]]//, returning zero or more values. ===evaluation=== //n.// * a model whereby //[[CL:Glossary:form|forms]]// are //[[CL:Glossary:execute|executed]]//, returning zero or more values. Such execution might be implemented directly in one step by an interpreter or in two steps by first //[[CL:Glossary:compile|compiling]]// the //[[CL:Glossary:form]]// and then //[[CL:Glossary:execute|executing]]// the //[[CL:Glossary:compile|compiled]]// //[[CL:Glossary:code]]//; this choice is dependent both on context and the nature of the //[[CL:Glossary:implementation]]//, but in any case is not in general detectable by any program. The evaluation model is designed in such a way that a //[[CL:Glossary:conforming implementation]]// might legitimately have only a compiler and no interpreter, or vice versa. \Seesection\EvaluationModel. ===evaluation environment=== //n.// * a //[[CL:Glossary:run-time environment]]// in which macro expanders and code specified by **[[CL:Special Operators:eval-when]]** to be evaluated are evaluated. All evaluations initiated by the //[[CL:Glossary:compiler]]// take place in the //[[CL:Glossary:evaluation environment]]//. ===execute=== //v.t.// //Trad.// (//[[CL:Glossary:code]]//) * to perform the imperative actions represented by the //[[CL:Glossary:code]]//. ===execution time=== //n.// * the duration of time that //[[CL:Glossary:compile|compiled code]]// is being //[[CL:Glossary:execute|executed]]//. ===exhaustive partition=== //n.// (of a //[[CL:Glossary:type]]//) * a set of //[[CL:Glossary:pairwise]]// //[[CL:Glossary:disjoint]]// //[[CL:Glossary:type|types]]// that form an //[[CL:Glossary:exhaustive union]]//. ===exhaustive union=== //n.// (of a //[[CL:Glossary:type]]//) * a set of //[[CL:Glossary:subtype|subtypes]]// of the //[[CL:Glossary:type]]//, whose union contains all //[[CL:Glossary:element|elements]]// of that //[[CL:Glossary:type]]//. ===exit point=== //n.// * a point in a //[[CL:Glossary:control form]]// from which (e.g. **[[CL:Special Operators:block]]**), through which (e.g. **[[CL:Special Operators:unwind-protect]]**), or to which (e.g. **[[CL:Special Operators:tagbody]]**) control and possibly //[[CL:Glossary:value|values]]// can be transferred both actively by using another //[[CL:Glossary:control form]]// and passively through the normal control and data flow of //[[CL:Glossary:evaluation]]//. "**[[CL:Special Operators:catch]]** and **[[CL:Special Operators:block]]** establish bindings for exit points to which **[[CL:Special Operators:throw]]** and **[[CL:Special Operators:return-from]]**, respectively, can transfer control and values; **[[CL:Special Operators:tagbody]]** establishes a binding for an exit point with lexical extent to which **[[CL:Special Operators:go]]** can transfer control; and **[[CL:Special Operators:unwind-protect]]** establishes an exit point through which control might be transferred by operators such as **[[CL:Special Operators:throw]]**, **[[CL:Special Operators:return-from]]**, and **[[CL:Special Operators:go]]**." ===explicit return=== //n.// * the act of transferring control (and possibly //[[CL:Glossary:value|values]]//) to a //[[CL:Glossary:block]]// by using **[[CL:Special Operators:return-from]]** (or **[[CL:Macros:return]]**). ===explicit use=== //n.// (of a //[[CL:Glossary:variable]]// //V// in a //[[CL:Glossary: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 //[[CL:Glossary:macro expansion]]// of the //[[CL:Glossary:form]]// itself. References to //V// exposed by expanding //[[CL:Glossary:subform|subforms]]// of //F// are, however, considered to be //[[CL:Glossary:explicit use|explicit uses]]// of //V//. ===exponent marker=== //n.// * a character that is used in the textual notation for a //[[CL:Glossary:float]]// to separate the mantissa from the exponent. The characters defined as //[[CL:Glossary:exponent marker|exponent markers]]// in the //[[CL:Glossary:standard readtable]]// are shown in the below table. For more information, \seesection\CharacterSyntax. "The exponent marker `d' in `3.0d7' indicates that this number is to be represented as a double float." ^ Marker ^ Meaning ^ | ''D'' or ''d'' | **[[CL:Types:double-float]]** | | ''E'' or ''e'' | **[[CL:Types:float]]** (see ** [[CL:Variables:star-read-default-float-format-star|*read-default-float-format*]]**) | | ''F'' or ''f'' | **[[CL:Types:single-float]]** | | ''L'' or ''l'' | **[[CL:Types:long-float]]** | | ''S'' or ''s'' | **[[CL:Types:short-float]]** | ===export=== //v.t.// (a //[[CL:Glossary:symbol]]// in a //[[CL:Glossary:package]]//) * to add the //[[CL:Glossary:symbol]]// to the list of //[[CL:Glossary:external symbol|external symbols]]// of the //[[CL:Glossary:package]]//. ===exported=== //adj.// (of a //[[CL:Glossary:symbol]]// in a //[[CL:Glossary:package]]//) * being an //[[CL:Glossary:external symbol]]// of the //[[CL:Glossary:package]]//. ===expressed adjustability=== //n.// (of an //[[CL:Glossary:array]]//) * a //[[CL:Glossary:generalized boolean]]// that is conceptually (but not necessarily actually) associated with the //[[CL:Glossary:array]]//, representing whether the //[[CL:Glossary:array]]// is //[[CL:Glossary:expressly adjustable]]//. See also //[[CL:Glossary:actual adjustability]]//. ===expressed array element type=== //n.// (of an //[[CL:Glossary:array]]//) * the //[[CL:Glossary:type]]// which is the //[[CL:Glossary:array element type]]// implied by a //[[CL:Glossary:type declaration]]// for the //[[CL:Glossary:array]]//, or which is the requested //[[CL:Glossary:array element type]]// at its time of creation, prior to any selection of an //[[CL:Glossary:upgraded array element type]]//. (Common Lisp does not provide a way of detecting this //[[CL:Glossary:type]]// directly at run time, but an //[[CL:Glossary:implementation]]// is permitted to make assumptions about the //[[CL:Glossary:array]]//'s contents and the operations which may be performed on the //[[CL:Glossary:array]]// when this //[[CL:Glossary:type]]// is noted during code analysis, even if those assumptions would not be valid in general for the //[[CL:Glossary:upgraded array element type]]// of the //[[CL:Glossary:expressed array element type]]//.) ===expressed complex part type=== //n.// (of a //[[CL:Glossary:complex]]//) * the //[[CL:Glossary:type]]// which is implied as the //[[CL:Glossary:complex part type]]// by a //[[CL:Glossary:type declaration]]// for the //[[CL:Glossary:complex]]//, or which is the requested //[[CL:Glossary:complex part type]]// at its time of creation, prior to any selection of an //[[CL:Glossary:upgraded complex part type]]//. (Common Lisp does not provide a way of detecting this //[[CL:Glossary:type]]// directly at run time, but an //[[CL:Glossary:implementation]]// is permitted to make assumptions about the operations which may be performed on the //[[CL:Glossary:complex]]// when this //[[CL:Glossary:type]]// is noted during code analysis, even if those assumptions would not be valid in general for the //[[CL:Glossary:upgraded complex part type]]// of the //[[CL:Glossary:expressed complex part type]]//.) ===expression=== //n.// * 1. an //[[CL:Glossary:object]]//, often used to emphasize the use of the //[[CL:Glossary:object]]// to encode or represent information in a specialized format, such as program text. "The second expression in a **[[CL:Special Operators:let]]** form is a list of bindings." * 2. the textual notation used to notate an //[[CL:Glossary:object]]// in a source file. "The expression ''<nowiki>'sample</nowiki>'' is equivalent to ''([[CL:Special Operators:quote]] sample)''." ===expressly adjustable=== //adj.// (of an //[[CL:Glossary:array]]//) * being //[[CL:Glossary:actually adjustable]]// by virtue of an explicit request for this characteristic having been made at the time of its creation. All //[[CL:Glossary:array|arrays]]// that are //[[CL:Glossary:expressly adjustable]]// are //[[CL:Glossary:actually adjustable]]//, but not necessarily vice versa. ===extended character=== //n.// a //[[CL:Glossary:character]]// of //[[CL:Glossary:type]]// **[[CL:Types:extended-char]]**: a //[[CL:Glossary:character]]// that is not a //[[CL:Glossary:base character]]//. \issue{CHARACTER-VS-CHAR:LESS-INCONSISTENT-SHORT} ===extended function designator=== //n.// * a //[[CL:Glossary:designator]]// for a //[[CL:Glossary:function]]//; that is, an //[[CL:Glossary:object]]// that denotes a //[[CL:Glossary:function]]// and that is one of: a //[[CL:Glossary:function name]]// (denoting the //[[CL:Glossary:function]]// it names in the //[[CL:Glossary:global environment]]//), or a //[[CL:Glossary:function]]// (denoting itself). The consequences are undefined if a //[[CL:Glossary:function name]]// is used as an //[[CL:Glossary:extended function designator]]// but it does not have a global definition as a //[[CL:Glossary:function]]//, or if it is a //[[CL:Glossary:symbol]]// that has a global definition as a //[[CL:Glossary:macro]]// or a //[[CL:Glossary:special form]]//. See also //[[CL:Glossary:function designator]]//. ===extended lambda list=== //n.// * a list resembling an //[[CL:Glossary:ordinary lambda list]]// in form and purpose, but offering additional syntax or functionality not available in an //[[CL:Glossary:ordinary lambda list]]//. "**[[CL:Macros:defmacro]]** uses extended lambda lists." ===extension=== //n.// * a facility in an //[[CL:Glossary:implementation]]// of Common Lisp that is not specified by this standard. ===extent=== //n.// * the interval of time during which a //[[CL:Glossary:reference]]// to an //[[CL:Glossary:object]]//, a //[[CL:Glossary:binding]]//, an //[[CL:Glossary:exit point]]//, a //[[CL:Glossary:tag]]//, a //[[CL:Glossary:handler]]//, a //[[CL:Glossary:restart]]//, or an //[[CL:Glossary:environment]]// is defined. ===external file format=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:implementation-dependent]]// nature which determines one of possibly several //[[CL:Glossary:implementation-dependent]]// ways in which //[[CL:Glossary:character|characters]]// are encoded externally in a //[[CL:Glossary:character]]// //[[CL:Glossary:file]]//. ===external file format designator=== //n.// * a //[[CL:Glossary:designator]]// for an //[[CL:Glossary:external file format]]//; that is, an //[[CL:Glossary:object]]// that denotes an //[[CL:Glossary:external file format]]// and that is one of: the //[[CL:Glossary:symbol]]// **'':default''** (denoting an //[[CL:Glossary:implementation-dependent]]// default //[[CL:Glossary:external file format]]// that can accomodate at least the //[[CL:Glossary:base character|base characters]]//), some other //[[CL:Glossary:object]]// defined by the //[[CL:Glossary:implementation]]// to be an //[[CL:Glossary:external file format designator]]// (denoting an //[[CL:Glossary:implementation-defined]]// //[[CL:Glossary:external file format]]//), or some other //[[CL:Glossary:object]]// defined by the //[[CL:Glossary:implementation]]// to be an //[[CL:Glossary:external file format]]// (denoting itself). ===external symbol=== //n.// (of a //[[CL:Glossary:package]]//) * a //[[CL:Glossary:symbol]]// that is part of the `external interface' to the //[[CL:Glossary:package]]// and that are //[[CL:Glossary:inherit|inherited|inherited<sub>3</sub>]]// by any other //[[CL:Glossary:package]]// that //[[CL:Glossary:use|uses]]// the //[[CL:Glossary:package]]//. When using the //[[CL:Glossary:Lisp reader]]//, if a //[[CL:Glossary:package prefix]]// is used, the //[[CL:Glossary:name]]// of an //[[CL:Glossary:external symbol]]// is separated from the //[[CL:Glossary:package]]// //[[CL:Glossary:name]]// by a single //[[CL:Glossary:package marker]]// while the //[[CL:Glossary:name]]// of an //[[CL:Glossary:internal symbol]]// is separated from the //[[CL:Glossary:package]]// //[[CL:Glossary:name]]// by a double //[[CL:Glossary:package marker]]//; \seesection\SymbolTokens. ===externalizable object=== //n.// * an //[[CL:Glossary:object]]// that can be used as a //[[CL:Glossary:literal]]// //[[CL:Glossary:object]]// in //[[CL:Glossary:code]]// to be processed by the //[[CL:Glossary:file compiler]]//. =====F===== ===false=== //n.// * the //[[CL:Glossary:symbol]]// **[[CL:Constant Variables:nil]]**, used to represent the failure of a //[[CL:Glossary:predicate]]// test. ===fbound=== //adj.// (of a //[[CL:Glossary:function name]]//) * //[[CL:Glossary:bound]]// in the //[[CL:Glossary:function]]// //[[CL:Glossary:name|namespace]]//. (The //[[CL:Glossary:name|names]]// of //[[CL:Glossary:macro|macros]]// and //[[CL:Glossary:special operator|special operators]]// are //[[CL:Glossary:fbound]]//, but the nature and //[[CL:Glossary:type]]// of the //[[CL:Glossary:object]]// which is their //[[CL:Glossary:value]]// is //[[CL:Glossary:implementation-dependent]]//. Further, defining a //[[CL:Glossary:setf expander]]// //F// does not cause the //[[CL:Glossary:setf function]]// ''([[CL:Macros:setf]] //F//)'' to become defined; as such, if there is a such a definition of a //[[CL:Glossary:setf expander]]// //F//, the //[[CL:Glossary:function]]// ''([[CL:Macros:setf]] //F//)'' can be //[[CL:Glossary:fbound]]// if and only if, by design or coincidence, a function binding for ''([[CL:Macros:setf]] //F//)'' has been independently established.) See functions **[[CL:Functions:fboundp]]** and **[[CL:Functions:symbol-function]]**. \issue{SETF-FUNCTIONS-AGAIN:MINIMAL-CHANGES} ===feature=== //n.// * 1. an aspect or attribute of Common Lisp, of the //[[CL:Glossary:implementation]]//, or of the //[[CL:Glossary:environment]]//. * 2. a //[[CL:Glossary:symbol]]// that names a //[[CL:Glossary:feature|feature<sub>1</sub>]]//. \Seesection\Features. "The **'':ansi-cl''** feature is present in all conforming implementations." ===feature expression=== //n.// * a boolean combination of //[[CL:Glossary:feature|features]]// used by the ''#+'' and ''#-'' //[[CL:Glossary:reader macro|reader macros]]// in order to direct conditional //[[CL:Glossary:read|reading]]// of //[[CL:Glossary:expression|expressions]]// by the //[[CL:Glossary:Lisp reader]]//. \Seesection\FeatureExpressions. ===features list=== //n.// * the //[[CL:Glossary:list]]// that is the //[[CL:Glossary:value]]// of **[[CL:Variables:star-features-star|*features*]]**. ===file=== //n.// * a named entry in a //[[CL:Glossary:file system]]//, having an //[[CL:Glossary:implementation-defined]]// nature. ===file compiler=== //n.// * any //[[CL:Glossary:compiler]]// which //[[CL:Glossary:compile|compiles]]// //[[CL:Glossary:source code]]// contained in a //[[CL:Glossary:file]]//, producing a //[[CL:Glossary:compile|compiled file]]// as output. The **[[CL:Functions:compile-file]]** function is the only interface to such a //[[CL:Glossary:compiler]]// provided by Common Lisp, but there might be other, //[[CL:Glossary:implementation-defined]]// mechanisms for invoking the //[[CL:Glossary:file compiler]]//. ===file position=== //n.// (in a //[[CL:Glossary:stream]]//) * a non-negative //[[CL:Glossary:integer]]// that represents a position in the //[[CL:Glossary:stream]]//. Not all //[[CL:Glossary:stream|streams]]// are able to represent the notion of //[[CL:Glossary:file position]]//; in the description of any //[[CL:Glossary:operator]]// which manipulates //[[CL:Glossary:file position|file positions]]//, the behavior for //[[CL:Glossary:stream|streams]]// that don't have this notion must be explicitly stated. For //[[CL:Glossary:binary]]// //[[CL:Glossary:stream|streams]]//, the //[[CL:Glossary:file position]]// represents the number of preceding //[[CL:Glossary:byte|bytes]]// in the //[[CL:Glossary:stream]]//. For //[[CL:Glossary:character]]// //[[CL:Glossary:stream|streams]]//, the constraint is more relaxed: //[[CL:Glossary:file position|file positions]]// must increase monot