======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_n]]//" 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₁]]// or //[[CL:Glossary:write|write₁]]// 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₁]]// 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₁]]//. * 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_2a]]//. \Seefigure\ConstituentTraitsOfStdChars. ===alphanumeric=== //adj.// * (of a //[[CL:Glossary:character]]//) being either an //[[CL:Glossary:alphabetic|alphabetic₁]]// //[[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₂]]//, 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₃]]// 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₁]]//. \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 monotonically, the amount of the increase between //[[CL:Glossary:file position|file positions]]// corresponding to any two successive characters in the //[[CL:Glossary:stream]]// is //[[CL:Glossary:implementation-dependent]]//. ===file position designator=== //n.// (in a //[[CL:Glossary:stream]]//) * a //[[CL:Glossary:designator]]// for a //[[CL:Glossary:file position]]// in that //[[CL:Glossary:stream]]//; that is, the symbol **'':start''** (denoting ''0'', the first //[[CL:Glossary:file position]]// in that //[[CL:Glossary:stream]]//), the symbol **'':end''** (denoting the last //[[CL:Glossary:file position]]// in that //[[CL:Glossary:stream]]//; i.e. the position following the last //[[CL:Glossary:element]]// of the //[[CL:Glossary:stream]]//), or a //[[CL:Glossary:file position]]// (denoting itself). ===file stream=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:file-stream]]**. ===file system=== //n.// * a facility which permits aggregations of data to be stored in named //[[CL:Glossary:file|files]]// on some medium that is external to the //[[CL:Glossary:Lisp image]]// and that therefore persists from //[[CL:Glossary:session]]// to //[[CL:Glossary:session]]//. ===filename=== //n.// * a handle, not necessarily ever directly represented as an //[[CL:Glossary:object]]//, that can be used to refer to a //[[CL:Glossary:file]]// in a //[[CL:Glossary:file system]]//. //[[CL:Glossary:Pathname|Pathnames]]// and //[[CL:Glossary:name|namestrings]]// are two kinds of //[[CL:Glossary:object|objects]]// that substitute for //[[CL:Glossary:filename|filenames]]// in Common Lisp. \issue{PATHNAME-HOST-PARSING:RECOGNIZE-LOGICAL-HOST-NAMES} ===fill pointer=== //n.// (of a //[[CL:Glossary:vector]]//) * an //[[CL:Glossary:integer]]// associated with a //[[CL:Glossary:vector]]// that represents the index above which no //[[CL:Glossary:element|elements]]// are //[[CL:Glossary:active]]//. (A //[[CL:Glossary:fill pointer]]// is a non-negative //[[CL:Glossary:integer]]// no larger than the total number of //[[CL:Glossary:element|elements]]// in the //[[CL:Glossary:vector]]//. Not all //[[CL:Glossary:vector|vectors]]// have //[[CL:Glossary:fill pointer|fill pointers]]//.) ===finite=== //adj.// (of a //[[CL:Glossary:type]]//) * having a finite number of //[[CL:Glossary:element|elements]]//. "The type specifier ''([[CL:Types:integer]] 0 5)'' denotes a finite type, but the type specifiers **[[CL:Types:integer]]** and ''([[CL:Types:integer]] 0)'' do not." ===fixnum=== //n.// * an //[[CL:Glossary:integer]]// of //[[CL:Glossary:type]]// **[[CL:Types:fixnum]]**. ===float=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:float]]**. ===for-value=== //adj.// (of a //[[CL:Glossary:reference]]// to a //[[CL:Glossary:binding]]//) * being a //[[CL:Glossary:reference]]// that //[[CL:Glossary:read|reads₁]]// the //[[CL:Glossary:value]]// of the //[[CL:Glossary:binding]]//. \issue{IGNORE-USE-TERMINOLOGY:VALUE-ONLY} ===form=== //n.// * 1. any //[[CL:Glossary:object]]// meant to be //[[CL:Glossary:evaluate|evaluated]]//. * 2. a //[[CL:Glossary:symbol]]//, a //[[CL:Glossary:compound form]]//, or a //[[CL:Glossary:self-evaluating object]]//. * 3. (for an //[[CL:Glossary:operator]]//, as in "operator //[[CL:Glossary:form]]//") a //[[CL:Glossary:compound form]]// having that //[[CL:Glossary:operator]]// as its first element. "A **[[CL:Special Operators:quote]]** form is a constant form." ===formal argument=== //n.//, //Trad.// * a //[[CL:Glossary:parameter]]//. ===formal parameter=== //n.//, //Trad.// * a //[[CL:Glossary:parameter]]//. ===format=== //v.t.// (a //[[CL:Glossary:format control]]// and //[[CL:Glossary:format argument|format arguments]]//) * to perform output as if by **[[CL:Functions:format]]**, using the //[[CL:Glossary:format string]]// and //[[CL:Glossary:format argument|format arguments]]//. \issue{FORMAT-STRING-ARGUMENTS:SPECIFY} ===format argument=== //n.// * an //[[CL:Glossary:object]]// which is used as data by functions such as **[[CL:Functions:format]]** which interpret //[[CL:Glossary:format control|format controls]]//. \issue{FORMAT-STRING-ARGUMENTS:SPECIFY} ===format control=== //n.// * a //[[CL:Glossary:format string]]//, or a //[[CL:Glossary:function]]// that obeys the //[[CL:Glossary:argument]]// conventions for a //[[CL:Glossary:function]]// returned by the //[[CL:Glossary:macro]]// **[[CL:Macros:formatter]]**. \Seesection\CompilingFormatStrings. ===format directive=== //n.// * 1. a sequence of //[[CL:Glossary:character|characters]]// in a //[[CL:Glossary:format string]]// which is introduced by a //[[CL:Glossary:tilde]]//, and which is specially interpreted by //[[CL:Glossary:code]]// which processes //[[CL:Glossary:format string|format strings]]// to mean that some special operation should be performed, possibly involving data supplied by the //[[CL:Glossary:format argument|format arguments]]// that accompanied the //[[CL:Glossary:format string]]//. See **[[CL:Functions:format]]**. "In ''"~D base 10 = ~8R"'', the character sequences "''~D''" and "''~8R''" are format directives." * 2. the conceptual category of all //[[CL:Glossary:format directive|format directives₁]]// which use the same dispatch character. "Both ''"~3d"'' and ''"~3,'0D"'' are valid uses of the "''~D''" format directive." ===format string=== //n.// * a //[[CL:Glossary:string]]// which can contain both ordinary text and //[[CL:Glossary:format directive|format directives]]//, and which is used in conjunction with //[[CL:Glossary:format argument|format arguments]]// to describe how text output should be formatted by certain functions, such as **[[CL:Functions:format]]**. ===free declaration=== //n.// * a declaration that is not a //[[CL:Glossary:bound declaration]]//. See **[[CL:Symbols:declare]]**. ===fresh=== //adj.// * 1. (of an //[[CL:Glossary:object]]// //[[CL:Glossary:yield|yielded]]// by a //[[CL:Glossary:function]]//) having been newly-allocated by that //[[CL:Glossary:function]]//. (The caller of a //[[CL:Glossary:function]]// that returns a //[[CL:Glossary:fresh]]// //[[CL:Glossary:object]]// may freely modify the //[[CL:Glossary:object]]// without fear that such modification will compromise the future correct behavior of that //[[CL:Glossary:function]]//.) * 2. (of a //[[CL:Glossary:binding]]// for a //[[CL:Glossary:name]]//) newly-allocated; not shared with other //[[CL:Glossary:binding|bindings]]// for that //[[CL:Glossary:name]]//. ===freshline=== //n.// * a conceptual operation on a //[[CL:Glossary:stream]]//, implemented by the //[[CL:Glossary:function]]// **[[CL:Functions:fresh-line]]** and by the //[[CL:Glossary:format directive]]// ''~&'', which advances the display position to the beginning of the next line (as if a //[[CL:Glossary:newline]]// had been typed, or the //[[CL:Glossary:function]]// **[[CL:Functions:terpri]]** had been called) unless the //[[CL:Glossary:stream]]// is already known to be positioned at the beginning of a line. Unlike //[[CL:Glossary:newline]]//, //[[CL:Glossary:freshline]]// is not a //[[CL:Glossary:character]]//. ===funbound=== //n.// (of a //[[CL:Glossary:function name]]//) * not //[[CL:Glossary:fbound]]//. ===function=== //n.// * 1. an //[[CL:Glossary:object]]// representing code, which can be //[[CL:Glossary:call|called]]// with zero or more //[[CL:Glossary:argument|arguments]]//, and which produces zero or more //[[CL:Glossary:value|values]]//. * 2. an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:function]]**. ===function block name=== //n.// (of a //[[CL:Glossary:function name]]//) * the //[[CL:Glossary:symbol]]// that would be used as the name of an //[[CL:Glossary:implicit block]]// which surrounds the body of a //[[CL:Glossary:function]]// having that //[[CL:Glossary:function name]]//. If the //[[CL:Glossary:function name]]// is a //[[CL:Glossary:symbol]]//, its //[[CL:Glossary:function block name]]// is the //[[CL:Glossary:function name]]// itself. If the //[[CL:Glossary:function name]]// is a //[[CL:Glossary:list]]// whose //[[CL:Glossary:car]]// is **[[CL:Macros:setf]]** and whose //[[CL:Glossary:cadr]]// is a //[[CL:Glossary:symbol]]//, its //[[CL:Glossary:function block name]]// is the //[[CL:Glossary:symbol]]// that is the //[[CL:Glossary:cadr]]// of the //[[CL:Glossary:function name]]//. An //[[CL:Glossary:implementation]]// which supports additional kinds of //[[CL:Glossary:function name|function names]]// must specify for each how the corresponding //[[CL:Glossary:function block name]]// is computed. ===function cell=== //n.//, //Trad.// (of a //[[CL:Glossary:symbol]]//) * the //[[CL:Glossary:place]]// which holds the definition of the global //[[CL:Glossary:function]]// //[[CL:Glossary:binding]]//, if any, named by that //[[CL:Glossary:symbol]]//, and which is //[[CL:Glossary:access|accessed]]// by **[[CL:Functions:symbol-function]]**. See //[[CL:Glossary:cell]]//. ===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:symbol]]// (denoting the //[[CL:Glossary:function]]// named by that //[[CL:Glossary:symbol]]// in the //[[CL:Glossary:global environment]]//), or a //[[CL:Glossary:function]]// (denoting itself). The consequences are undefined if a //[[CL:Glossary:symbol]]// is used as a //[[CL:Glossary:function designator]]// but it does not have a global definition as a //[[CL:Glossary:function]]//, or it has a global definition as a //[[CL:Glossary:macro]]// or a //[[CL:Glossary:special form]]//. See also //[[CL:Glossary:extended function designator]]//. ===function form=== //n.// * a //[[CL:Glossary:form]]// that is a //[[CL:Glossary:list]]// and that has a first element which is the //[[CL:Glossary:name]]// of a //[[CL:Glossary:function]]// to be called on //[[CL:Glossary:argument|arguments]]// which are the result of //[[CL:Glossary:evaluate|evaluating]]// subsequent elements of the //[[CL:Glossary:function form]]//. ===function name=== //n.// * 1. (in an //[[CL:Glossary:environment]]//) A //[[CL:Glossary:symbol]]// or a //[[CL:Glossary:list]]// ''([[CL:Macros:setf]] //symbol//)'' that is the //[[CL:Glossary:name]]// of a //[[CL:Glossary:function]]// in that //[[CL:Glossary:environment]]//. * 2. A //[[CL:Glossary:symbol]]// or a //[[CL:Glossary:list]]// ''([[CL:Macros:setf]] //symbol//)''. ===functional evaluation=== //n.// * the process of extracting a //[[CL:Glossary:functional value]]// from a //[[CL:Glossary:function name]]// or a //[[CL:Glossary:lambda expression]]//. The evaluator performs //[[CL:Glossary:functional evaluation]]// implicitly when it encounters a //[[CL:Glossary:function name]]// or a //[[CL:Glossary:lambda expression]]// in the //[[CL:Glossary:car]]// of a //[[CL:Glossary:compound form]]//, or explicitly when it encounters a **[[CL:Special Operators:function]]** //[[CL:Glossary:special form]]//. Neither a use of a //[[CL:Glossary:symbol]]// as a //[[CL:Glossary:function designator]]// nor a use of the //[[CL:Glossary:function]]// **[[CL:Functions:symbol-function]]** to extract the //[[CL:Glossary:functional value]]// of a //[[CL:Glossary:symbol]]// is considered a //[[CL:Glossary:functional evaluation]]//. ===functional value=== //n.// * 1. (of a //[[CL:Glossary:function name]]// //N// in an //[[CL:Glossary:environment]]// //E//) The //[[CL:Glossary:value]]// of the //[[CL:Glossary:binding]]// named //N// in the //[[CL:Glossary:function]]// //[[CL:Glossary:name|namespace]]// for //[[CL:Glossary:environment]]// //E//; that is, the contents of the //[[CL:Glossary:function cell]]// named //N// in //[[CL:Glossary:environment]]// //E//. * 2. (of an //[[CL:Glossary:fbound]]// //[[CL:Glossary:symbol]]// //S//) the contents of the //[[CL:Glossary:symbol]]//'s //[[CL:Glossary:function cell]]//; that is, the //[[CL:Glossary:value]]// of the //[[CL:Glossary:binding]]// named //S// in the //[[CL:Glossary:function]]// //[[CL:Glossary:name|namespace]]// of the //[[CL:Glossary:global environment]]//. (A //[[CL:Glossary:name]]// that is a //[[CL:Glossary:macro name]]// in the //[[CL:Glossary:global environment]]// or is a //[[CL:Glossary:special operator]]// might or might not be //[[CL:Glossary:fbound]]//. But if //S// is such a //[[CL:Glossary:name]]// and is //[[CL:Glossary:fbound]]//, the specific nature of its //[[CL:Glossary:functional value]]// is //[[CL:Glossary:implementation-dependent]]//; in particular, it might or might not be a //[[CL:Glossary:function]]//.) ===further compilation=== //n.// * //[[CL:Glossary:implementation-dependent]]// compilation beyond //[[CL:Glossary:minimal compilation]]//. Further compilation is permitted to take place at //[[CL:Glossary:run time]]//. "Block compilation and generation of machine-specific instructions are examples of further compilation." =====G===== ===general=== //adj.// (of an //[[CL:Glossary:array]]//) * having //[[CL:Glossary:element type]]// **[[CL:Types:t]]**, and consequently able to have any //[[CL:Glossary:object]]// as an //[[CL:Glossary:element]]//. ===generalized boolean=== //n.// * an //[[CL:Glossary:object]]// used as a truth value, where the symbol~**[[CL:Constant Variables:nil]]** represents //[[CL:Glossary:false]]// and all other //[[CL:Glossary:object|objects]]// represent //[[CL:Glossary:true]]//. See //[[CL:Glossary:boolean]]//. ===generalized instance=== //n.// (of a //[[CL:Glossary:class]]//) * an //[[CL:Glossary:object]]// the //[[CL:Glossary:class]]// of which is either that //[[CL:Glossary:class]]// itself, or some subclass of that //[[CL:Glossary:class]]//. (Because of the correspondence between types and classes, the term "generalized instance of //X//" implies "object of type //X//" and in cases where //X// is a //[[CL:Glossary:class]]// (or //[[CL:Glossary:class]]// //[[CL:Glossary:name]]//) the reverse is also true. The former terminology emphasizes the view of //X// as a //[[CL:Glossary:class]]// while the latter emphasizes the view of //X// as a //[[CL:Glossary:type specifier]]//.) ===generalized reference=== //n.// * a reference to a location storing an //[[CL:Glossary:object]]// as if to a //[[CL:Glossary:variable]]//. (Such a reference can be either to //[[CL:Glossary:read]]// or //[[CL:Glossary:write]]// the location.) \Seesection\GeneralizedReference. See also //[[CL:Glossary:place]]//. ===generalized synonym stream=== //n.// (with a //[[CL:Glossary:synonym stream symbol]]//) * 1. (to a //[[CL:Glossary:stream]]//) a //[[CL:Glossary:synonym stream]]// to the //[[CL:Glossary:stream]]//, or a //[[CL:Glossary:composite stream]]// which has as a target a //[[CL:Glossary:generalized synonym stream]]// to the //[[CL:Glossary:stream]]//. * 2. (to a //[[CL:Glossary:symbol]]//) a //[[CL:Glossary:synonym stream]]// to the //[[CL:Glossary:symbol]]//, or a //[[CL:Glossary:composite stream]]// which has as a target a //[[CL:Glossary:generalized synonym stream]]// to the //[[CL:Glossary:symbol]]//. ===generic function=== //n.// * a //[[CL:Glossary:function]]// whose behavior depends on the //[[CL:Glossary:class|classes]]// or identities of the arguments supplied to it and whose parts include, among other things, a set of //[[CL:Glossary:method|methods]]//, a //[[CL:Glossary:lambda list]]//, and a //[[CL:Glossary:method combination]]// type. ===generic function lambda list=== //n.// * a //[[CL:Glossary:lambda list]]// that is used to describe data flow into a //[[CL:Glossary:generic function]]//. \Seesection\GFLambdaLists. ===gensym=== //n.// //Trad.// * an //[[CL:Glossary:uninterned]]// //[[CL:Glossary:symbol]]//. See **[[CL:Functions:gensym]]**. ===global declaration=== //n.// * a //[[CL:Glossary:form]]// that makes certain kinds of information about code globally available; that is, a **[[CL:Functions:proclaim]]** //[[CL:Glossary:form]]// or a **[[CL:Macros:declaim]]** //[[CL:Glossary:form]]//. ===global environment=== //n.// * that part of an //[[CL:Glossary:environment]]// that contains //[[CL:Glossary:binding|bindings]]// with //[[CL:Glossary:indefinite scope]]// and //[[CL:Glossary:indefinite extent]]//. ===global variable=== //n.// * a //[[CL:Glossary:dynamic variable]]// or a //[[CL:Glossary:constant variable]]//. ===glyph=== //n.// * a visual representation. "Graphic characters have associated glyphs." ===go=== //v.// * to transfer control to a //[[CL:Glossary:go point]]//. See **[[CL:Special Operators:go]]**. ===go point=== //n.// * one of possibly several //[[CL:Glossary:exit point|exit points]]// that are //[[CL:Glossary:establish|established]]// by **[[CL:Special Operators:tagbody]]** (or other abstractions, such as **[[CL:Macros:prog]]**, which are built from **[[CL:Special Operators:tagbody]]**). ===go tag=== //n.// * the //[[CL:Glossary:symbol]]// or //[[CL:Glossary:integer]]// that, within the //[[CL:Glossary:lexical scope]]// of a **[[CL:Special Operators:tagbody]]** //[[CL:Glossary:form]]//, names an //[[CL:Glossary:exit point]]// //[[CL:Glossary:establish|established]]// by that **[[CL:Special Operators:tagbody]]** //[[CL:Glossary:form]]//. ===graphic=== //adj.// (of a //[[CL:Glossary:character]]//) * being a "printing" or "displayable" //[[CL:Glossary:character]]// that has a standard visual representation as a single //[[CL:Glossary:glyph]]//, such as ''A'' or ''*'' or ''=''. //[[CL:Glossary:Space]]// is defined to be //[[CL:Glossary:graphic]]//. Of the //[[CL:Glossary:standard character|standard characters]]//, all but //[[CL:Glossary:newline]]// are //[[CL:Glossary:graphic]]//. See //[[CL:Glossary:non-graphic]]//. =====H===== ===handle=== //v.// (of a //[[CL:Glossary:condition]]// being //[[CL:Glossary:signal|signaled]]//) * to perform a non-local transfer of control, terminating the ongoing //[[CL:Glossary:signal|signaling]]// of the //[[CL:Glossary:condition]]//. ===handler=== //n.// * a //[[CL:Glossary:condition handler]]//. ===hash table=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:hash-table]]**, which provides a mapping from //[[CL:Glossary:key|keys]]// to //[[CL:Glossary:value|values]]//. ===home package=== //n.// (of a //[[CL:Glossary:symbol]]//) * the //[[CL:Glossary:package]]//, if any, which is contents of the //[[CL:Glossary:package cell]]// of the //[[CL:Glossary:symbol]]//, and which dictates how the //[[CL:Glossary:Lisp printer]]// prints the //[[CL:Glossary:symbol]]// when it is not //[[CL:Glossary:accessible]]// in the //[[CL:Glossary:current package]]//. (//[[CL:Glossary:symbol|Symbols]]// which have **[[CL:Constant Variables:nil]]** in their //[[CL:Glossary:package cell]]// are said to have no //[[CL:Glossary:home package]]//, and also to be //[[CL:Glossary:apparently uninterned]]//.) =====I===== ===I/O customization variable=== //n.// * one of the //[[CL:Glossary:stream variable|stream variables]]// in the below list, or some other (//[[CL:Glossary:implementation-defined]]//) //[[CL:Glossary:stream variable]]// that is defined by the //[[CL:Glossary:implementation]]// to be an //[[CL:Glossary:IO customization variable|I/O customization variable]]//. * **[[CL:Variables:star-debug-io-star|*debug-io*]]** * **[[CL:Variables:star-error-output-star|*error-output*]]** * **[[CL:Variables:star-query-io-star|*query-io*]]** * **[[CL:Variables:star-standard-input-star|*standard-input*]]** * **[[CL:Variables:star-standard-output-star|*standard-output*]]** * **[[CL:Variables:star-trace-output-star|*trace-output*]]** ===identical=== //adj.// * the //[[CL:Glossary:same]]// under **[[CL:Functions:eq]]**. ===identifier=== //n.// * 1. a //[[CL:Glossary:symbol]]// used to identify or to distinguish //[[CL:Glossary:name|names]]//. * 2. a //[[CL:Glossary:string]]// used the same way. ===immutable=== //adj.// * not subject to change, either because no //[[CL:Glossary:operator]]// is provided which is capable of effecting such change or because some constraint exists which prohibits the use of an //[[CL:Glossary:operator]]// that might otherwise be capable of effecting such a change. Except as explicitly indicated otherwise, //[[CL:Glossary:implementation|implementations]]// are not required to detect attempts to modify //[[CL:Glossary:immutable]]// //[[CL:Glossary:object|objects]]// or //[[CL:Glossary:cell|cells]]//; the consequences of attempting to make such modification are undefined. "Numbers are immutable." ===implementation=== //n.// * a system, mechanism, or body of //[[CL:Glossary:code]]// that implements the semantics of Common Lisp. ===implementation limit=== //n.// * a restriction imposed by an //[[CL:Glossary:implementation]]//. ===implementation-defined=== //adj.// * //[[CL:Glossary:implementation-dependent]]//, but required by this specification to be defined by each //[[CL:Glossary:conforming implementation]]// and to be documented by the corresponding implementor. ===implementation-dependent=== //adj.// * describing a behavior or aspect of Common Lisp which has been deliberately left unspecified, that might be defined in some //[[CL:Glossary:conforming implementation|conforming implementations]]// but not in others, and whose details may differ between //[[CL:Glossary:implementation|implementations]]//. A //[[CL:Glossary:conforming implementation]]// is encouraged (but not required) to document its treatment of each item in this specification which is marked //[[CL:Glossary:implementation-dependent]]//, although in some cases such documentation might simply identify the item as "undefined." ===implementation-independent=== //adj.// used to identify or emphasize a behavior or aspect of Common Lisp which does not vary between //[[CL:Glossary:conforming implementation|conforming implementations]]//. ===implicit block=== //n.// * a //[[CL:Glossary:block]]// introduced by a //[[CL:Glossary:macro form]]// rather than by an explicit **[[CL:Special Operators:block]]** //[[CL:Glossary:form]]//. ===implicit compilation=== //n.// * //[[CL:Glossary:compilation]]// performed during //[[CL:Glossary:evaluation]]//. ===implicit progn=== //n.// * an ordered set of adjacent //[[CL:Glossary:form|forms]]// appearing in another //[[CL:Glossary:form]]//, and defined by their context in that //[[CL:Glossary:form]]// to be executed as if within a **[[CL:Special Operators:progn]]**. ===implicit tagbody=== //n.// * an ordered set of adjacent //[[CL:Glossary:form|forms]]// and/or //[[CL:Glossary:tag|tags]]// appearing in another //[[CL:Glossary:form]]//, and defined by their context in that //[[CL:Glossary:form]]// to be executed as if within a **[[CL:Special Operators:tagbody]]**. ===import=== //v.t.// (a //[[CL:Glossary:symbol]]// into a //[[CL:Glossary:package]]//) * to make the //[[CL:Glossary:symbol]]// be //[[CL:Glossary:present]]// in the //[[CL:Glossary:package]]//. ===improper list=== //n.// * a //[[CL:Glossary:list]]// which is not a //[[CL:Glossary:proper list]]//: a //[[CL:Glossary:circular list]]// or a //[[CL:Glossary:dotted list]]//. ===inaccessible=== //adj.// * not //[[CL:Glossary:accessible]]//. ===indefinite extent=== //n.// * an //[[CL:Glossary:extent]]// whose duration is unlimited. "Most Common Lisp objects have indefinite extent." ===indefinite scope=== //n.// * //[[CL:Glossary:scope]]// that is unlimited. ===indicator=== //n.// * a //[[CL:Glossary:property indicator]]//. ===indirect instance=== //n.// (of a //[[CL:Glossary:class]]// //C₁//) * an //[[CL:Glossary:object]]// of //[[CL:Glossary:class]]// //C₂//, where //C₂// is a //[[CL:Glossary:subclass]]// of //C₁//. "An integer is an indirect instance of the class **[[CL:Types:number]]**." ===inherit=== //v.t.// * 1. to receive or acquire a quality, trait, or characteristic; to gain access to a feature defined elsewhere. * 2. (a //[[CL:Glossary:class]]//) to acquire the structure and behavior defined by a //[[CL:Glossary:superclass]]//. * 3. (a //[[CL:Glossary:package]]//) to make //[[CL:Glossary:symbol|symbols]]// //[[CL:Glossary:exported]]// by another //[[CL:Glossary:package]]// //[[CL:Glossary:accessible]]// by using **[[CL:Functions:use-package]]**. ===initial pprint dispatch table=== //n.// * the //[[CL:Glossary:value]]// of **[[CL:Variables:star-print-pprint-dispatch-star|*print-pprint-dispatch*]]** at the time the //[[CL:Glossary:Lisp image]]// is started. \issue{KMP-COMMENTS-ON-SANDRA-COMMENTS:X3J13-MAR-92} ===initial readtable=== //n.// * the //[[CL:Glossary:value]]// of **[[CL:Variables:star-readtable-star|*readtable*]]** at the time the //[[CL:Glossary:Lisp image]]// is started. \issue{WITH-STANDARD-IO-SYNTAX-READTABLE:X3J13-MAR-91} ===initialization argument list=== //n.// * a //[[CL:Glossary:property list]]// of initialization argument //[[CL:Glossary:name|names]]// and //[[CL:Glossary:value|values]]// used in the protocol for initializing and reinitializing //[[CL:Glossary:instance|instances]]// of //[[CL:Glossary:class|classes]]//. \Seesection\ObjectCreationAndInit. \issue{PLIST-DUPLICATES:ALLOW} ===initialization form=== //n.// * a //[[CL:Glossary:form]]// used to supply the initial //[[CL:Glossary:value]]// for a //[[CL:Glossary:slot]]// or //[[CL:Glossary:variable]]//. "The initialization form for a slot in a **[[CL:Macros:defclass]]** form is introduced by the keyword **'':initform''**." ===input=== //adj.// (of a //[[CL:Glossary:stream]]//) * supporting input operations (i.e. being a "data source"). An //[[CL:Glossary:input]]// //[[CL:Glossary:stream]]// might also be an //[[CL:Glossary:output]]// //[[CL:Glossary:stream]]//, in which case it is sometimes called a //[[CL:Glossary:bidirectional]]// //[[CL:Glossary:stream]]//. See **[[CL:Functions:input-stream-p]]**. ===instance=== //n.// * 1. a //[[CL:Glossary:direct instance]]//. * 2. a //[[CL:Glossary:generalized instance]]//. * 3. an //[[CL:Glossary:indirect instance]]//. ===integer=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:integer]]**, which represents a mathematical integer. ===interactive stream=== //n.// * a //[[CL:Glossary:stream]]// on which it makes sense to perform interactive querying. \Seesection\InteractiveStreams. ===intern=== //v.t.// * 1. (a //[[CL:Glossary:string]]// in a //[[CL:Glossary:package]]//) to look up the //[[CL:Glossary:string]]// in the //[[CL:Glossary:package]]//, returning either a //[[CL:Glossary:symbol]]// with that //[[CL:Glossary:name]]// which was already //[[CL:Glossary:accessible]]// in the //[[CL:Glossary:package]]// or a newly created //[[CL:Glossary:internal symbol]]// of the //[[CL:Glossary:package]]// with that //[[CL:Glossary:name]]//. * 2. //Idiom.// generally, to observe a protocol whereby objects which are equivalent or have equivalent names under some predicate defined by the protocol are mapped to a single canonical object. ===internal symbol=== //n.// (of a //[[CL:Glossary:package]]//) * a symbol which is //[[CL:Glossary:accessible]]// in the //[[CL:Glossary:package]]//, but which is not an //[[CL:Glossary:external symbol]]// of the //[[CL:Glossary:package]]//. ===internal time=== //n.// * //[[CL:Glossary:time]]//, represented as an //[[CL:Glossary:integer]]// number of //[[CL:Glossary:internal time unit|internal time units]]//. //[[CL:Glossary:Absolute]]// //[[CL:Glossary:internal time]]// is measured as an offset from an arbitrarily chosen, //[[CL:Glossary:implementation-dependent]]// base. \Seesection\InternalTime. ===internal time unit=== //n.// * a unit of time equal to ''1<nowiki>/</nowiki>//n//'' of a second, for some //[[CL:Glossary:implementation-defined]]// //[[CL:Glossary:integer]]// value of //n//. See **[[CL:Constant Variables:internal-time-units-per-second]]**. ===interned=== //adj.// //Trad.// * 1. (of a //[[CL:Glossary:symbol]]//) //[[CL:Glossary:accessible|accessible₃]]// in any //[[CL:Glossary:package]]//. * 2. (of a //[[CL:Glossary:symbol]]// in a specific //[[CL:Glossary:package]]//) //[[CL:Glossary:present]]// in that //[[CL:Glossary:package]]//. ===interpreted function=== //n.// * a //[[CL:Glossary:function]]// that is not a //[[CL:Glossary:compile|compiled function]]//. (It is possible for there to be a //[[CL:Glossary:conforming implementation]]// which has no //[[CL:Glossary:interpreted function|interpreted functions]]//, but a //[[CL:Glossary:conforming program]]// must not assume that all //[[CL:Glossary:function|functions]]// are //[[CL:Glossary:compiled function|compiled functions]]//.) ===interpreted implementation=== //n.// * an //[[CL:Glossary:implementation]]// that uses an execution strategy for //[[CL:Glossary:interpreted function|interpreted functions]]// that does not involve a one-time semantic analysis pre-pass, and instead uses "lazy" (and sometimes repetitious) semantic analysis of //[[CL:Glossary:form|forms]]// as they are encountered during execution. ===interval designator=== //n.// (of //[[CL:Glossary:type]]// //T//) * an ordered pair of //[[CL:Glossary:object|objects]]// that describe a //[[CL:Glossary:subtype]]// of //T// by delimiting an interval on the real number line. \Seesection\IntervalDesignators. ===invalid=== //n.//, //adj.// * 1. //n.// a possible //[[CL:Glossary:constituent trait]]// of a //[[CL:Glossary:character]]// which if present signifies that the //[[CL:Glossary:character]]// cannot ever appear in a //[[CL:Glossary:token]]// except under the control of a //[[CL:Glossary:single escape]]// //[[CL:Glossary:character]]//. For details, \seesection\ConstituentChars. * 2. //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:invalid|invalid₁]]//. \Seefigure\ConstituentTraitsOfStdChars. ===iteration form=== //n.// * a //[[CL:Glossary:compound form]]// whose //[[CL:Glossary:operator]]// is named in the below list, or a //[[CL:Glossary:compound form]]// that has an //[[CL:Glossary:implementation-defined]]// //[[CL:Glossary:operator]]// and that is defined by the //[[CL:Glossary:implementation]]// to be an //[[CL:Glossary:iteration form]]//. \issue{DOTIMES-IGNORE:X3J13-MAR91} * **[[CL:Macros:do]]** * **[[CL:Macros:do-external-symbols]]** * **[[CL:Macros:dotimes]]** * **[[CL:Macros:do-star|do*]]** * **[[CL:Macros:do-symbols]]** * **[[CL:Macros:loop]]** * **[[CL:Macros:do-all-symbols]]** * **[[CL:Macros:dolist]]** ===iteration variable=== //n.// * a //[[CL:Glossary:variable]]// //V//, the //[[CL:Glossary:binding]]// for which was created by an //[[CL:Glossary:explicit use]]// of //V// in an //[[CL:Glossary:iteration form]]//. =====K===== ===key=== //n.// * an //[[CL:Glossary:object]]// used for selection during retrieval. See //[[CL:Glossary:association list]]//, //[[CL:Glossary:property list]]//, and //[[CL:Glossary:hash table]]//. Also, \seesection\SequenceConcepts. ===keyword=== //n.// * 1. a //[[CL:Glossary:symbol]]// the //[[CL:Glossary:home package]]// of which is the //[[CL:Glossary:package]]// **''keyword''**. * 2. any //[[CL:Glossary:symbol]]//, usually but not necessarily in the //[[CL:Glossary:package]]// **''keyword''**, that is used as an identifying marker in keyword-style argument passing. See **[[CL:Symbols:lambda]]**. * 3. //Idiom.// a //[[CL:Glossary:lambda list keyword]]//. ===keyword parameter=== //n.// * a //[[CL:Glossary:parameter]]// for which a corresponding keyword //[[CL:Glossary:argument]]// is optional. (There is no such thing as a required keyword //[[CL:Glossary:argument]]//.) If the //[[CL:Glossary:argument]]// is not supplied, a default value is used. See also //[[CL:Glossary:supplied-p parameter]]//. \issue{PLIST-DUPLICATES:ALLOW} ===keyword/value pair=== //n.// * two successive //[[CL:Glossary:element|elements]]// (a //[[CL:Glossary:keyword]]// and a //[[CL:Glossary:value]]//, respectively) of a //[[CL:Glossary:property list]]//. =====L===== ===lambda combination=== //n.//, //Trad.// * a //[[CL:Glossary:lambda form]]//. ===lambda expression=== //n.// * a //[[CL:Glossary:list]]// which can be used in place of a //[[CL:Glossary:function name]]// in certain contexts to denote a //[[CL:Glossary:function]]// by directly describing its behavior rather than indirectly by referring to the name of an //[[CL:Glossary:establish|established]]// //[[CL:Glossary:function]]//; its name derives from the fact that its first element is the //[[CL:Glossary:symbol]]// **[[CL:Symbols:lambda]]**. See **[[CL:Symbols:lambda]]**. ===lambda form=== //n.// * a //[[CL:Glossary:form]]// that is a //[[CL:Glossary:list]]// and that has a first element which is a //[[CL:Glossary:lambda expression]]// representing a //[[CL:Glossary:function]]// to be called on //[[CL:Glossary:argument|arguments]]// which are the result of //[[CL:Glossary:evaluate|evaluating]]// subsequent elements of the //[[CL:Glossary:lambda form]]//. ===lambda list=== //n.// * a //[[CL:Glossary:list]]// that specifies a set of //[[CL:Glossary:parameter|parameters]]// (sometimes called //[[CL:Glossary:lambda variable|lambda variables]]//) and a protocol for receiving //[[CL:Glossary:value|values]]// for those //[[CL:Glossary:parameter|parameters]]//; that is, an //[[CL:Glossary:ordinary lambda list]]//, an //[[CL:Glossary:extended lambda list]]//, or a //[[CL:Glossary:modified lambda list]]//. ===lambda list keyword=== //n.// * a //[[CL:Glossary:symbol]]// whose //[[CL:Glossary:name]]// begins with //[[CL:Glossary:ampersand]]// and that is specially recognized in a //[[CL:Glossary:lambda list]]//. Note that no //[[CL:Glossary:standardized]]// //[[CL:Glossary:lambda list keyword]]// is in the //[[CL:Glossary:package]]// **''keyword''**. ===lambda variable=== //n.// * a //[[CL:Glossary:formal parameter]]//, used to emphasize the //[[CL:Glossary:variable]]//'s relation to the //[[CL:Glossary:lambda list]]// that //[[CL:Glossary:establish|established]]// it. ===leaf=== //n.// * 1. an //[[CL:Glossary:atom]]// in a //[[CL:Glossary:tree|tree₁]]//. * 2. a terminal node of a //[[CL:Glossary:tree|tree₂]]//. ===leap seconds=== //n.// * additional one-second intervals of time that are occasionally inserted into the true calendar by official timekeepers as a correction similar to "leap years." All Common Lisp //[[CL:Glossary:time]]// representations ignore //[[CL:Glossary:leap seconds]]//; every day is assumed to be exactly 86400 seconds long. ===left-parenthesis=== //n.// * the //[[CL:Glossary:standard character]]// "''(''", that is variously called "left parenthesis" or "open parenthesis" \Seefigure\StdCharsThree. ===length=== //n.// (of a //[[CL:Glossary:sequence]]//) * the number of //[[CL:Glossary:element|elements]]// in the //[[CL:Glossary:sequence]]//. (Note that if the //[[CL:Glossary:sequence]]// is a //[[CL:Glossary:vector]]// with a //[[CL:Glossary:fill pointer]]//, its //[[CL:Glossary:length]]// is the same as the //[[CL:Glossary:fill pointer]]// even though the total allocated size of the //[[CL:Glossary:vector]]// might be larger.) ===lexical binding=== //n.// * a //[[CL:Glossary:binding]]// in a //[[CL:Glossary:lexical environment]]//. ===lexical closure=== //n.// * a //[[CL:Glossary:function]]// that, when invoked on //[[CL:Glossary:argument|arguments]]//, executes the body of a //[[CL:Glossary:lambda expression]]// in the //[[CL:Glossary:lexical environment]]// that was captured at the time of the creation of the //[[CL:Glossary:lexical closure]]//, augmented by //[[CL:Glossary:binding|bindings]]// of the //[[CL:Glossary:function]]//'s //[[CL:Glossary:parameter|parameters]]// to the corresponding //[[CL:Glossary:argument|arguments]]//. ===lexical environment=== //n.// * that part of the //[[CL:Glossary:environment]]// that contains //[[CL:Glossary:binding|bindings]]// whose names have //[[CL:Glossary:lexical scope]]//. A //[[CL:Glossary:lexical environment]]// contains, among other things: ordinary //[[CL:Glossary:binding|bindings]]// of //[[CL:Glossary:variable]]// //[[CL:Glossary:name|names]]// to //[[CL:Glossary:value|values]]//, lexically //[[CL:Glossary:establish|established]]// //[[CL:Glossary:binding|bindings]]// of //[[CL:Glossary:function name|function names]]// to //[[CL:Glossary:function|functions]]//, //[[CL:Glossary:macro|macros]]//, //[[CL:Glossary:symbol macro|symbol macros]]//, //[[CL:Glossary:block|blocks]]//, //[[CL:Glossary:tag|tags]]//, and //[[CL:Glossary:local declaration|local declarations]]// (see **[[CL:Symbols:declare]]**). ===lexical scope=== //n.// * //[[CL:Glossary:scope]]// that is limited to a spatial or textual region within the establishing //[[CL:Glossary:form]]//. "The names of parameters to a function normally are lexically scoped." ===lexical variable=== //n.// * a //[[CL:Glossary:variable]]// the //[[CL:Glossary:binding]]// for which is in the //[[CL:Glossary:lexical environment]]//. ===Lisp image=== //n.// * a running instantiation of a Common Lisp //[[CL:Glossary:implementation]]//. A //[[CL:Glossary:Lisp image]]// is characterized by a single address space in which any //[[CL:Glossary:object]]// can directly refer to any another in conformance with this specification, and by a single, common, //[[CL:Glossary:global environment]]//. (External operating systems sometimes call this a "core image," "fork," "incarnation," "job," or "process." Note however, that the issue of a "process" in such an operating system is technically orthogonal to the issue of a //[[CL:Glossary:Lisp image]]// being defined here. Depending on the operating system, a single "process" might have multiple //[[CL:Glossary:Lisp image|Lisp images]]//, and multiple "processes" might reside in a single //[[CL:Glossary:Lisp image]]//. Hence, it is the idea of a fully shared address space for direct reference among all //[[CL:Glossary:object|objects]]// which is the defining characteristic. Note, too, that two "processes" which have a communication area that permits the sharing of some but not all //[[CL:Glossary:object|objects]]// are considered to be distinct //[[CL:Glossary:Lisp image|Lisp images]]//.) ===Lisp printer=== //n.//, //Trad.// * the procedure that prints the character representation of an //[[CL:Glossary:object]]// onto a //[[CL:Glossary:stream]]//. (This procedure is implemented by the //[[CL:Glossary:function]]// **[[CL:Functions:write]]**.) ===Lisp read-eval-print loop=== //n.//, //Trad.// * an endless loop that //[[CL:Glossary:read|reads₂]]// a //[[CL:Glossary:form]]//, //[[CL:Glossary:evaluate|evaluates]]// it, and prints (i.e. //[[CL:Glossary:write|writes₂]]//) the results. In many //[[CL:Glossary:implementation|implementations]]//, the default mode of interaction with Common Lisp during program development is through such a loop. ===Lisp reader=== //n.//, //Trad.// * the procedure that parses character representations of //[[CL:Glossary:object|objects]]// from a //[[CL:Glossary:stream]]//, producing //[[CL:Glossary:object|objects]]//. (This procedure is implemented by the //[[CL:Glossary:function]]// **[[CL:Functions:read]]**.) ===list=== //n.// * 1. a chain of //[[CL:Glossary:cons|conses]]// in which the //[[CL:Glossary:car]]// of each //[[CL:Glossary:cons]]// is an //[[CL:Glossary:element]]// of the //[[CL:Glossary:list]]//, and the //[[CL:Glossary:cdr]]// of each //[[CL:Glossary:cons]]// is either the next link in the chain or a terminating //[[CL:Glossary:atom]]//. See also //[[CL:Glossary:proper list]]//, //[[CL:Glossary:dotted list]]//, or //[[CL:Glossary:circular list]]//. * 2. the //[[CL:Glossary:type]]// that is the union of **[[CL:Types:null]]** and **[[CL:Types:cons]]**. ===list designator=== //n.// * a //[[CL:Glossary:designator]]// for a //[[CL:Glossary:list]]// of //[[CL:Glossary:object|objects]]//; that is, an //[[CL:Glossary:object]]// that denotes a //[[CL:Glossary:list]]// and that is one of: a //[[CL:Glossary:non-nil]]// //[[CL:Glossary:atom]]// (denoting a //[[CL:Glossary:singleton]]// //[[CL:Glossary:list]]// whose //[[CL:Glossary:element]]// is that //[[CL:Glossary:non-nil]]// //[[CL:Glossary:atom]]//) or a //[[CL:Glossary:proper list]]// (denoting itself). ===list structure=== //n.// (of a //[[CL:Glossary:list]]//) * the set of //[[CL:Glossary:cons|conses]]// that make up the //[[CL:Glossary:list]]//. Note that while the //[[CL:Glossary:car|car_1b]]// component of each such //[[CL:Glossary:cons]]// is part of the //[[CL:Glossary:list structure]]//, the //[[CL:Glossary:object|objects]]// that are //[[CL:Glossary:element|elements]]// of the //[[CL:Glossary:list]]// (i.e. the //[[CL:Glossary:object|objects]]// that are the //[[CL:Glossary:car|cars₂]]// of each //[[CL:Glossary:cons]]// in the //[[CL:Glossary:list]]//) are not themselves part of its //[[CL:Glossary:list structure]]//, even if they are //[[CL:Glossary:cons|conses]]//, except in the (//[[CL:Glossary:circular|circular₂]]//) case where the //[[CL:Glossary:list]]// actually contains one of its //[[CL:Glossary:tail|tails]]// as an //[[CL:Glossary:element]]//. (The //[[CL:Glossary:list structure]]// of a //[[CL:Glossary:list]]// is sometimes redundantly referred to as its "top-level list structure" in order to emphasize that any //[[CL:Glossary:cons|conses]]// that are //[[CL:Glossary:element|elements]]// of the //[[CL:Glossary:list]]// are not involved.) ===literal=== //adj.// (of an //[[CL:Glossary:object]]//) * referenced directly in a program rather than being computed by the program; that is, appearing as data in a **[[CL:Special Operators:quote]]** //[[CL:Glossary:form]]//, or, if the //[[CL:Glossary:object]]// is a //[[CL:Glossary:self-evaluating object]]//, appearing as unquoted data. "In the form ''(cons "one" '("two"))'', the expressions ''"one"'', ''("two")'', and ''"two"'' are literal objects." ===load=== //v.t.// (a //[[CL:Glossary:file]]//) * to cause the //[[CL:Glossary:code]]// contained in the //[[CL:Glossary:file]]// to be //[[CL:Glossary:execute|executed]]//. See **[[CL:Functions:load]]**. ===load time=== //n.// * the duration of time that the loader is //[[CL:Glossary:load|loading]]// //[[CL:Glossary:compile|compiled code]]//. ===load time value=== //n.// * an //[[CL:Glossary:object]]// referred to in //[[CL:Glossary:code]]// by a **[[CL:Special Operators:load-time-value]]** //[[CL:Glossary:form]]//. The //[[CL:Glossary:value]]// of such a //[[CL:Glossary:form]]// is some specific //[[CL:Glossary:object]]// which can only be computed in the run-time //[[CL:Glossary:environment]]//. In the case of //[[CL:Glossary:file]]// //[[CL:Glossary:compilation]]//, the //[[CL:Glossary:value]]// is computed once as part of the process of //[[CL:Glossary:load|loading]]// the //[[CL:Glossary:compile|compiled file]]//, and not again. See **[[CL:Special Operators:load-time-value]]**. ===loader=== //n.// * a facility that is part of Lisp and that //[[CL:Glossary:load|loads]]// a //[[CL:Glossary:file]]//. See **[[CL:Functions:load]]**. ===local declaration=== //n.// * an //[[CL:Glossary:expression]]// which may appear only in specially designated positions of certain //[[CL:Glossary:form|forms]]//, and which provides information about the code contained within the containing //[[CL:Glossary:form]]//; that is, a **[[CL:Symbols:declare]]** //[[CL:Glossary:expression]]//. ===local precedence order=== //n.// (of a //[[CL:Glossary:class]]//) * a //[[CL:Glossary:list]]// consisting of the //[[CL:Glossary:class]]// followed by its //[[CL:Glossary:direct superclass|direct superclasses]]// in the order mentioned in the defining //[[CL:Glossary:form]]// for the //[[CL:Glossary:class]]//. ===local slot=== //n.// (of a //[[CL:Glossary:class]]//) * a //[[CL:Glossary:slot]]// //[[CL:Glossary:accessible]]// in only one //[[CL:Glossary:instance]]//, namely the //[[CL:Glossary:instance]]// in which the //[[CL:Glossary:slot]]// is allocated. ===logical block=== //n.// * a conceptual grouping of related output used by the //[[CL:Glossary:pretty printer]]//. see //[[CL:Glossary:macro]]// **[[CL:Macros:pprint-logical-block]]** and \secref\DynamicControlofOutput. ===logical host=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:implementation-dependent]]// nature that is used as the representation of a "host" in a //[[CL:Glossary:logical pathname]]//, and that has an associated set of translation rules for converting //[[CL:Glossary:logical pathname|logical pathnames]]// belonging to that host into //[[CL:Glossary:physical pathname|physical pathnames]]//. \Seesection\LogicalPathnames. ===logical host designator=== //n.// * a //[[CL:Glossary:designator]]// for a //[[CL:Glossary:logical host]]//; that is, an //[[CL:Glossary:object]]// that denotes a //[[CL:Glossary:logical host]]// and that is one of: a //[[CL:Glossary:string]]// (denoting the //[[CL:Glossary:logical host]]// that it names), or a //[[CL:Glossary:logical host]]// (denoting itself). (Note that because the representation of a //[[CL:Glossary:logical host]]// is //[[CL:Glossary:implementation-dependent]]//, it is possible that an //[[CL:Glossary:implementation]]// might represent a //[[CL:Glossary:logical host]]// as the //[[CL:Glossary:string]]// that names it.) ===logical pathname=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:logical-pathname]]**. ===long float=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:long-float]]**. ===loop keyword=== //n.//, //Trad.// * a symbol that is a specially recognized part of the syntax of an extended **[[CL:Macros:loop]]** //[[CL:Glossary:form]]//. Such symbols are recognized by their //[[CL:Glossary:name]]// (using **[[CL:Functions:string-equal|string=]]**), not by their identity; as such, they may be in any package. A //[[CL:Glossary:loop keyword]]// is not a //[[CL:Glossary:keyword]]//. ===lowercase=== //adj.// (of a //[[CL:Glossary:character]]//) * being among //[[CL:Glossary:standard character|standard characters]]// corresponding to the small letters ''a'' through ''z'', or being some other //[[CL:Glossary:implementation-defined]]// //[[CL:Glossary:character]]// that is defined by the //[[CL:Glossary:implementation]]// to be //[[CL:Glossary:lowercase]]//. \Seesection\CharactersWithCase. =====M===== ===macro=== //n.// * 1. a //[[CL:Glossary:macro form]]// * 2. a //[[CL:Glossary:macro function]]//. * 3. a //[[CL:Glossary:macro name]]//. ===macro character=== //n.// * a //[[CL:Glossary:character]]// which, when encountered by the //[[CL:Glossary:Lisp reader]]// in its main dispatch loop, introduces a //[[CL:Glossary:reader macro|reader macro₁]]//. (//[[CL:Glossary:|macro characterMacro characters]]// have nothing to do with //[[CL:Glossary:macro|macros]]//.) ===macro expansion=== //n.// * 1. the process of translating a //[[CL:Glossary:macro form]]// into another //[[CL:Glossary:form]]//. * 2. the //[[CL:Glossary:form]]// resulting from this process. ===macro form=== //n.// * a //[[CL:Glossary:form]]// that stands for another //[[CL:Glossary:form]]// (e.g. for the purposes of abstraction, information hiding, or syntactic convenience); that is, either a //[[CL:Glossary:compound form]]// whose first element is a //[[CL:Glossary:macro name]]//, or a //[[CL:Glossary:form]]// that is a //[[CL:Glossary:symbol]]// that names a //[[CL:Glossary:symbol macro]]//. ===macro function=== //n.// * a //[[CL:Glossary:function]]// of two arguments, a //[[CL:Glossary:form]]// and an //[[CL:Glossary:environment]]//, that implements //[[CL:Glossary:macro expansion]]// by producing a //[[CL:Glossary:form]]// to be evaluated in place of the original argument //[[CL:Glossary:form]]//. ===macro lambda list=== //n.// * an //[[CL:Glossary:extended lambda list]]// used in //[[CL:Glossary:form|forms]]// that //[[CL:Glossary:establish]]// //[[CL:Glossary:macro]]// definitions, such as **[[CL:Macros:defmacro]]** and **[[CL:Special Operators:macrolet]]**. \Seesection\MacroLambdaLists. ===macro name=== //n.// * a //[[CL:Glossary:name]]// for which **[[CL:Functions:macro-function]]** returns //[[CL:Glossary:true]]// and which when used as the first element of a //[[CL:Glossary:compound form]]// identifies that //[[CL:Glossary:form]]// as a //[[CL:Glossary:macro form]]//. ===macroexpand hook=== //n.// * the //[[CL:Glossary:function]]// that is the //[[CL:Glossary:value]]// of **[[CL:Variables:star-macroexpand-hook-star|*macroexpand-hook*]]**. ===mapping=== //n.// * 1. a type of iteration in which a //[[CL:Glossary:function]]// is successively applied to //[[CL:Glossary:object|objects]]// taken from corresponding entries in collections such as //[[CL:Glossary:sequence|sequences]]// or //[[CL:Glossary:hash table|hash tables]]//. * 2. //Math.// a relation between two sets in which each element of the first set (the "domain") is assigned one element of the second set (the "range"). ===metaclass=== //n.// * 1. a //[[CL:Glossary:class]]// whose instances are //[[CL:Glossary:class|classes]]//. * 2. (of an //[[CL:Glossary:object]]//) the //[[CL:Glossary:class]]// of the //[[CL:Glossary:class]]// of the //[[CL:Glossary:object]]//. ===Metaobject Protocol=== //n.// * one of many possible descriptions of how a //[[CL:Glossary:conforming implementation]]// might implement various aspects of the Common Lisp Object System. This description is beyond the scope of this document, and no //[[CL:Glossary:conforming implementation]]// is required to adhere to it except as noted explicitly in this specification. Nevertheless, its existence helps to establish normative practice, and implementors with no reason to diverge from it are encouraged to consider making their //[[CL:Glossary:implementation]]// adhere to it where possible. It is described in detail in the book //The Art Of Metaobject Protocol// by Gregor Kiczales. ===method=== //n.// * an //[[CL:Glossary:object]]// that is part of a //[[CL:Glossary:generic function]]// and which provides information about how that //[[CL:Glossary:generic function]]// should behave when its //[[CL:Glossary:argument|arguments]]// are //[[CL:Glossary:object|objects]]// of certain //[[CL:Glossary:class|classes]]// or with certain identities. ===method combination=== //n.// * 1. generally, the composition of a set of //[[CL:Glossary:method|methods]]// to produce an //[[CL:Glossary:effective method]]// for a //[[CL:Glossary:generic function]]//. * 2. an object of //[[CL:Glossary:type]]// **[[CL:Types:method-combination]]**, which represents the details of how the //[[CL:Glossary:method combination|method combination₁]]// for one or more specific //[[CL:Glossary:generic function|generic functions]]// is to be performed. ===method-defining form=== //n.// * a //[[CL:Glossary:form]]// that defines a //[[CL:Glossary:method]]// for a //[[CL:Glossary:generic function]]//, whether explicitly or implicitly. \Seesection\IntroToGFs. ===method-defining operator=== //n.// * an //[[CL:Glossary:operator]]// corresponding to a //[[CL:Glossary:method-defining form]]//. \Seefigure\StdMethDefOps. ===minimal compilation=== //n.// * actions the //[[CL:Glossary:compiler]]// must take at compile time. \Seesection\CompilationSemantics. ===modified lambda list=== //n.// * a list resembling an //[[CL:Glossary:ordinary lambda list]]// in form and purpose, but which deviates in syntax or functionality from the definition of an //[[CL:Glossary:ordinary lambda list]]//. See //[[CL:Glossary:ordinary lambda list]]//. "**[[CL:Macros:deftype]]** uses a modified lambda list." ===most recent=== //adj.// * innermost; that is, having been //[[CL:Glossary:establish|established]]// (and not yet //[[CL:Glossary:disestablish|disestablished]]//) more recently than any other of its kind. ===multiple escape=== //n.//, //adj.// * 1. //n.// the //[[CL:Glossary:syntax type]]// of a //[[CL:Glossary:character]]// that is used in pairs to indicate that the enclosed //[[CL:Glossary:character|characters]]// are to be treated as //[[CL:Glossary:alphabetic|alphabetic₂]]// //[[CL:Glossary:character|characters]]// with their //[[CL:Glossary:case]]// preserved. For details, \seesection\MultipleEscapeChar. * 2. //adj.// (of a //[[CL:Glossary:character]]//) having the //[[CL:Glossary:multiple escape]]// //[[CL:Glossary:syntax type]]//. * 3. //n.// a //[[CL:Glossary:multiple escape|multiple escape₂]]// //[[CL:Glossary:character]]//. (In the //[[CL:Glossary:standard readtable]]//, //[[CL:Glossary:vertical-bar]]// is a //[[CL:Glossary:multiple escape]]// //[[CL:Glossary:character]]//.) ===multiple values=== //n.// * 1. more than one //[[CL:Glossary:value]]//. "The function **[[CL:Functions:truncate]]** returns multiple values." * 2. a variable number of //[[CL:Glossary:value|values]]//, possibly including zero or one. "The function **[[CL:Functions:values]]** returns multiple values." * 3. a fixed number of values other than one. "The macro **[[CL:Macros:multiple-value-bind]]** is among the few operators in Common Lisp which can detect and manipulate multiple values." =====N===== ===name=== //n.//, //v.t.// * 1. //n.// an //[[CL:Glossary:identifier]]// by which an //[[CL:Glossary:object]]//, a //[[CL:Glossary:binding]]//, or an //[[CL:Glossary:exit point]]// is referred to by association using a //[[CL:Glossary:binding]]//. * 2. //v.t.// to give a //[[CL:Glossary:name]]// to. * 3. //n.// (of an //[[CL:Glossary:object]]// having a name component) the //[[CL:Glossary:object]]// which is that component. "The string which is a symbol's name is returned by **[[CL:Functions:symbol-name]]**." * 4. //n.// (of a //[[CL:Glossary:pathname]]//) a. the name component, returned by **[[CL:Functions:pathname-name]]**. b. the entire namestring, returned by **[[CL:Functions:namestring]]**. * 5. //n.// (of a //[[CL:Glossary:character]]//) a //[[CL:Glossary:string]]// that names the //[[CL:Glossary:character]]// and that has //[[CL:Glossary:length]]// greater than one. (All //[[CL:Glossary:non-graphic]]// //[[CL:Glossary:character|characters]]// are required to have //[[CL:Glossary:name|names]]// unless they have some //[[CL:Glossary:implementation-defined]]// //[[CL:Glossary:attribute]]// which is not //[[CL:Glossary:null]]//. Whether or not other //[[CL:Glossary:character|characters]]// have //[[CL:Glossary:name|names]]// is //[[CL:Glossary:implementation-dependent]]//.) ===named constant=== //n.// * a //[[CL:Glossary:variable]]// that is defined by Common Lisp, by the //[[CL:Glossary:implementation]]//, or by user code (see **[[CL:Macros:defconstant]]**) to always //[[CL:Glossary:yield]]// the same //[[CL:Glossary:value]]// when //[[CL:Glossary:evaluate|evaluated]]//. "The value of a named constant may not be changed by assignment or by binding." ===namespace=== //n.// * 1. //[[CL:Glossary:binding|bindings]]// whose denotations are restricted to a particular kind. "The bindings of names to tags is the tag namespace." * 2. any //[[CL:Glossary:mapping]]// whose domain is a set of //[[CL:Glossary:name|names]]//. "A package defines a namespace." ===namestring=== //n.// * a //[[CL:Glossary:string]]// that represents a //[[CL:Glossary:filename]]// using either the //[[CL:Glossary:standardized]]// notation for naming //[[CL:Glossary:logical pathname|logical pathnames]]// described in \secref\LogPathNamestrings, or some //[[CL:Glossary:implementation-defined]]// notation for naming a //[[CL:Glossary:physical pathname]]//. \issue{PATHNAME-HOST-PARSING:RECOGNIZE-LOGICAL-HOST-NAMES} ===newline=== //n.// * the //[[CL:Glossary:standard character]]// ''" "'', notated for the //[[CL:Glossary:Lisp reader]]// as ''#\Newline''. ===next method=== //n.// * the next //[[CL:Glossary:method]]// to be invoked with respect to a given //[[CL:Glossary:method]]// for a particular set of arguments or argument //[[CL:Glossary:class|classes]]//. \Seesection\ApplyMethCombToSortedMethods. ===nickname=== //n.// (of a //[[CL:Glossary:package]]//) * one of possibly several //[[CL:Glossary:name|names]]// that can be used to refer to the //[[CL:Glossary:package]]// but that is not the primary //[[CL:Glossary:name]]// of the //[[CL:Glossary:package]]//. ===nil=== //n.// * the //[[CL:Glossary:object]]// that is at once the //[[CL:Glossary:symbol]]// named ''"NIL"'' in the //[[CL:Glossary:package]]// **''common-lisp''**, the //[[CL:Glossary:empty list]]//, the //[[CL:Glossary:boolean]]// (or //[[CL:Glossary:generalized boolean]]//) representing //[[CL:Glossary:false]]//, and the //[[CL:Glossary:name]]// of the //[[CL:Glossary:empty type]]//. ===non-atomic=== //adj.// * being other than an //[[CL:Glossary:atom]]//; i.e. being a //[[CL:Glossary:cons]]//. ===non-constant variable=== //n.// * a //[[CL:Glossary:variable]]// that is not a //[[CL:Glossary:constant variable]]//. ===non-correctable=== //adj.// (of an //[[CL:Glossary:error]]//) * not intentionally //[[CL:Glossary:correctable]]//. (Because of the dynamic nature of //[[CL:Glossary:restart|restarts]]//, it is neither possible nor generally useful to completely prohibit an //[[CL:Glossary:error]]// from being //[[CL:Glossary:correctable]]//. This term is used in order to express an intent that no special effort should be made by //[[CL:Glossary:code]]// signaling an //[[CL:Glossary:error]]// to make that //[[CL:Glossary:error]]// //[[CL:Glossary:correctable]]//; however, there is no actual requirement on //[[CL:Glossary:conforming program|conforming programs]]// or //[[CL:Glossary:conforming implementation|conforming implementations]]// imposed by this term.) ===non-empty=== //adj.// * having at least one //[[CL:Glossary:element]]//. ===non-generic function=== //n.// * a //[[CL:Glossary:function]]// that is not a //[[CL:Glossary:generic function]]//. ===non-graphic=== //adj.// (of a //[[CL:Glossary:character]]//) * not //[[CL:Glossary:graphic]]//. \Seesection\GraphicChars. ===non-list=== //n.//, //adj.// * other than a //[[CL:Glossary:list]]//; i.e. a //[[CL:Glossary:non-nil]]// //[[CL:Glossary:atom]]//. ===non-local exit=== //n.// * a transfer of control (and sometimes //[[CL:Glossary:value|values]]//) to an //[[CL:Glossary:exit point]]// for reasons other than a //[[CL:Glossary:normal return]]//. "The operators **[[CL:Special Operators:go]]**, **[[CL:Special Operators:throw]]**, and **[[CL:Special Operators:return-from]]** cause a non-local exit." ===non-nil=== //n.//, //adj.// * not **[[CL:Constant Variables:nil]]**. Technically, any //[[CL:Glossary:object]]// which is not **[[CL:Constant Variables:nil]]** can be referred to as //[[CL:Glossary:true]]//, but that would tend to imply a unique view of the //[[CL:Glossary:object]]// as a //[[CL:Glossary:generalized boolean]]//. Referring to such an //[[CL:Glossary:object]]// as //[[CL:Glossary:non-nil]]// avoids this implication. ===non-null lexical environment=== //n.// * a //[[CL:Glossary:lexical environment]]// that has additional information not present in the //[[CL:Glossary:global environment]]//, such as one or more //[[CL:Glossary:binding|bindings]]//. ===non-simple=== //adj.// * not //[[CL:Glossary:simple]]//. ===non-terminating=== //adj.// (of a //[[CL:Glossary:macro character]]//) * being such that it is treated as a constituent //[[CL:Glossary:character]]// when it appears in the middle of an extended token. \Seesection\ReaderAlgorithm. ===non-top-level form=== //n.// * a //[[CL:Glossary:form]]// that, by virtue of its position as a //[[CL:Glossary:subform]]// of another //[[CL:Glossary:form]]//, is not a //[[CL:Glossary:top level form]]//. \Seesection\TopLevelForms. ===normal return=== //n.// * the natural transfer of control and //[[CL:Glossary:value|values]]// which occurs after the complete //[[CL:Glossary:execute|execution]]// of a //[[CL:Glossary:form]]//. ===normalized=== //adj.//, //ANSI//, //IEEE// (of a //[[CL:Glossary:float]]//) * conforming to the description of "normalized" as described by {\IEEEFloatingPoint}. See //[[CL:Glossary:denormalized]]//. ===null=== //adj.//, //n.// * 1. //adj.// a. (of a //[[CL:Glossary:list]]//) having no //[[CL:Glossary:element|elements]]//: empty. See //[[CL:Glossary:empty list]]//. b. (of a //[[CL:Glossary:string]]//) having a //[[CL:Glossary:length]]// of zero. (It is common, both within this document and in observed spoken behavior, to refer to an empty string by an apparent definite reference, as in "the //[[CL:Glossary:null]]// //[[CL:Glossary:string]]//" even though no attempt is made to //[[CL:Glossary:intern|intern₂]]// null strings. The phrase "a //[[CL:Glossary:null]]// //[[CL:Glossary:string]]//" is technically more correct, but is generally considered awkward by most Lisp programmers. As such, the phrase "the //[[CL:Glossary:null]]// //[[CL:Glossary:string]]//" should be treated as an indefinite reference in all cases except for anaphoric references.) c. (of an //[[CL:Glossary:implementation-defined]]// //[[CL:Glossary:attribute]]// of a //[[CL:Glossary:character]]//) An //[[CL:Glossary:object]]// to which the value of that //[[CL:Glossary:attribute]]// defaults if no specific value was requested. * 2. //n.// an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:null]]** (the only such //[[CL:Glossary:object]]// being **[[CL:Constant Variables:nil]]**). ===null lexical environment=== //n.// * the //[[CL:Glossary:lexical environment]]// which has no //[[CL:Glossary:binding|bindings]]//. ===number=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:number]]**. ===numeric=== //adj.// (of a //[[CL:Glossary:character]]//) * being one of the //[[CL:Glossary:standard character|standard characters]]// ''0'' through ''9'', or being some other //[[CL:Glossary:graphic]]// //[[CL:Glossary:character]]// defined by the //[[CL:Glossary:implementation]]// to be //[[CL:Glossary:numeric]]//. =====O===== ===object=== //n.// * 1. any Lisp datum. "The function **[[CL:Functions:cons]]** creates an object which refers to two other objects." * 2. (immediately following the name of a //[[CL:Glossary:type]]//) an //[[CL:Glossary:object]]// which is of that //[[CL:Glossary:type]]//, used to emphasize that the //[[CL:Glossary:object]]// is not just a //[[CL:Glossary:name]]// for an object of that //[[CL:Glossary:type]]// but really an //[[CL:Glossary:element]]// of the //[[CL:Glossary:type]]// in cases where //[[CL:Glossary:object|objects]]// of that //[[CL:Glossary:type]]// (such as **[[CL:Types:function]]** or **[[CL:Types:class]]**) are commonly referred to by //[[CL:Glossary:name]]//. "The function **[[CL:Functions:symbol-function]]** takes a function name and returns a function object." ===object-traversing=== //adj.// * operating in succession on components of an //[[CL:Glossary:object]]//. "The operators **[[CL:Functions:mapcar]]**, **[[CL:Functions:maphash]]**, **[[CL:Macros:with-package-iterator]]** and **[[CL:Functions:count]]** perform object-traversing operations." ===open=== //adj.//, //v.t.// (a //[[CL:Glossary:file]]//) * 1. //v.t.// to create and return a //[[CL:Glossary:stream]]// to the //[[CL:Glossary:file]]//. * 2. //adj.// (of a //[[CL:Glossary:stream]]//) having been //[[CL:Glossary:open|opened₁]]//, but not yet //[[CL:Glossary:closed]]//. ===operator=== //n.// * 1. a //[[CL:Glossary:function]]//, //[[CL:Glossary:macro]]//, or //[[CL:Glossary:special operator]]//. * 2. a //[[CL:Glossary:symbol]]// that names such a //[[CL:Glossary:function]]//, //[[CL:Glossary:macro]]//, or //[[CL:Glossary:special operator]]//. * 3. (in a **[[CL:Special Operators:function]]** //[[CL:Glossary:special form]]//) the //[[CL:Glossary:cadr]]// of the **[[CL:Special Operators:function]]** //[[CL:Glossary:special form]]//, which might be either an //[[CL:Glossary:operator|operator₂]]// or a //[[CL:Glossary:lambda expression]]//. * 4. (of a //[[CL:Glossary:compound form]]//) the //[[CL:Glossary:car]]// of the //[[CL:Glossary:compound form]]//, which might be either an //[[CL:Glossary:operator|operator₂]]// or a //[[CL:Glossary:lambda expression]]//, and which is never ''([[CL:Macros:setf]] //[[CL:Glossary:symbol]]//)''. ===optimize quality=== //n.// * one of several aspects of a program that might be optimizable by certain compilers. Since optimizing one such quality might conflict with optimizing another, relative priorities for qualities can be established in an **[[CL:Declarations:optimize]]** //[[CL:Glossary:declaration]]//. The //[[CL:Glossary:standardized]]// //[[CL:Glossary:optimize quality|optimize qualities]]// are **''compilation-speed''** (speed of the compilation process), **''debug''** (ease of debugging), **''safety''** (run-time error checking), **''space''** (both code size and run-time space), and **''speed''** (of the object code). //[[CL:Glossary:implementation|implementations]]// may define additional //[[CL:Glossary:optimize quality|optimize qualities]]//. \issue{OPTIMIZE-DEBUG-INFO:NEW-QUALITY} ===optional parameter=== //n.// * a //[[CL:Glossary:parameter]]// for which a corresponding positional //[[CL:Glossary:argument]]// is optional. If the //[[CL:Glossary:argument]]// is not supplied, a default value is used. See also //[[CL:Glossary:supplied-p parameter]]//. ===ordinary function=== //n.// * a //[[CL:Glossary:function]]// that is not a //[[CL:Glossary:generic function]]//. ===ordinary lambda list=== //n.// * the kind of //[[CL:Glossary:lambda list]]// used by **[[CL:Symbols:lambda]]**. See //[[CL:Glossary:modified lambda list]]// and //[[CL:Glossary:extended lambda list]]//. "**[[CL:Macros:defun]]** uses an ordinary lambda list." ===otherwise inaccessible part=== //n.// (of an //[[CL:Glossary:object]]//, //O₁//) * an //[[CL:Glossary:object]]//, //O₂//, which would be made //[[CL:Glossary:inaccessible]]// if //O₁// were made //[[CL:Glossary:inaccessible]]//. (Every //[[CL:Glossary:object]]// is an //[[CL:Glossary:otherwise inaccessible part]]// of itself.) ===output=== //adj.// (of a //[[CL:Glossary:stream]]//) * supporting output operations (i.e. being a "data sink"). An //[[CL:Glossary:output]]// //[[CL:Glossary:stream]]// might also be an //[[CL:Glossary:input]]// //[[CL:Glossary:stream]]//, in which case it is sometimes called a //[[CL:Glossary:bidirectional]]// //[[CL:Glossary:stream]]//. See **[[CL:Functions:output-stream-p]]**. =====P===== ===package=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:package]]**. ===package cell=== //n.//, //Trad.// (of a //[[CL:Glossary:symbol]]//) * the //[[CL:Glossary:place]]// in a //[[CL:Glossary:symbol]]// that holds one of possibly several //[[CL:Glossary:package|packages]]// in which the //[[CL:Glossary:symbol]]// is //[[CL:Glossary:interned]]//, called the //[[CL:Glossary:home package]]//, or which holds **[[CL:Constant Variables:nil]]** if no such //[[CL:Glossary:package]]// exists or is known. See **[[CL:Functions:symbol-package]]**. ===package designator=== //n.// * a //[[CL:Glossary:designator]]// for a //[[CL:Glossary:package]]//; that is, an //[[CL:Glossary:object]]// that denotes a //[[CL:Glossary:package]]// and that is one of: a //[[CL:Glossary:string designator]]// (denoting the //[[CL:Glossary:package]]// that has the //[[CL:Glossary:string]]// that it designates as its //[[CL:Glossary:name]]// or as one of its //[[CL:Glossary:nickname|nicknames]]//), or a //[[CL:Glossary:package]]// (denoting itself). ===package marker=== //n.// * a character which is used in the textual notation for a symbol to separate the package name from the symbol name, and which is //[[CL:Glossary:colon]]// in the //[[CL:Glossary:standard readtable]]//. \Seesection\CharacterSyntax. ===package prefix=== //n.// * a notation preceding the //[[CL:Glossary:name]]// of a //[[CL:Glossary:symbol]]// in text that is processed by the //[[CL:Glossary:Lisp reader]]//, which uses a //[[CL:Glossary:package]]// //[[CL:Glossary:name]]// followed by one or more //[[CL:Glossary:package marker|package markers]]//, and which indicates that the symbol is looked up in the indicated //[[CL:Glossary:package]]//. ===package registry=== //n.// * a mapping of //[[CL:Glossary:name|names]]// to //[[CL:Glossary:package]]// //[[CL:Glossary:object|objects]]//. It is possible for there to be a //[[CL:Glossary:package]]// //[[CL:Glossary:object]]// which is not in this mapping; such a //[[CL:Glossary:package]]// is called an //[[CL:Glossary:unregistered package]]//. //[[CL:Glossary:operator|operators]]// such as **[[CL:Functions:find-package]]** consult this mapping in order to find a //[[CL:Glossary:package]]// from its //[[CL:Glossary:name]]//. //[[CL:Glossary:operator|operators]]// such as **[[CL:Macros:do-all-symbols]]**, **[[CL:Functions:find-all-symbols]]**, and **[[CL:Functions:list-all-packages]]** operate only on //[[CL:Glossary:package|packages]]// that exist in the //[[CL:Glossary:package registry]]//. ===pairwise=== //adv.// (of an adjective on a set) * applying individually to all possible pairings of elements of the set. "The types //A//, //B//, and //C// are pairwise disjoint if //A// and //B// are disjoint, //B// and //C// are disjoint, and //A// and //C// are disjoint." ===parallel=== //adj.//, //Trad.// (of //[[CL:Glossary:binding]]// or //[[CL:Glossary:assign|assignment]]//) * done in the style of **[[CL:Macros:psetq]]**, **[[CL:Special Operators:let]]**, or **[[CL:Macros:do]]**; that is, first evaluating all of the //[[CL:Glossary:form|forms]]// that produce //[[CL:Glossary:value|values]]//, and only then //[[CL:Glossary:|assigning]]// or //[[CL:Glossary:binding]]// the //[[CL:Glossary:variable|variables]]// (or //[[CL:Glossary:place|places]]//). Note that this does not imply traditional computational "parallelism" since the //[[CL:Glossary:form|forms]]// that produce //[[CL:Glossary:value|values]]// are evaluated //[[CL:Glossary:sequentially]]//. See //[[CL:Glossary:sequential]]//. ===parameter=== //n.// * 1. (of a //[[CL:Glossary:function]]//) a //[[CL:Glossary:variable]]// in the definition of a //[[CL:Glossary:function]]// which takes on the //[[CL:Glossary:value]]// of a corresponding //[[CL:Glossary:argument]]// (or of a //[[CL:Glossary:list]]// of corresponding arguments) to that //[[CL:Glossary:function]]// when it is called, or which in some cases is given a default value because there is no corresponding //[[CL:Glossary:argument]]//. * 2. (of a //[[CL:Glossary:format directive]]//) an //[[CL:Glossary:object]]// received as data flow by a //[[CL:Glossary:format directive]]// due to a prefix notation within the //[[CL:Glossary:format string]]// at the //[[CL:Glossary:format directive]]//'s point of use. \Seesection\FormattedOutput. "In ''"~3,'0D"'', the number ''3'' and the character ''#\0'' are parameters to the ''~D'' format directive." ===parameter specializer=== //n.// * 1. (of a //[[CL:Glossary:method]]//) an //[[CL:Glossary:expression]]// which constrains the //[[CL:Glossary:method]]// to be applicable only to //[[CL:Glossary:argument]]// sequences in which the corresponding //[[CL:Glossary:argument]]// matches the //[[CL:Glossary:parameter specializer]]//. * 2. a //[[CL:Glossary:class]]//, or a //[[CL:Glossary:list]]// ''([[CL:Types:eql]] //[[CL:Glossary:object]]//)''. ===parameter specializer name=== //n.// * 1. (of a //[[CL:Glossary:method]]// definition) an expression used in code to name a //[[CL:Glossary:parameter specializer]]//. \Seesection\IntroToMethods. * 2. a //[[CL:Glossary:class]]//, a //[[CL:Glossary:symbol]]// naming a //[[CL:Glossary:class]]//, or a //[[CL:Glossary:list]]// ''([[CL:Types:eql]] //[[CL:Glossary:form]]//)''. \issue{CLASS-OBJECT-SPECIALIZER:AFFIRM} ===pathname=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:pathname]]**, which is a structured representation of the name of a //[[CL:Glossary:file]]//. A //[[CL:Glossary:pathname]]// has six components: a "host," a "device," a "directory," a "name," a "type," and a "version." ===pathname designator=== //n.// * a //[[CL:Glossary:designator]]// for a //[[CL:Glossary:pathname]]//; that is, an //[[CL:Glossary:object]]// that denotes a //[[CL:Glossary:pathname]]// and that is one of: a //[[CL:Glossary:pathname]]// //[[CL:Glossary:name|namestring]]// (denoting the corresponding //[[CL:Glossary:pathname]]//), a //[[CL:Glossary:stream associated with a file]]// (denoting the //[[CL:Glossary:pathname]]// used to open the //[[CL:Glossary:file]]//; this may be, but is not required to be, the actual name of the //[[CL:Glossary:file]]//), or a //[[CL:Glossary:pathname]]// (denoting itself). \Seesection\OpenAndClosedStreams. \issue{PATHNAME-LOGICAL:ADD} \issue{PATHNAME-HOST-PARSING:RECOGNIZE-LOGICAL-HOST-NAMES} ===physical pathname=== //n.// a //[[CL:Glossary:pathname]]// that is not a //[[CL:Glossary:logical pathname]]//. ===place=== //n.// * 1. a //[[CL:Glossary:form]]// which is suitable for use as a //[[CL:Glossary:generalized reference]]//. * 2. the conceptual location referred to by such a //[[CL:Glossary:place|place₁]]//. ===plist=== //n.// * a //[[CL:Glossary:property list]]//. ===portable=== //adj.// (of //[[CL:Glossary:code]]//) * required to produce equivalent results and observable side effects in all //[[CL:Glossary:conforming implementation|conforming implementations]]//. ===potential copy=== //n.// (of an //[[CL:Glossary:object]]// //O₁// subject to constriants) * an //[[CL:Glossary:object]]// //O₂// that if the specified constraints are satisfied by //O₁// without any modification might or might not be //[[CL:Glossary:identical]]// to //O₁//, or else that must be a //[[CL:Glossary:fresh]]// //[[CL:Glossary:object]]// that resembles a //[[CL:Glossary:copy]]// of //O₁// except that it has been modified as necessary to satisfy the constraints. ===potential number=== //n.// * a textual notation that might be parsed by the //[[CL:Glossary:Lisp reader]]// in some //[[CL:Glossary:conforming implementation]]// as a //[[CL:Glossary:number]]// but is not required to be parsed as a //[[CL:Glossary:number]]//. No //[[CL:Glossary:object]]// is a //[[CL:Glossary:potential number]]// - either an //[[CL:Glossary:object]]// is a //[[CL:Glossary:number]]// or it is not. \Seesection\PotentialNumbersAsTokens. ===pprint dispatch table=== //n.// * an //[[CL:Glossary:object]]// that can be the //[[CL:Glossary:value]]// of **[[CL:Variables:star-print-pprint-dispatch-star|*print-pprint-dispatch*]]** and hence can control how //[[CL:Glossary:object|objects]]// are printed when **[[CL:Variables:star-print-pretty-star|*print-pretty*]]** is //[[CL:Glossary:true]]//. \Seesection\PPrintDispatchTables. ===predicate=== //n.// * a //[[CL:Glossary:function]]// that returns a //[[CL:Glossary:generalized boolean]]// as its first value. **Editor Note:** //This definition is imprecise, as every value in Common Lisp is a generalized boolean. The intent of a predicate is to return a truth value while not having any side effects. To quote Common Lisp the Language 2: "A predicate is a //[[CL:Glossary:function]]// that tests for some //[[CL:Glossary:condition]]// involving its //[[CL:Glossary:argument|arguments]]// and returns **[[CL:Constant Variables:nil]]** if the //[[CL:Glossary:condition]]// is false, or some //[[CL:Glossary:non-nil]]// //[[CL:Glossary:value]]// if the //[[CL:Glossary:condition]]// is true."// ===present=== //n.// * 1. (of a //[[CL:Glossary:feature]]// in a //[[CL:Glossary:Lisp image]]//) a state of being that is in effect if and only if the //[[CL:Glossary:symbol]]// naming the //[[CL:Glossary:feature]]// is an //[[CL:Glossary:element]]// of the //[[CL:Glossary:feature|features list]]//. * 2. (of a //[[CL:Glossary:symbol]]// in a //[[CL:Glossary:package]]//) being accessible in that //[[CL:Glossary:package]]// directly, rather than being inherited from another //[[CL:Glossary:package]]//. ===pretty print=== //v.t.// (an //[[CL:Glossary:object]]//) * to invoke the //[[CL:Glossary:pretty printer]]// on the //[[CL:Glossary:object]]//. ===pretty printer=== //n.// * the procedure that prints the character representation of an //[[CL:Glossary:object]]// onto a //[[CL:Glossary:stream]]// when the //[[CL:Glossary:value]]// of **[[CL:Variables:star-print-pretty-star|*print-pretty*]]** is //[[CL:Glossary:true]]//, and that uses layout techniques (e.g. indentation) that tend to highlight the structure of the //[[CL:Glossary:object]]// in a way that makes it easier for human readers to parse visually. See **[[CL:Variables:star-print-pprint-dispatch-star|*print-pprint-dispatch*]]** and \secref\PPrinter. ===pretty printing stream=== //n.// * a //[[CL:Glossary:stream]]// that does pretty printing. Such streams are created by the //[[CL:Glossary:macro]]// **[[CL:Macros:pprint-logical-block]]** as a link between the output stream and the logical block. ===primary method=== //n.// * a member of one of two sets of //[[CL:Glossary:method|methods]]// (the set of //[[CL:Glossary:auxiliary method|auxiliary 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. ===primary value=== //n.// (of //[[CL:Glossary:value|values]]// resulting from the //[[CL:Glossary:evaluation]]// of a //[[CL:Glossary:form]]//) * the first //[[CL:Glossary:value]]//, if any, or else **[[CL:Constant Variables:nil]]** if there are no //[[CL:Glossary:value|values]]//. "The primary value returned by **[[CL:Functions:truncate]]** is an integer quotient, truncated toward zero." ===principal=== //adj.// (of a value returned by a Common Lisp //[[CL:Glossary:function]]// that implements a mathematically irrational or transcendental function defined in the complex domain) * of possibly many (sometimes an infinite number of) correct values for the mathematical function, being the particular //[[CL:Glossary:value]]// which the corresponding Common Lisp //[[CL:Glossary:function]]// has been defined to return. ===print name=== //n.//, //Trad.// (usually of a //[[CL:Glossary:symbol]]//) * a //[[CL:Glossary:name|name₃]]//. ===printer control variable=== //n.// * a //[[CL:Glossary:variable]]// whose specific purpose is to control some action of the //[[CL:Glossary:Lisp printer]]//; that is, one of the //[[CL:Glossary:variable|variables]]// in \figref\StdPrinterControlVars, or else some //[[CL:Glossary:implementation-defined]]// //[[CL:Glossary:variable]]// which is defined by the //[[CL:Glossary:implementation]]// to be a //[[CL:Glossary:printer control variable]]//. ===printer escaping=== //n.// * the combined state of the //[[CL:Glossary:printer control variable|printer control variables]]// **[[CL:Variables:star-print-escape-star|*print-escape*]]** and **[[CL:Variables:star-print-readably-star|*print-readably*]]**. If the value of either **[[CL:Variables:star-print-readably-star|*print-readably*]]** or **[[CL:Variables:star-print-escape-star|*print-escape*]]** is //[[CL:Glossary:true]]//, then printer escaping is "enabled"; otherwise (if the values of both **[[CL:Variables:star-print-readably-star|*print-readably*]]** and **[[CL:Variables:star-print-escape-star|*print-escape*]]** are //[[CL:Glossary:false]]//), then //[[CL:Glossary:printer escaping]]// is "disabled". \issue{PRINT-READABLY-BEHAVIOR:CLARIFY} ===printing=== //adj.// (of a //[[CL:Glossary:character]]//) * being a //[[CL:Glossary:graphic]]// //[[CL:Glossary:character]]// other than //[[CL:Glossary:space]]//. ===process=== //v.t.// (a //[[CL:Glossary:form]]// by the //[[CL:Glossary:compiler]]//) * to perform //[[CL:Glossary:minimal compilation]]//, determining the time of evaluation for a //[[CL:Glossary:form]]//, and possibly //[[CL:Glossary:evaluate|evaluating]]// that //[[CL:Glossary:form]]// (if required). ===processor=== //n.//, //ANSI// * an //[[CL:Glossary:implementation]]//. ===proclaim=== //v.t.// (a //[[CL:Glossary:proclamation]]//) * to //[[CL:Glossary:establish]]// that //[[CL:Glossary:proclamation]]//. ===proclamation=== //n.// * a //[[CL:Glossary:global declaration]]//. ===prog tag=== //n.//, //Trad.// * a //[[CL:Glossary:go tag]]//. ===program=== //n.//, //Trad.// * Common Lisp //[[CL:Glossary:code]]//. ===programmer=== //n.// * an active entity, typically a human, that writes a //[[CL:Glossary:program]]//, and that might or might not also be a //[[CL:Glossary:user]]// of the //[[CL:Glossary:program]]//. ===programmer code=== //n.// * //[[CL:Glossary:code]]// that is supplied by the programmer; that is, //[[CL:Glossary:code]]// that is not //[[CL:Glossary:system code]]//. ===proper list=== //n.// * a //[[CL:Glossary:list]]// terminated by the //[[CL:Glossary:empty list]]//. (The //[[CL:Glossary:empty list]]// is a //[[CL:Glossary:proper list]]//.) See //[[CL:Glossary:improper list]]//. ===proper name=== //n.// (of a //[[CL:Glossary:class]]//) * a //[[CL:Glossary:symbol]]// that //[[CL:Glossary:name|names]]// the //[[CL:Glossary:class]]// whose //[[CL:Glossary:name]]// is that //[[CL:Glossary:symbol]]//. See //[[CL:Glossary:function|functions]]// **[[CL:Functions:class-name]]** and **[[CL:Functions:find-class]]**. ===proper sequence=== //n.// * a //[[CL:Glossary:sequence]]// which is not an //[[CL:Glossary:improper list]]//; that is, a //[[CL:Glossary:vector]]// or a //[[CL:Glossary:proper list]]//. ===proper subtype=== //n.// (of a //[[CL:Glossary:type]]//) * a //[[CL:Glossary:subtype]]// of the //[[CL:Glossary:type]]// which is not the //[[CL:Glossary:same]]// //[[CL:Glossary:type]]// as the //[[CL:Glossary:type]]// (i.e. its //[[CL:Glossary:element|elements]]// are a "proper subset" of the //[[CL:Glossary:type]]//). ===property=== //n.// (of a //[[CL:Glossary:property list]]//) * 1. a conceptual pairing of a //[[CL:Glossary:property indicator]]// and its associated //[[CL:Glossary:property value]]// on a //[[CL:Glossary:property list]]//. * 2. a //[[CL:Glossary:property value]]//. ===property indicator=== //n.// (of a //[[CL:Glossary:property list]]//) * the //[[CL:Glossary:name]]// part of a //[[CL:Glossary:property]]//, used as a //[[CL:Glossary:key]]// when looking up a //[[CL:Glossary:property value]]// on a //[[CL:Glossary:property list]]//. ===property list=== //n.// * 1. a //[[CL:Glossary:list]]// containing an even number of //[[CL:Glossary:element|elements]]// that are alternating //[[CL:Glossary:name|names]]// (sometimes called //[[CL:Glossary:indicator|indicators]]// or //[[CL:Glossary:key|keys]]//) and //[[CL:Glossary:value|values]]// (sometimes called //[[CL:Glossary:property|properties]]//). When there is more than one //[[CL:Glossary:name]]// and //[[CL:Glossary:value]]// pair with the //[[CL:Glossary:identical]]// //[[CL:Glossary:name]]// in a //[[CL:Glossary:property list]]//, the first such pair determines the //[[CL:Glossary:property]]//. * 2. (of a //[[CL:Glossary:symbol]]//) the component of the //[[CL:Glossary:symbol]]// containing a //[[CL:Glossary:property list]]//. \issue{PLIST-DUPLICATES:ALLOW} ===property value=== //n.// (of a //[[CL:Glossary:property indicator]]// on a //[[CL:Glossary:property list]]//) the //[[CL:Glossary:object]]// associated with the //[[CL:Glossary:property indicator]]// on the //[[CL:Glossary:property list]]//. \issue{PLIST-DUPLICATES:ALLOW} ===purport to conform=== //v.// * make a good-faith claim of conformance. This term expresses intention to conform, regardless of whether the goal of that intention is realized in practice. For example, language implementations have been known to have bugs, and while an //[[CL:Glossary:implementation]]// of this specification with bugs might not be a //[[CL:Glossary:conforming implementation]]//, it can still //[[CL:Glossary:purport to conform]]//. This is an important distinction in certain specific cases; e.g. See **[[CL:Variables:star-features-star|*features*]]**. =====Q===== ===qualified method=== //n.// * a //[[CL:Glossary:method]]// that has one or more //[[CL:Glossary:qualifier|qualifiers]]//. ===qualifier=== //n.// (of a //[[CL:Glossary:method]]// for a //[[CL:Glossary:generic function]]//) * one of possibly several //[[CL:Glossary:object|objects]]// used to annotate the //[[CL:Glossary:method]]// in a way that identifies its role in the //[[CL:Glossary:method combination]]//. The //[[CL:Glossary:method combination]]// //[[CL:Glossary:type]]// determines how many //[[CL:Glossary:qualifier|qualifiers]]// are permitted for each //[[CL:Glossary:method]]//, which //[[CL:Glossary:qualifier|qualifiers]]// are permitted, and the semantics of those //[[CL:Glossary:qualifier|qualifiers]]//. ===query I/O=== //n.// * the //[[CL:Glossary:bidirectional]]// //[[CL:Glossary:stream]]// that is the //[[CL:Glossary:value]]// of the //[[CL:Glossary:variable]]// **[[CL:Variables:star-query-io-star|*query-io*]]**. ===quoted object=== //n.// * an //[[CL:Glossary:object]]// which is the second element of a **[[CL:Special Operators:quote]]** //[[CL:Glossary:form]]//. =====R===== ===radix=== //n.// * an //[[CL:Glossary:integer]]// between 2 and 36, inclusive, which can be used to designate a base with respect to which certain kinds of numeric input or output are performed. (There are ''n'' valid digit characters for any given //[[CL:Glossary:radix]]// ''n'', and those digits are the first ''n'' digits in the sequence ''0, 1, …, 9, A, B, …, Z'', which have the weights ''0, 1, …, 9, 10, 11, …, 35'', respectively. Case is not significant in parsing numbers of radix greater than ''10'', so "9b8a" and "9B8A" denote the same //[[CL:Glossary:radix]]// ''16'' number.) ===random state=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:random-state]]**. ===rank=== //n.// * a non-negative //[[CL:Glossary:integer]]// indicating the number of //[[CL:Glossary:dimension|dimensions]]// of an //[[CL:Glossary:array]]//. ===ratio=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:ratio]]**. ===ratio marker=== //n.// * a character which is used in the textual notation for a //[[CL:Glossary:ratio]]// to separate the numerator from the denominator, and which is //[[CL:Glossary:slash]]// in the //[[CL:Glossary:standard readtable]]//. \Seesection\CharacterSyntax. ===rational=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:rational]]**. ===read=== //v.t.// * 1. (a //[[CL:Glossary:binding]]// or //[[CL:Glossary:slot]]// or component) to obtain the //[[CL:Glossary:value]]// of the //[[CL:Glossary:binding]]// or //[[CL:Glossary:slot]]//. * 2. (an //[[CL:Glossary:object]]// from a //[[CL:Glossary:stream]]//) to parse an //[[CL:Glossary:object]]// from its representation on the //[[CL:Glossary:stream]]//. \Seesection\ReaderAlgorithm. \issue{IGNORE-USE-TERMINOLOGY:VALUE-ONLY} ===readably=== //adv.// (of a manner of printing an //[[CL:Glossary:object]]// ''O₁'') * in such a way as to permit the //[[CL:Glossary:Lisp reader]]// to later //[[CL:Glossary:read|read₂]]// the printed output into an //[[CL:Glossary:object]]// ''O₂'' that is //[[CL:Glossary:similar]]// to ''O₁''. ===reader=== //n.// * 1. a //[[CL:Glossary:function]]// that //[[CL:Glossary:read|reads₁]]// a //[[CL:Glossary:variable]]// or //[[CL:Glossary:slot]]//. * 2. the //[[CL:Glossary:Lisp reader]]//. ===reader macro=== //n.// * 1. a textual notation introduced by dispatch on one or two //[[CL:Glossary:character|characters]]// that defines special-purpose syntax for use by the //[[CL:Glossary:Lisp reader]]//, and that is implemented by a //[[CL:Glossary:reader macro function]]//. \Seesection\ReaderAlgorithm. * 2. the //[[CL:Glossary:character]]// or //[[CL:Glossary:character|characters]]// that introduce a //[[CL:Glossary:reader macro|reader macro₁]]//; that is, a //[[CL:Glossary:macro character]]// or the conceptual pairing of a //[[CL:Glossary:dispatching macro character]]// and the //[[CL:Glossary:character]]// that follows it. (A //[[CL:Glossary:reader macro]]// is not a kind of //[[CL:Glossary:macro]]//.) ===reader macro function=== //n.// * a //[[CL:Glossary:function]]// //[[CL:Glossary:designator]]// that denotes a //[[CL:Glossary:function]]// that implements a //[[CL:Glossary:reader macro|reader macro₂]]//. See //[[CL:Glossary:function|functions]]// **[[CL:Functions:set-macro-character]]** and **[[CL:Functions:set-dispatch-macro-character]]**. ===readtable=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:readtable]]**. ===readtable case=== //n.// * an attribute of a //[[CL:Glossary:readtable]]// whose value is a //[[CL:Glossary:case sensitivity mode]]//, and that selects the manner in which //[[CL:Glossary:character|characters]]// in a //[[CL:Glossary:symbol]]//'s //[[CL:Glossary:name]]// are to be treated by the //[[CL:Glossary:Lisp reader]]// and the //[[CL:Glossary:Lisp printer]]//. \Seesection\ReadtableCaseReadEffect\ and \secref\ReadtableCasePrintEffect. ===readtable designator=== //n.// * a //[[CL:Glossary:designator]]// for a //[[CL:Glossary:readtable]]//; that is, an //[[CL:Glossary:object]]// that denotes a //[[CL:Glossary:readtable]]// and that is one of: **[[CL:Constant Variables:nil]]** (denoting the //[[CL:Glossary:standard readtable]]//), or a //[[CL:Glossary:readtable]]// (denoting itself). ===recognizable subtype=== //n.// (of a //[[CL:Glossary:type]]//) * a //[[CL:Glossary:subtype]]// of the //[[CL:Glossary:type]]// which can be reliably detected to be such by the //[[CL:Glossary:implementation]]//. See **[[CL:Functions:subtypep]]**. ===recursion=== //n.// //Math.// * See //[[CL:Glossary:recursion]]//. ===reference=== //n.//, //v.t.// * 1. //n.// an act or occurrence of referring to an //[[CL:Glossary:object]]//, a //[[CL:Glossary:binding]]//, an //[[CL:Glossary:exit point]]//, a //[[CL:Glossary:tag]]//, or an //[[CL:Glossary:environment]]//. * 2. //v.t.// to refer to an //[[CL:Glossary:object]]//, a //[[CL:Glossary:binding]]//, an //[[CL:Glossary:exit point]]//, a //[[CL:Glossary:tag]]//, or an //[[CL:Glossary:environment]]//, usually by //[[CL:Glossary:name]]//. ===registered package=== //n.// * a //[[CL:Glossary:package]]// //[[CL:Glossary:object]]// that is installed in the //[[CL:Glossary:package registry]]//. (Every //[[CL:Glossary:registered package]]// has a //[[CL:Glossary:name]]// that is a //[[CL:Glossary:string]]//, as well as zero or more //[[CL:Glossary:string]]// nicknames. All //[[CL:Glossary:package|packages]]// that are initially specified by Common Lisp or created by **[[CL:Functions:make-package]]** or **[[CL:Macros:defpackage]]** are //[[CL:Glossary:registered package|registered packages]]//. //[[CL:Glossary:registered package|Registered packages]]// can be turned into //[[CL:Glossary:unregistered package|unregistered packages]]// by **[[CL:Functions:delete-package]]**.) ===relative=== //adj.// * 1. (of a //[[CL:Glossary:time]]//) representing an offset from an //[[CL:Glossary:absolute]]// //[[CL:Glossary:time]]// in the units appropriate to that time. For example, a //[[CL:Glossary:relative]]// //[[CL:Glossary:internal time]]// is the difference between two //[[CL:Glossary:absolute]]// //[[CL:Glossary:internal time|internal times]]//, and is measured in //[[CL:Glossary:internal time unit|internal time units]]//. * 2. (of a //[[CL:Glossary:pathname]]//) representing a position in a directory hierarchy by motion from a position other than the root, which might therefore vary. "The notation ''#P"../foo.text"'' denotes a relative pathname if the host file system is Unix." See //[[CL:Glossary:absolute]]//. ===repertoire=== //n.//, //ISO// * a //[[CL:Glossary:subtype]]// of **[[CL:Types:character]]**. \Seesection\CharRepertoires. ===report=== //n.// (of a //[[CL:Glossary:condition]]//) * to //[[CL:Glossary:call]]// the //[[CL:Glossary:function]]// **[[CL:Functions:print-object]]** on the //[[CL:Glossary:condition]]// in an //[[CL:Glossary:environment]]// where the //[[CL:Glossary:value]]// of **[[CL:Variables:star-print-escape-star|*print-escape*]]** is //[[CL:Glossary:false]]//. ===report message=== //n.// * the text that is output by a //[[CL:Glossary:condition reporter]]//. ===required parameter=== //n.// * a //[[CL:Glossary:parameter]]// for which a corresponding positional //[[CL:Glossary:argument]]// must be supplied when //[[CL:Glossary:call|calling]]// the //[[CL:Glossary:function]]//. ===rest list=== //n.// (of a //[[CL:Glossary:function]]// having a //[[CL:Glossary:rest parameter]]//) * the //[[CL:Glossary:list]]// to which the //[[CL:Glossary:rest parameter]]// is //[[CL:Glossary:bound]]// on some particular //[[CL:Glossary:call]]// to the //[[CL:Glossary:function]]//. ===rest parameter=== //n.// * a //[[CL:Glossary:parameter]]// which was introduced by ''&body''. ===restart=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:restart]]**. ===restart designator=== //n.// * a //[[CL:Glossary:designator]]// for a //[[CL:Glossary:restart]]//; that is, an //[[CL:Glossary:object]]// that denotes a //[[CL:Glossary:restart]]// and that is one of: a //[[CL:Glossary:non-nil]]// //[[CL:Glossary:symbol]]// (denoting the most recently established //[[CL:Glossary:active]]// //[[CL:Glossary:restart]]// whose //[[CL:Glossary:name]]// is that //[[CL:Glossary:symbol]]//), or a //[[CL:Glossary:restart]]// (denoting itself). ===restart function=== //n.// * a //[[CL:Glossary:function]]// that invokes a //[[CL:Glossary:restart]]//, as if by **[[CL:Functions:invoke-restart]]**. The primary purpose of a //[[CL:Glossary:restart function]]// is to provide an alternate interface. By convention, a //[[CL:Glossary:restart function]]// usually has the same name as the //[[CL:Glossary:restart]]// which it invokes. The below list shows a list of the //[[CL:Glossary:standardized]]// //[[CL:Glossary:restart function|restart functions]]//. * **[[CL:Functions:abort]]** * **[[CL:Functions:muffle-warning]]** * **[[CL:Functions:use-value]]** * **[[CL:Functions:continue]]** * **[[CL:Functions:store-value]]** ===return=== //v.t.// (of //[[CL:Glossary:value|values]]//) * 1. (from a //[[CL:Glossary:block]]//) to transfer control and //[[CL:Glossary:value|values]]// from the //[[CL:Glossary:block]]//; that is, to cause the //[[CL:Glossary:block]]// to //[[CL:Glossary:yield]]// the //[[CL:Glossary:value|values]]// immediately without doing any further evaluation of the //[[CL:Glossary:form|forms]]// in its body. * 2. (from a //[[CL:Glossary:form]]//) to //[[CL:Glossary:yield]]// the //[[CL:Glossary:value|values]]//. ===return value=== //n.//, //Trad.// * a //[[CL:Glossary:value|value₁]]// ===right-parenthesis=== //n.// * the //[[CL:Glossary:standard character]]// "'')''", that is variously called "right parenthesis" or "close parenthesis" \Seefigure\StdCharsThree. ===run time=== //n.// * 1. //[[CL:Glossary:load time]]// * 2. //[[CL:Glossary:execute|execution time]]// ===run-time compiler=== //n.// * refers to the **[[CL:Functions:compile]]** function or to //[[CL:Glossary:implicit compilation]]//, for which the compilation and run-time //[[CL:Glossary:environment|environments]]// are maintained in the same //[[CL:Glossary:Lisp image]]//. ===run-time definition=== //n.// * a definition in the //[[CL:Glossary:run-time environment]]//. ===run-time environment=== //n.// * the //[[CL:Glossary:environment]]// in which a program is //[[CL:Glossary:execute|executed]]//. =====S===== ===safe=== //adj.// * 1. (of //[[CL:Glossary:code]]//) processed in a //[[CL:Glossary:lexical environment]]// where the the highest **''safety''** level (''3'') was in effect. See **[[CL:Declarations:optimize]]**. * 2. (of a //[[CL:Glossary:call]]//) a //[[CL:Glossary:safe call]]//. ===safe call=== //n.// * a //[[CL:Glossary:call]]// in which the //[[CL:Glossary:call]]//, the //[[CL:Glossary:function]]// being //[[CL:Glossary:call|called]]//, and the point of //[[CL:Glossary:functional evaluation]]// are all //[[CL:Glossary:safe|safe₁]]// //[[CL:Glossary:code]]//. For more detailed information, \seesection\SafeAndUnsafeCalls. ===same=== //adj.// * 1. (of //[[CL:Glossary:object|objects]]// under a specified //[[CL:Glossary:predicate]]//) indistinguishable by that //[[CL:Glossary:predicate]]//. "The symbol ''car'', the string ''"car"'', and the string ''"CAR"'' are the same under **[[CL:Functions:string-equal]]**". * 2. (of //[[CL:Glossary:object|objects]]// if no predicate is implied by context) indistinguishable by **[[CL:Functions:eql]]**. Note that **[[CL:Functions:eq]]** might be capable of distinguishing some //[[CL:Glossary:number|numbers]]// and //[[CL:Glossary:character|characters]]// which **[[CL:Functions:eql]]** cannot distinguish, but the nature of such, if any, is //[[CL:Glossary:implementation-dependent]]//. Since **[[CL:Functions:eq]]** is used only rarely in this specification, **[[CL:Functions:eql]]** is the default predicate when none is mentioned explicitly. "The conses returned by two successive calls to **[[CL:Functions:cons]]** are never the same." * 3. (of //[[CL:Glossary:type|types]]//) having the same set of //[[CL:Glossary:element|elements]]//; that is, each //[[CL:Glossary:type]]// is a //[[CL:Glossary:subtype]]// of the others. "The types specified by ''([[CL:Types:integer]] 0 1)'', ''([[CL:Types:unsigned-byte]] 1)'', and **[[CL:Types:bit]]** are the same." ===satisfy the test=== //v.// (of an //[[CL:Glossary:object]]// being considered by a //[[CL:Glossary:sequence function]]//) * 1. (for a one //[[CL:Glossary:argument]]// test) to be in a state such that the //[[CL:Glossary:function]]// which is the //predicate// //[[CL:Glossary:argument]]// to the //[[CL:Glossary:sequence function]]// returns //[[CL:Glossary:true]]// when given a single //[[CL:Glossary:argument]]// that is the result of calling the //[[CL:Glossary:sequence function]]//'s //key// //[[CL:Glossary:argument]]// on the //[[CL:Glossary:object]]// being considered. \Seesection\SatisfyingTheOneArgTest. * 2. (for a two //[[CL:Glossary:argument]]// test) to be in a state such that the two-place //[[CL:Glossary:predicate]]// which is the //[[CL:Glossary:sequence function]]//'s //test// //[[CL:Glossary:argument]]// returns //[[CL:Glossary:true]]// when given a first //[[CL:Glossary:argument]]// that is the //[[CL:Glossary:object]]// being considered, and when given a second //[[CL:Glossary:argument]]// that is the result of calling the //[[CL:Glossary:sequence function]]//'s //key// //[[CL:Glossary:argument]]// on an //[[CL:Glossary:element]]// of the //[[CL:Glossary:sequence function]]//'s //sequence// //[[CL:Glossary:argument]]// which is being tested for equality; or to be in a state such that the //test-not// //[[CL:Glossary:function]]// returns //[[CL:Glossary:false]]// given the same //[[CL:Glossary:argument|arguments]]//. \Seesection\SatisfyingTheTwoArgTest. ===scope=== //n.// * the structural or textual region of code in which //[[CL:Glossary:reference|references]]// to an //[[CL:Glossary:object]]//, a //[[CL:Glossary:binding]]//, an //[[CL:Glossary:exit point]]//, a //[[CL:Glossary:tag]]//, or an //[[CL:Glossary:environment]]// (usually by //[[CL:Glossary:name]]//) can occur. ===script=== //n.//, //ISO// * one of possibly several sets that form an //[[CL:Glossary:exhaustive partition]]// of the type **[[CL:Types:character]]**. \Seesection\CharScripts. ===secondary value=== //n.// (of //[[CL:Glossary:value|values]]// resulting from the //[[CL:Glossary:evaluation]]// of a //[[CL:Glossary:form]]//) * the second //[[CL:Glossary:value]]//, if any, or else **[[CL:Constant Variables:nil]]** if there are fewer than two //[[CL:Glossary:value|values]]//. "The secondary value returned by **[[CL:Functions:truncate]]** is a remainder." ===section=== //n.// * a partitioning of output by a //[[CL:Glossary:conditional newline]]// on a //[[CL:Glossary:pretty printing stream]]//. \Seesection\DynamicControlofOutput. ===self-evaluating object=== //n.// * an //[[CL:Glossary:object]]// that is neither a //[[CL:Glossary:symbol]]// nor a //[[CL:Glossary:cons]]//. If a //[[CL:Glossary:self-evaluating object]]// is //[[CL:Glossary:evaluate|evaluated]]//, it //[[CL:Glossary:yield|yields]]// itself as its only //[[CL:Glossary:value]]//. "Strings are self-evaluating objects." ===semi-standard=== //adj.// (of a language feature) * not required to be implemented by any //[[CL:Glossary:conforming implementation]]//, but nevertheless recommended as the canonical approach in situations where an //[[CL:Glossary:implementation]]// does plan to support such a feature. The presence of //[[CL:Glossary:semi-standard]]// aspects in the language is intended to lessen portability problems and reduce the risk of gratuitous divergence among //[[CL:Glossary:implementation|implementations]]// that might stand in the way of future standardization. ===semicolon=== //n.// * the //[[CL:Glossary:standard character]]// that is called "semicolon" ('';''). \Seefigure\StdCharsThree. ===sequence=== //n.// * 1. an ordered collection of elements * 2. a //[[CL:Glossary:vector]]// or a //[[CL:Glossary:list]]//. ===sequence function=== //n.// * one of the //[[CL:Glossary:function|functions]]// in \figref\SequenceFunctions, or an //[[CL:Glossary:implementation-defined]]// //[[CL:Glossary:function]]// that operates on one or more //[[CL:Glossary:sequence|sequences]]//. and that is defined by the //[[CL:Glossary:implementation]]// to be a //[[CL:Glossary:sequence function]]//. ===sequential=== //adj.// //Trad.// (of //[[CL:Glossary:binding]]// or //[[CL:Glossary:assign|assignment]]//) * done in the style of **[[CL:Special Operators:setq]]**, **[[CL:Special Operators:let-star|let*]]**, or **[[CL:Macros:do-star|do*]]**; that is, interleaving the evaluation of the //[[CL:Glossary:form|forms]]// that produce //[[CL:Glossary:value|values]]// with the //[[CL:Glossary:assign|assignments]]// or //[[CL:Glossary:binding|bindings]]// of the //[[CL:Glossary:variable|variables]]// (or //[[CL:Glossary:place|places]]//). See //[[CL:Glossary:parallel]]//. ===sequentially=== //adv.// * in a //[[CL:Glossary:sequential]]// way. ===serious condition=== //n.// * a //[[CL:Glossary:condition]]// of //[[CL:Glossary:type]]// **[[CL:Types:serious-condition]]**, which represents a //[[CL:Glossary:situation]]// that is generally sufficiently severe that entry into the //[[CL:Glossary:debugger]]// should be expected if the //[[CL:Glossary:condition]]// is //[[CL:Glossary:signal|signaled]]// but not //[[CL:Glossary:handle|handled]]//. ===session=== //n.// * the conceptual aggregation of events in a //[[CL:Glossary:Lisp image]]// from the time it is started to the time it is terminated. ===set=== //v.t.// //Trad.// (any //[[CL:Glossary:variable]]// or a //[[CL:Glossary:symbol]]// that is the //[[CL:Glossary:name]]// of a //[[CL:Glossary:dynamic variable]]//) * to //[[CL:Glossary:assign]]// the //[[CL:Glossary:variable]]//. ===setf expander=== //n.// * a function used by **[[CL:Macros:setf]]** to compute the //[[CL:Glossary:setf expansion]]// of a //[[CL:Glossary:place]]//. \issue{SETF-METHOD-VS-SETF-METHOD:RENAME-OLD-TERMS} ===setf expansion=== //n.// * a set of five //[[CL:Glossary:expression|expressions₁]]// that, taken together, describe how to store into a //[[CL:Glossary:place]]// and which //[[CL:Glossary:subform|subforms]]// of the macro call associated with the //[[CL:Glossary:place]]// are evaluated. \Seesection\SetfExpansions. \issue{SETF-METHOD-VS-SETF-METHOD:RENAME-OLD-TERMS} ===setf function=== //n.// * a //[[CL:Glossary:function]]// whose //[[CL:Glossary:name]]// is ''([[CL:Macros:setf]] //[[CL:Glossary:symbol]]//)''. ===setf function name=== //n.// (of a //[[CL:Glossary:symbol]]// //S//) * the //[[CL:Glossary:list]]// ''(setf //S//)''. \issue{LISP-SYMBOL-REDEFINITION-AGAIN:MORE-FIXES} ===shadow=== //v.t.// * 1. to override the meaning of. "That binding of //X// shadows an outer one." * 2. to hide the presence of. "That **[[CL:Special Operators:macrolet]]** of //F// shadows the outer **[[CL:Special Operators:flet]]** of //F//." * 3. to replace. "That package shadows the symbol ''[[CL:Functions:car|cl:car]]'' with its own symbol ''car''." ===shadowing symbol=== //n.// (in a //[[CL:Glossary:package]]//) * an //[[CL:Glossary:element]]// of the //[[CL:Glossary:package]]//'s //[[CL:Glossary:shadowing symbols list]]//. ===shadowing symbols list=== //n.// (of a //[[CL:Glossary:package]]//) * a //[[CL:Glossary:list]]//, associated with the //[[CL:Glossary:package]]//, of //[[CL:Glossary:symbol|symbols]]// that are to be exempted from `symbol conflict errors' detected when packages are //[[CL:Glossary:use|used]]//. See **[[CL:Functions:package-shadowing-symbols]]**. ===shared slot=== //n.// (of a //[[CL:Glossary:class]]//) * a //[[CL:Glossary:slot]]// //[[CL:Glossary:accessible]]// in more than one //[[CL:Glossary:instance]]// of a //[[CL:Glossary:class]]//; specifically, such a //[[CL:Glossary:slot]]// is //[[CL:Glossary:accessible]]// in all //[[CL:Glossary:direct instance|direct instances]]// of the //[[CL:Glossary:class]]// and in those //[[CL:Glossary:indirect instance|indirect instances]]// whose //[[CL:Glossary:class]]// does not //[[CL:Glossary:shadow|shadow₁]]// the //[[CL:Glossary:slot]]//. ===sharpsign=== //n.// * the //[[CL:Glossary:standard character]]// that is variously called "number sign," "sharp," or "sharp sign" (''#''). \Seefigure\StdCharsThree. ===short float=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:short-float]]**. ===sign=== //n.// * one of the //[[CL:Glossary:standard character|standard characters]]// "''+''" or "''-''". ===signal=== //v.// * to announce, using a standard protocol, that a particular situation, represented by a //[[CL:Glossary:condition]]//, has been detected. \Seesection\ConditionSystemConcepts. ===signature=== //n.// (of a //[[CL:Glossary:method]]//) * a description of the //[[CL:Glossary:parameter|parameters]]// and //[[CL:Glossary:parameter specializer|parameter specializers]]// for the //[[CL:Glossary:method]]// which determines the //[[CL:Glossary:method]]//'s applicability for a given set of required //[[CL:Glossary:argument|arguments]]//, and which also describes the //[[CL:Glossary:argument]]// conventions for its other, non-required //[[CL:Glossary:argument|arguments]]//. ===similar=== //adj.// (of two //[[CL:Glossary:object|objects]]//) * defined to be equivalent under the //[[CL:Glossary:similarity]]// relationship. ===similarity=== //n.// * a two-place conceptual equivalence predicate, which is independent of the //[[CL:Glossary:Lisp image]]// so that two //[[CL:Glossary:object|objects]]// in different //[[CL:Glossary:Lisp image|Lisp images]]// can be understood to be equivalent under this predicate. \Seesection\LiteralsInCompiledFiles. ===simple=== //adj.// * 1. (of an //[[CL:Glossary:array]]//) being of //[[CL:Glossary:type]]// **[[CL:Types:simple-array]]**. * 2. (of a //[[CL:Glossary:character]]//) having no //[[CL:Glossary:implementation-defined]]// //[[CL:Glossary:attribute|attributes]]//, or else having //[[CL:Glossary:implementation-defined]]// //[[CL:Glossary:attribute|attributes]]// each of which has the //[[CL:Glossary:null]]// value for that //[[CL:Glossary:attribute]]//. ===simple array=== //n.// * an //[[CL:Glossary:array]]// of //[[CL:Glossary:type]]// **[[CL:Types:simple-array]]**. ===simple bit array=== //n.// * a //[[CL:Glossary:bit array]]// that is a //[[CL:Glossary:simple array]]//; that is, an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// ''([[CL:Types:simple-array]] [[CL:Types:bit]])''. ===simple bit vector=== //n.// * a //[[CL:Glossary:bit vector]]// of //[[CL:Glossary:type]]// **[[CL:Types:simple-bit-vector]]**. ===simple condition=== //n.// * a //[[CL:Glossary:condition]]// of //[[CL:Glossary:type]]// **[[CL:Types:simple-condition]]**. ===simple general vector=== //n.// * a //[[CL:Glossary:simple vector]]//. ===simple string=== //n.// * a //[[CL:Glossary:string]]// of //[[CL:Glossary:type]]// **[[CL:Types:simple-string]]**. ===simple vector=== //n.// * a //[[CL:Glossary:vector]]// of //[[CL:Glossary:type]]// **[[CL:Types:simple-vector]]**, sometimes called a "//[[CL:Glossary:simple general vector]]//." Not all //[[CL:Glossary:vector|vectors]]// that are //[[CL:Glossary:simple]]// are //[[CL:Glossary:simple vector|simple vectors]]// - only those that have //[[CL:Glossary:element type]]// **[[CL:Types:t]]**. ===single escape=== //n.//, //adj.// * 1. //n.// the //[[CL:Glossary:syntax type]]// of a //[[CL:Glossary:character]]// that indicates that the next //[[CL:Glossary:character]]// is to be treated as an //[[CL:Glossary:alphabetic|alphabetic₂]]// //[[CL:Glossary:character]]// with its //[[CL:Glossary:case]]// preserved. For details, \seesection\SingleEscapeChar. * 2. //adj.// (of a //[[CL:Glossary:character]]//) having the //[[CL:Glossary:single escape]]// //[[CL:Glossary:syntax type]]//. * 3. //n.// a //[[CL:Glossary:single escape|single escape₂]]// //[[CL:Glossary:character]]//. (In the //[[CL:Glossary:standard readtable]]//, //[[CL:Glossary:slash]]// is the only //[[CL:Glossary:single escape]]//.) ===single float=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:single-float]]**. ===single-quote=== //n.// * the //[[CL:Glossary:standard character]]// that is variously called "apostrophe," "acute accent," "quote," or "single quote" (''<nowiki>'</nowiki>''). \Seefigure\StdCharsThree. ===singleton=== //adj.// (of a //[[CL:Glossary:sequence]]//) * having only one //[[CL:Glossary:element]]//. "''([[CL:Functions:list]] 'hello)'' returns a singleton list." ===situation=== //n.// * the //[[CL:Glossary:evaluation]]// of a //[[CL:Glossary:form]]// in a specific //[[CL:Glossary:environment]]//. ===slash=== //n.// * the //[[CL:Glossary:standard character]]// that is variously called "solidus" or "slash" (''/''). \Seefigure\StdCharsThree. ===slot=== //n.// * a component of an //[[CL:Glossary:object]]// that can store a //[[CL:Glossary:value]]//. ===slot specifier=== //n.// * a representation of a //[[CL:Glossary:slot]]// that includes the //[[CL:Glossary:name]]// of the //[[CL:Glossary:slot]]// and zero or more //[[CL:Glossary:slot]]// options. A //[[CL:Glossary:slot]]// option pertains only to a single //[[CL:Glossary:slot]]//. ===source code=== //n.// * //[[CL:Glossary:code]]// representing //[[CL:Glossary:object|objects]]// suitable for //[[CL:Glossary:evaluation]]// (e.g. //[[CL:Glossary:object|objects]]// created by **[[CL:Functions:read]]**, by //[[CL:Glossary:macro expansion]]//, or by //[[CL:Glossary:compiler macro expansion]]//). \issue{DEFINE-COMPILER-MACRO:X3J13-NOV89} ===source file=== //n.// * a //[[CL:Glossary:file]]// which contains a textual representation of //[[CL:Glossary:source code]]//, that can be edited, //[[CL:Glossary:load|loaded]]//, or //[[CL:Glossary:compile|compiled]]//. ===space=== //n.// * the //[[CL:Glossary:standard character]]// ''" "'', notated for the //[[CL:Glossary:Lisp reader]]// as ''#\Space''. ===special form=== //n.// * a //[[CL:Glossary:list]]//, other than a //[[CL:Glossary:macro form]]//, which is a //[[CL:Glossary:form]]// with special syntax or special //[[CL:Glossary:evaluation]]// rules or both, possibly manipulating the //[[CL:Glossary:evaluation]]// //[[CL:Glossary:environment]]// or control flow or both. The first element of a //[[CL:Glossary:special form]]// is a //[[CL:Glossary:special operator]]//. ===special operator=== //n.// * one of a fixed set of //[[CL:Glossary:symbol|symbols]]//, enumerated in \figref\CLSpecialOps, that may appear in the //[[CL:Glossary:car]]// of a //[[CL:Glossary:form]]// in order to identify the //[[CL:Glossary:form]]// as a //[[CL:Glossary:special form]]//. ===special variable=== //n.//, //Trad.// * a //[[CL:Glossary:dynamic variable]]//. ===specialize=== //v.t.// (a //[[CL:Glossary:generic function]]//) * to define a //[[CL:Glossary:method]]// for the //[[CL:Glossary:generic function]]//, or in other words, to refine the behavior of the //[[CL:Glossary:generic function]]// by giving it a specific meaning for a particular set of //[[CL:Glossary:class|classes]]// or //[[CL:Glossary:argument|arguments]]//. ===specialized=== //adj.// * 1. (of a //[[CL:Glossary:generic function]]//) having //[[CL:Glossary:method|methods]]// which //[[CL:Glossary:specialize]]// the //[[CL:Glossary:generic function]]//. * 2. (of an //[[CL:Glossary:array]]//) having an //[[CL:Glossary:actual array element type]]// that is a //[[CL:Glossary:proper subtype]]// of the //[[CL:Glossary:type]]// **[[CL:Types:t]]**; \seesection\ArrayElements. "''([[CL:Functions:make-array]] 5 :element-type '[[CL:Types:bit]])'' makes an array of length five that is specialized for bits." ===specialized lambda list=== //n.// * an //[[CL:Glossary:extended lambda list]]// used in //[[CL:Glossary:form|forms]]// that //[[CL:Glossary:establish]]// //[[CL:Glossary:method]]// definitions, such as **[[CL:Macros:defmethod]]**. \Seesection\SpecializedLambdaLists. ===spreadable argument list designator=== //n.// * a //[[CL:Glossary:designator]]// for a //[[CL:Glossary:list]]// of //[[CL:Glossary:object|objects]]//; that is, an //[[CL:Glossary:object]]// that denotes a //[[CL:Glossary:list]]// and that is a //[[CL:Glossary:non-nil]]// //[[CL:Glossary:list]]// ''L1'' of length ''n'', whose last element is a //[[CL:Glossary:list]]// ''L2'' of length ''m'' (denoting a list ''L3'' of length ''m+n-1'' whose //[[CL:Glossary:element|elements]]// are ''L1_i'' for ''i < n-1'' followed by ''L2_j'' for ''j < m''). "The list (1 2 (3 4 5)) is a spreadable argument list designator for the list (1 2 3 4 5)." ===stack allocate=== //v.t.//, //Trad.// * to allocate in a non-permanent way, such as on a stack. Stack-allocation is an optimization technique used in some //[[CL:Glossary:implementation|implementations]]// for allocating certain kinds of //[[CL:Glossary:object|objects]]// that have //[[CL:Glossary:dynamic extent]]//. Such //[[CL:Glossary:object|objects]]// are allocated on the stack rather than in the heap so that their storage can be freed as part of unwinding the stack rather than taking up space in the heap until the next garbage collection. What //[[CL:Glossary:type|types]]// (if any) can have //[[CL:Glossary:dynamic extent]]// can vary from //[[CL:Glossary:implementation]]// to //[[CL:Glossary:implementation]]//. No //[[CL:Glossary:implementation]]// is ever required to perform stack-allocation. See **[[CL:Declarations:dynamic-extent]]**. ===stack-allocated=== //adj.//, //Trad.// * having been //[[CL:Glossary:stack allocate|stack allocated]]//. ===standard character=== //n.// * a //[[CL:Glossary:character]]// of //[[CL:Glossary:type]]// **[[CL:Types:standard-char]]**, which is one of a fixed set of 96 such //[[CL:Glossary:character|characters]]// required to be present in all //[[CL:Glossary:conforming implementation|conforming implementations]]//. \Seesection\StandardChars. ===standard class=== //n.// * a //[[CL:Glossary:class]]// that is a //[[CL:Glossary:generalized instance]]// of //[[CL:Glossary:class]]// **[[CL:Types:standard-class]]**. ===standard generic function=== * a //[[CL:Glossary:function]]// of //[[CL:Glossary:type]]// **[[CL:Types:standard-generic-function]]**. ===standard input=== //n.// * the //[[CL:Glossary:input]]// //[[CL:Glossary:stream]]// which is the //[[CL:Glossary:value]]// of the //[[CL:Glossary:dynamic variable]]// **[[CL:Variables:star-standard-input-star|*standard-input*]]**. ===standard method combination=== //n.// * the //[[CL:Glossary:method combination]]// named **''standard''**. ===standard object=== //n.// * an //[[CL:Glossary:object]]// that is a //[[CL:Glossary:generalized instance]]// of //[[CL:Glossary:class]]// **[[CL:Types:standard-object]]**. ===standard output=== //n.// * the //[[CL:Glossary:output]]// //[[CL:Glossary:stream]]// which is the //[[CL:Glossary:value]]// of the //[[CL:Glossary:dynamic variable]]// **[[CL:Variables:star-standard-output-star|*standard-output*]]**. ===standard pprint dispatch table=== //n.// * a //[[CL:Glossary:pprint dispatch table]]// that is //[[CL:Glossary:different]]// from the //[[CL:Glossary:initial pprint dispatch table]]//, that implements //[[CL:Glossary:pretty print|pretty printing]]// as described in this specification, and that, unlike other //[[CL:Glossary:pprint dispatch table|pprint dispatch tables]]//, must never be modified by any program. (Although the definite reference "the //[[CL:Glossary:standard pprint dispatch table]]//" is generally used within this document, it is actually //[[CL:Glossary:implementation-dependent]]// whether a single //[[CL:Glossary:object]]// fills the role of the //[[CL:Glossary:standard pprint dispatch table]]//, or whether there might be multiple such objects, any one of which could be used on any given occasion where "the //[[CL:Glossary:standard pprint dispatch table]]//" is called for. As such, this phrase should be seen as an indefinite reference in all cases except for anaphoric references.) \issue{KMP-COMMENTS-ON-SANDRA-COMMENTS:X3J13-MAR-92} ===standard readtable=== //n.// * a //[[CL:Glossary:readtable]]// that is //[[CL:Glossary:different]]// from the //[[CL:Glossary:initial readtable]]//, that implements the //[[CL:Glossary:expression]]// syntax defined in this specification, and that, unlike other //[[CL:Glossary:readtable|readtables]]//, must never be modified by any program. (Although the definite reference "the //[[CL:Glossary:standard readtable]]//" is generally used within this document, it is actually //[[CL:Glossary:implementation-dependent]]// whether a single //[[CL:Glossary:object]]// fills the role of the //[[CL:Glossary:standard readtable]]//, or whether there might be multiple such objects, any one of which could be used on any given occasion where "the //[[CL:Glossary:standard readtable]]//" is called for. As such, this phrase should be seen as an indefinite reference in all cases except for anaphoric references.) \issue{WITH-STANDARD-IO-SYNTAX-READTABLE:X3J13-MAR-91} ===standard syntax=== //n.// * the syntax represented by the //[[CL:Glossary:standard readtable]]// and used as a reference syntax throughout this document. \Seesection\TheStandardSyntax. ===standardized=== //adj.// (of a //[[CL:Glossary:name]]//, //[[CL:Glossary:object]]//, or definition) * having been defined by Common Lisp. "All standardized variables that are required to hold bidirectional streams have "''-io*''" in their name." ===startup environment=== //n.// * the //[[CL:Glossary:global environment]]// of the running //[[CL:Glossary:Lisp image]]// from which the //[[CL:Glossary:compiler]]// was invoked. ===step=== //v.t.//, //n.// * 1. //v.t.// (an iteration //[[CL:Glossary:variable]]//) to //[[CL:Glossary:assign]]// the //[[CL:Glossary:variable]]// a new //[[CL:Glossary:value]]// at the end of an iteration, in preparation for a new iteration. * 2. //n.// the //[[CL:Glossary:code]]// that identifies how the next value in an iteration is to be computed. * 3. //v.t.// (//[[CL:Glossary:code]]//) to specially execute the //[[CL:Glossary:code]]//, pausing at intervals to allow user confirmation or intervention, usually for debugging. ===stream=== //n.// * an //[[CL:Glossary:object]]// that can be used with an input or output function to identify an appropriate source or sink of //[[CL:Glossary:character|characters]]// or //[[CL:Glossary:byte|bytes]]// for that operation. ===stream associated with a file=== //n.// * a //[[CL:Glossary:file stream]]//, or a //[[CL:Glossary:synonym stream]]// the //[[CL:Glossary:target]]// of which is a //[[CL:Glossary:stream associated with a file]]//. Such a //[[CL:Glossary:stream]]// cannot be created with **[[CL:Functions:make-two-way-stream]]**, **[[CL:Functions:make-echo-stream]]**, **[[CL:Functions:make-broadcast-stream]]**, **[[CL:Functions:make-concatenated-stream]]**, **[[CL:Functions:make-string-input-stream]]**, or **[[CL:Functions:make-string-output-stream]]**. \issue{CLOSED-STREAM-FUNCTIONS:ALLOW-INQUIRY} \issue{PATHNAME-STREAM:FILES-OR-SYNONYM} ===stream designator=== //n.// * a //[[CL:Glossary:designator]]// for a //[[CL:Glossary:stream]]//; that is, an //[[CL:Glossary:object]]// that denotes a //[[CL:Glossary:stream]]// and that is one of: **[[CL:Constant Variables:t]]** (denoting the //[[CL:Glossary:value]]// of **[[CL:Variables:star-terminal-io-star|*terminal-io*]]**), **[[CL:Constant Variables:nil]]** (denoting the //[[CL:Glossary:value]]// of **[[CL:Variables:star-standard-input-star|*standard-input*]]** for //[[CL:Glossary:input]]// //[[CL:Glossary:stream designator|stream designators]]// or denoting the //[[CL:Glossary:value]]// of **[[CL:Variables:star-standard-output-star|*standard-output*]]** for //[[CL:Glossary:output]]// //[[CL:Glossary:stream designator|stream designators]]//), or a //[[CL:Glossary:stream]]// (denoting itself). ===stream element type=== //n.// (of a //[[CL:Glossary:stream]]//) * the //[[CL:Glossary:type]]// of data for which the //[[CL:Glossary:stream]]// is specialized. ===stream variable=== //n.// * a //[[CL:Glossary:variable]]// whose //[[CL:Glossary:value]]// must be a //[[CL:Glossary:stream]]//. ===stream variable designator=== //n.// * a //[[CL:Glossary:designator]]// for a //[[CL:Glossary:stream variable]]//; that is, a //[[CL:Glossary:symbol]]// that denotes a //[[CL:Glossary:stream variable]]// and that is one of: **[[CL:Constant Variables:t]]** (denoting **[[CL:Variables:star-terminal-io-star|*terminal-io*]]**), **[[CL:Constant Variables:nil]]** (denoting **[[CL:Variables:star-standard-input-star|*standard-input*]]** for //[[CL:Glossary:input]]// //[[CL:Glossary:stream variable designator|stream variable designators]]// or denoting **[[CL:Variables:star-standard-output-star|*standard-output*]]** for //[[CL:Glossary:output]]// //[[CL:Glossary:stream variable designator|stream variable designators]]//), or some other //[[CL:Glossary:symbol]]// (denoting itself). ===string=== //n.// * a specialized //[[CL:Glossary:vector]]// that is of //[[CL:Glossary:type]]// **[[CL:Types:string]]**, and whose elements are \oftypes{character}. ===string designator=== //n.// * a //[[CL:Glossary:designator]]// for a //[[CL:Glossary:string]]//; that is, an //[[CL:Glossary:object]]// that denotes a //[[CL:Glossary:string]]// and that is one of: a //[[CL:Glossary:character]]// (denoting a //[[CL:Glossary:singleton]]// //[[CL:Glossary:string]]// that has the //[[CL:Glossary:character]]// as its only //[[CL:Glossary:element]]//), a //[[CL:Glossary:symbol]]// (denoting the //[[CL:Glossary:string]]// that is its //[[CL:Glossary:name]]//), or a //[[CL:Glossary:string]]// (denoting itself).The intent is that this term be consistent with the behavior of **[[CL:Functions:string]]**; //[[CL:Glossary:implementation|implementations]]// that extend **[[CL:Functions:string]]** must extend the meaning of this term in a compatible way. \issue{STRING-COERCION:MAKE-CONSISTENT} ===string equal=== //adj.// * the //[[CL:Glossary:same]]// under **[[CL:Functions:string-equal]]**. ===string stream=== //n.// * a //[[CL:Glossary:stream]]// of //[[CL:Glossary:type]]// **[[CL:Types:string-stream]]**. ===structure=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:structure-object]]**. ===structure class=== //n.// * a //[[CL:Glossary:class]]// that is a //[[CL:Glossary:generalized instance]]// of //[[CL:Glossary:class]]// **[[CL:Types:structure-class]]**. ===structure name=== //n.// * a //[[CL:Glossary:name]]// defined with **[[CL:Macros:defstruct]]**. Usually, such a //[[CL:Glossary:type]]// is also a //[[CL:Glossary:structure class]]//, but there may be //[[CL:Glossary:implementation-dependent]]// situations in which this is not so, if the **'':type''** option to **[[CL:Macros:defstruct]]** is used. ===style warning=== //n.// * a //[[CL:Glossary:condition]]// of //[[CL:Glossary:type]]// **[[CL:Types:style-warning]]**. ===subclass=== //n.// * a //[[CL:Glossary:class]]// that //[[CL:Glossary:inherit|inherits]]// from another //[[CL:Glossary:class]]//, called a //[[CL:Glossary:superclass]]//. (No //[[CL:Glossary:class]]// is a //[[CL:Glossary:subclass]]// of itself.) ===subexpression=== //n.// (of an //[[CL:Glossary:expression]]//) * an //[[CL:Glossary:expression]]// that is contained within the //[[CL:Glossary:expression]]//. (In fact, the state of being a //[[CL:Glossary:subexpression]]// is not an attribute of the //[[CL:Glossary:subexpression]]//, but really an attribute of the containing //[[CL:Glossary:expression]]// since the //[[CL:Glossary:same]]// //[[CL:Glossary:object]]// can at once be a //[[CL:Glossary:subexpression]]// in one context, and not in another.) ===subform=== //n.// (of a //[[CL:Glossary:form]]//) * an //[[CL:Glossary:expression]]// that is a //[[CL:Glossary:subexpression]]// of the //[[CL:Glossary:form]]//, and which by virtue of its position in that //[[CL:Glossary:form]]// is also a //[[CL:Glossary:form]]//. "''(f x)'' and ''x'', but not ''exit'', are subforms of ''([[CL:Special Operators:return-from]] exit (f x))''." ===subrepertoire=== //n.// * a subset of a //[[CL:Glossary:repertoire]]//. ===subtype=== //n.// * a //[[CL:Glossary:type]]// whose membership is the same as or a proper subset of the membership of another //[[CL:Glossary:type]]//, called a //[[CL:Glossary:supertype]]//. (Every //[[CL:Glossary:type]]// is a //[[CL:Glossary:subtype]]// of itself.) ===superclass=== //n.// * a //[[CL:Glossary:class]]// from which another //[[CL:Glossary:class]]// (called a //[[CL:Glossary:subclass]]//) //[[CL:Glossary:inherit|inherits]]//. (No //[[CL:Glossary:class]]// is a //[[CL:Glossary:superclass]]// of itself.) See //[[CL:Glossary:subclass]]//. ===supertype=== //n.// * a //[[CL:Glossary:type]]// whose membership is the same as or a proper superset of the membership of another //[[CL:Glossary:type]]//, called a //[[CL:Glossary:subtype]]//. (Every //[[CL:Glossary:type]]// is a //[[CL:Glossary:supertype]]// of itself.) See //[[CL:Glossary:subtype]]//. ===supplied-p parameter=== //n.// * a //[[CL:Glossary:parameter]]// which recieves its //[[CL:Glossary:generalized boolean]]// value implicitly due to the presence or absence of an //[[CL:Glossary:argument]]// corresponding to another //[[CL:Glossary:parameter]]// (such as an //[[CL:Glossary:optional parameter]]// or a //[[CL:Glossary:rest parameter]]//). \Seesection\OrdinaryLambdaLists. ===symbol=== //n.// * an //[[CL:Glossary:object]]// of //[[CL:Glossary:type]]// **[[CL:Types:symbol]]**. ===symbol macro=== //n.// * a //[[CL:Glossary:symbol]]// that stands for another //[[CL:Glossary:form]]//. See //[[CL:Glossary:special operator]]// **[[CL:Special Operators:symbol-macrolet]]**. ===synonym stream=== //n.// * 1. a //[[CL:Glossary:stream]]// of //[[CL:Glossary:type]]// **[[CL:Types:synonym-stream]]**, which is consequently a //[[CL:Glossary:stream]]// that is an alias for another //[[CL:Glossary:stream]]//, which is the //[[CL:Glossary:value]]// of a //[[CL:Glossary:dynamic variable]]// whose //[[CL:Glossary:name]]// is the //[[CL:Glossary:synonym stream symbol]]// of the //[[CL:Glossary:synonym stream]]//. See **[[CL:Functions:make-synonym-stream]]**. * 2. (to a //[[CL:Glossary:stream]]//) a //[[CL:Glossary:synonym stream]]// which has the //[[CL:Glossary:stream]]// as the //[[CL:Glossary:value]]// of its //[[CL:Glossary:synonym stream symbol]]//. * 3. (to a //[[CL:Glossary:symbol]]//) a //[[CL:Glossary:synonym stream]]// which has the //[[CL:Glossary:symbol]]// as its //[[CL:Glossary:synonym stream symbol]]//. ===synonym stream symbol=== //n.// (of a //[[CL:Glossary:synonym stream]]//) * the //[[CL:Glossary:symbol]]// which names the //[[CL:Glossary:dynamic variable]]// which has as its //[[CL:Glossary:value]]// another //[[CL:Glossary:stream]]// for which the //[[CL:Glossary:synonym stream]]// is an alias. ===syntax type=== //n.// (of a //[[CL:Glossary:character]]//) * one of several classifications, enumerated in \figref\PossibleSyntaxTypes, that are used for dispatch during parsing by the //[[CL:Glossary:Lisp reader]]//. \Seesection\CharacterSyntaxTypes. ===system class=== //n.// * a //[[CL:Glossary:class]]// that may be of //[[CL:Glossary:type]]// **[[CL:Types:built-in-class]]** in a //[[CL:Glossary:conforming implementation]]// and hence cannot be inherited by //[[CL:Glossary:class|classes]]// defined by //[[CL:Glossary:conforming program|conforming programs]]//. ===system code=== //n.// * //[[CL:Glossary:code]]// supplied by the //[[CL:Glossary:implementation]]// to implement this specification (e.g. the definition of **[[CL:Functions:mapcar]]**) or generated automatically in support of this specification (e.g. during method combination); that is, //[[CL:Glossary:code]]// that is not //[[CL:Glossary:programmer code]]//. =====T===== ===t=== //n.// * 1. * a. the //[[CL:Glossary:boolean]]// representing true. See **[[CL:Constant Variables:t]]**. * b. the canonical //[[CL:Glossary:generalized boolean]]// representing true. (Although any //[[CL:Glossary:object]]// other than **[[CL:Constant Variables:nil]]** is considered //[[CL:Glossary:true]]// as a //[[CL:Glossary:generalized boolean]]//, **[[CL:Constant Variables:t]]** is generally used when there is no special reason to prefer one such //[[CL:Glossary:object]]// over another.) * 2. the //[[CL:Glossary:name]]// of the //[[CL:Glossary:type]]// to which all //[[CL:Glossary:object|objects]]// belong - the //[[CL:Glossary:supertype]]// of all //[[CL:Glossary:type|types]]// (including itself). See **[[CL:Types:t]]**. * 3. the //[[CL:Glossary:name]]// of the //[[CL:Glossary:superclass]]// of all //[[CL:Glossary:class|classes]]// except itself. See **[[CL:Types:t]]**. ===tag=== //n.// * 1. a //[[CL:Glossary:catch tag]]//. * 2. a //[[CL:Glossary:go tag]]//. \issue{TAILP-NIL:T} ===tail=== //n.// (of a //[[CL:Glossary:list]]//) * an //[[CL:Glossary:object]]// that is the //[[CL:Glossary:same]]// as either some //[[CL:Glossary:cons]]// which makes up that //[[CL:Glossary:list]]// or the //[[CL:Glossary:atom]]// (if any) which terminates the //[[CL:Glossary:list]]//. "The empty list is a tail of every proper list." ===target=== //n.// * 1. (of a //[[CL:Glossary:constructed stream]]//) a //[[CL:Glossary:constituent]]// of the //[[CL:Glossary:constructed stream]]//. "The target of a synonym stream is the value of its synonym stream symbol." * 2. (of a //[[CL:Glossary:displaced array]]//) the //[[CL:Glossary:array]]// to which the //[[CL:Glossary:displaced array]]// is displaced. (In the case of a chain of //[[CL:Glossary:constructed stream|constructed streams]]// or //[[CL:Glossary:displaced array|displaced arrays]]//, the unqualified term "//[[CL:Glossary:target]]//" always refers to the immediate //[[CL:Glossary:target]]// of the first item in the chain, not the immediate target of the last item.) ===terminal I/O=== //n.// * the //[[CL:Glossary:bidirectional]]// //[[CL:Glossary:stream]]// that is the //[[CL:Glossary:value]]// of the //[[CL:Glossary:variable]]// **[[CL:Variables:star-terminal-io-star|*terminal-io*]]**. ===terminating=== //n.// (of a //[[CL:Glossary:macro character]]//) * being such that, if it appears while parsing a token, it terminates that token. \Seesection\ReaderAlgorithm. ===tertiary value=== //n.// (of //[[CL:Glossary:value|values]]// resulting from the //[[CL:Glossary:evaluation]]// of a //[[CL:Glossary:form]]//) * the third //[[CL:Glossary:value]]//, if any, or else **[[CL:Constant Variables:nil]]** if there are fewer than three //[[CL:Glossary:value|values]]//. ===throw=== //v.// * to transfer control and //[[CL:Glossary:value|values]]// to a //[[CL:Glossary:catch]]//. See **[[CL:Special Operators:throw]]**. ===tilde=== //n.// * the //[[CL:Glossary:standard character]]// that is called "tilde" (''~''). \Seefigure\StdCharsThree. ===time=== //n.// * a representation of a point (//[[CL:Glossary:absolute]]// //[[CL:Glossary:time]]//) or an interval (//[[CL:Glossary:relative]]// //[[CL:Glossary:time]]//) on a time line. See //[[CL:Glossary:decoded time]]//, //[[CL:Glossary:internal time]]//, and //[[CL:Glossary:universal time]]//. ===time zone=== //n.// * a //[[CL:Glossary:rational]]// multiple of ''1/3600'' between ''-24'' (inclusive) and ''24'' (inclusive) that represents a time zone as a number of hours offset from Greenwich Mean Time. Time zone values increase with motion to the west, so Massachusetts, U.S.A. is in time zone ''5'', California, U.S.A. is time zone ''8'', and Moscow, Russia is time zone ''-3''. (When "daylight savings time" is separately represented as an //[[CL:Glossary:argument]]// or //[[CL:Glossary:return value]]//, the //[[CL:Glossary:time zone]]// that accompanies it does not depend on whether daylight savings time is in effect.) \issue{TIME-ZONE-NON-INTEGER:ALLOW} ===token=== //n.// * a textual representation for a //[[CL:Glossary:number]]// or a //[[CL:Glossary:symbol]]//. \Seesection\InterpOfTokens. ===top level form=== //n.// * a //[[CL:Glossary:form]]// which is processed specially by **[[CL:Functions:compile-file]]** for the purposes of enabling //[[CL:Glossary:compile time]]// //[[CL:Glossary:evaluation]]// of that //[[CL:Glossary:form]]//. //[[CL:Glossary:top level form|Top level forms]]// include those //[[CL:Glossary:form|forms]]// which are not //[[CL:Glossary:subform|subforms]]// of any other //[[CL:Glossary:form]]//, and certain other cases. \Seesection\TopLevelForms. ===trace output=== //n.// * the //[[CL:Glossary:output]]// //[[CL:Glossary:stream]]// which is the //[[CL:Glossary:value]]// of the //[[CL:Glossary:dynamic variable]]// **[[CL:Variables:star-trace-output-star|*trace-output*]]**. ===tree=== //n.// * 1. a binary //[[CL:Glossary:recursion|recursive]]// data structure made up of //[[CL:Glossary:cons|conses]]// and //[[CL:Glossary:atom|atoms]]//: the //[[CL:Glossary:cons|conses]]// are themselves also //[[CL:Glossary:tree|trees]]// (sometimes called "subtrees" or "branches"), and the //[[CL:Glossary:atom|atoms]]// are terminal nodes (sometimes called //[[CL:Glossary:leaf|leaves]]//). Typically, the //[[CL:Glossary:leaf|leaves]]// represent data while the branches establish some relationship among that data. * 2. in general, any //[[CL:Glossary:recursion|recursive]]// data structure that has some notion of "branches" and //[[CL:Glossary:leaf|leaves]]//. ===tree structure=== //n.// (of a //[[CL:Glossary:tree|tree₁]]//) * the set of //[[CL:Glossary:cons|conses]]// that make up the //[[CL:Glossary:tree]]//. Note that while the //[[CL:Glossary:car|car_1b]]// component of each such //[[CL:Glossary:cons]]// is part of the //[[CL:Glossary:tree structure]]//, the //[[CL:Glossary:object|objects]]// that are the //[[CL:Glossary:car|cars₂]]// of each //[[CL:Glossary:cons]]// in the //[[CL:Glossary:tree]]// are not themselves part of its //[[CL:Glossary:tree structure]]// unless they are also //[[CL:Glossary:cons|conses]]//. ===true=== //n.// * any //[[CL:Glossary:object]]// that is not //[[CL:Glossary:false]]// and that is used to represent the success of a //[[CL:Glossary:predicate]]// test. See //[[CL:Glossary:t|t₁]]//. ===truename=== //n.// * 1. the canonical //[[CL:Glossary:filename]]// of a //[[CL:Glossary:file]]// in the //[[CL:Glossary:file system]]//. \Seesection\Truenames. * 2. a //[[CL:Glossary:pathname]]// representing a //[[CL:Glossary:truename|truename₁]]//. ===two-way stream=== //n.// * a //[[CL:Glossary:stream]]// of //[[CL:Glossary:type]]// **[[CL:Types:two-way-stream]]**, which is a //[[CL:Glossary:bidirectional]]// //[[CL:Glossary:composite stream]]// that receives its input from an associated //[[CL:Glossary:input]]// //[[CL:Glossary:stream]]// and sends its output to an associated //[[CL:Glossary:output]]// //[[CL:Glossary:stream]]//. ===type=== //n.// * 1. a set of //[[CL:Glossary:object|objects]]//, usually with common structure, behavior, or purpose. (Note that the expression "//X// is of type //S_a//" naturally implies that "//X// is of type //S_b//" if //S_a// is a //[[CL:Glossary:subtype]]// of//S_b//.) * 2. (immediately following the name of a //[[CL:Glossary:type]]//) a //[[CL:Glossary:subtype]]// of that //[[CL:Glossary:type]]//. "The type **[[CL:Types:vector]]** is an array type." ===type declaration=== //n.// * a //[[CL:Glossary:declaration]]// that asserts that every reference to a specified //[[CL:Glossary:binding]]// within the scope of the //[[CL:Glossary:declaration]]// results in some //[[CL:Glossary:object]]// of the specified //[[CL:Glossary:type]]//. ===type equivalent=== //adj.// (of two //[[CL:Glossary:type|types]]// ''X'' and ''Y'') * having the same //[[CL:Glossary:element|elements]]//; that is, ''X'' is a //[[CL:Glossary:subtype]]// of ''Y'' and ''Y'' is a //[[CL:Glossary:subtype]]// of ''X''. ===type expand=== //v.// * to fully expand a //[[CL:Glossary:type specifier]]//, removing any references to //[[CL:Glossary:derived type|derived types]]//. (Common Lisp provides no program interface to cause this to occur, but the semantics of Common Lisp are such that every //[[CL:Glossary:implementation]]// must be able to do this internally, and some situations involving //[[CL:Glossary:type specifier|type specifiers]]// are most easily described in terms of a fully expanded //[[CL:Glossary:type specifier]]//.) ===type specifier=== //n.// * an //[[CL:Glossary:expression]]// that denotes a //[[CL:Glossary:type]]//. "The symbol **[[CL:Types:random-state]]**, the list ''([[CL:Types:integer]] 3 5)'', the list ''([[CL:Types:and]] [[CL:Types:list]] ([[CL:Types:not]] [[CL:Types:null]]))'', and the class named **[[CL:Types:standard-class]]** are type specifiers." =====U===== ===unbound=== //adj.// * not having an associated denotation in a //[[CL:Glossary:binding]]//. See //[[CL:Glossary:bound]]//. ===unbound variable=== //n.// * a //[[CL:Glossary:name]]// that is syntactically plausible as the name of a //[[CL:Glossary:variable]]// but which is not //[[CL:Glossary:bound]]// in the //[[CL:Glossary:variable]]// //[[CL:Glossary:name|namespace]]//. ===undefined function=== //n.// * a //[[CL:Glossary:name]]// that is syntactically plausible as the name of a //[[CL:Glossary:function]]// but which is not //[[CL:Glossary:bound]]// in the //[[CL:Glossary:function]]// //[[CL:Glossary:name|namespace]]//. ===unintern=== //v.t.// (a //[[CL:Glossary:symbol]]// in a //[[CL:Glossary:package]]//) * to make the //[[CL:Glossary:symbol]]// not be //[[CL:Glossary:present]]// in that //[[CL:Glossary:package]]//. (The //[[CL:Glossary:symbol]]// might continue to be //[[CL:Glossary:accessible]]// by inheritance.) ===uninterned=== //adj.// (of a //[[CL:Glossary:symbol]]//) * not //[[CL:Glossary:accessible]]// in any //[[CL:Glossary:package]]//; i.e. not //[[CL:Glossary:interned|interned₁]]//. ===universal time=== //n.// * //[[CL:Glossary:time]]//, represented as a non-negative //[[CL:Glossary:integer]]// number of seconds. //[[CL:Glossary:Absolute]]// //[[CL:Glossary:universal time]]// is measured as an offset from the beginning of the year 1900 (ignoring //[[CL:Glossary:leap seconds]]//). \Seesection\UniversalTime. ===unqualified method=== //n.// * a //[[CL:Glossary:method]]// with no //[[CL:Glossary:qualifier|qualifiers]]//. ===unregistered package=== //n.// * a //[[CL:Glossary:package]]// //[[CL:Glossary:object]]// that is not present in the //[[CL:Glossary:package registry]]//. An //[[CL:Glossary:unregistered package]]// has no //[[CL:Glossary:name]]//; i.e. its //[[CL:Glossary:name]]// is **[[CL:Constant Variables:nil]]**. See **[[CL:Functions:delete-package]]**. ===unsafe=== //adj.// (of //[[CL:Glossary:code]]//) * not //[[CL:Glossary:safe]]//. (Note that, unless explicitly specified otherwise, if a particular kind of error checking is guaranteed only in a //[[CL:Glossary:safe]]// context, the same checking might or might not occur in that context if it were //[[CL:Glossary:unsafe]]//; describing a context as //[[CL:Glossary:unsafe]]// means that certain kinds of error checking are not reliably enabled but does not guarantee that error checking is definitely disabled.) ===unsafe call=== //n.// * a //[[CL:Glossary:call]]// that is not a //[[CL:Glossary:safe call]]//. For more detailed information, \seesection\SafeAndUnsafeCalls. ===upgrade=== //v.t.// (a declared //[[CL:Glossary:type]]// to an actual //[[CL:Glossary:type]]//) * 1. (when creating an //[[CL:Glossary:array]]//) to substitute an //[[CL:Glossary:actual array element type]]// for an //[[CL:Glossary:expressed array element type]]// when choosing an appropriately //[[CL:Glossary:specialized]]// //[[CL:Glossary:array]]// representation. See **[[CL:Functions:upgraded-array-element-type]]**. * 2. (when creating a //[[CL:Glossary:complex]]//) to substitute an //[[CL:Glossary:actual complex part type]]// for an //[[CL:Glossary:expressed complex part type]]// when choosing an appropriately //[[CL:Glossary:specialized]]// //[[CL:Glossary:complex]]// representation. See **[[CL:Functions:upgraded-complex-part-type]]**. ===upgraded array element type=== //n.// (of a //[[CL:Glossary:type]]//) * a //[[CL:Glossary:type]]// that is a //[[CL:Glossary:supertype]]// of the //[[CL:Glossary:type]]// and that is used instead of the //[[CL:Glossary:type]]// whenever the //[[CL:Glossary:type]]// is used as an //[[CL:Glossary:array element type]]// for object creation or type discrimination. \Seesection\ArrayUpgrading. ===upgraded complex part type=== //n.// (of a //[[CL:Glossary:type]]//) * a //[[CL:Glossary:type]]// that is a //[[CL:Glossary:supertype]]// of the //[[CL:Glossary:type]]// and that is used instead of the //[[CL:Glossary:type]]// whenever the //[[CL:Glossary:type]]// is used as a //[[CL:Glossary:complex part type]]// for object creation or type discrimination. See **[[CL:Functions:upgraded-complex-part-type]]**. ===uppercase=== //adj.// (of a //[[CL:Glossary:character]]//) * being among //[[CL:Glossary:standard character|standard characters]]// corresponding to the capital letters ''A'' through ''Z'', or being some other //[[CL:Glossary:implementation-defined]]// //[[CL:Glossary:character]]// that is defined by the //[[CL:Glossary:implementation]]// to be //[[CL:Glossary:uppercase]]//. \Seesection\CharactersWithCase. ===use=== //v.t.// (a //[[CL:Glossary:package]]// //P₁//) * to //[[CL:Glossary:inherit]]// the //[[CL:Glossary:external symbol|external symbols]]// of //P₁//. (If a package //P₂// uses //P₁//, the //[[CL:Glossary:external symbol|external symbols]]// of //P₁// become //[[CL:Glossary:internal symbol|internal symbols]]// of //P₂// unless they are explicitly //[[CL:Glossary:exported]]//.) "The package **''cl-user''** uses the package **''cl''**." ===use list=== //n.// (of a //[[CL:Glossary:package]]//) * a (possibly empty) //[[CL:Glossary:list]]// associated with each //[[CL:Glossary:package]]// which determines what other //[[CL:Glossary:package|packages]]// are currently being //[[CL:Glossary:use|used]]// by that //[[CL:Glossary:package]]//. ===user=== //n.// * an active entity, typically a human, that invokes or interacts with a //[[CL:Glossary:program]]// at run time, but that is not necessarily a //[[CL:Glossary:programmer]]//. =====V===== ===valid array dimension=== //n.// * a //[[CL:Glossary:fixnum]]// suitable for use as an //[[CL:Glossary:array]]// //[[CL:Glossary:dimension]]//. Such a //[[CL:Glossary:fixnum]]// must be greater than or equal to zero, and less than the //[[CL:Glossary:value]]// of **[[CL:Constant Variables:array-dimension-limit]]**. When multiple //[[CL:Glossary:array]]// //[[CL:Glossary:dimension|dimensions]]// are to be used together to specify a multi-dimensional //[[CL:Glossary:array]]//, there is also an implied constraint that the product of all of the //[[CL:Glossary:dimension|dimensions]]// be less than the //[[CL:Glossary:value]]// of **[[CL:Constant Variables:array-total-size-limit]]**. \issue{ARRAY-DIMENSION-LIMIT-IMPLICATIONS:ALL-FIXNUM} ===valid array index=== //n.// (of an //[[CL:Glossary:array]]//) * a //[[CL:Glossary:fixnum]]// suitable for use as one of possibly several indices needed to name an //[[CL:Glossary:element]]// of the //[[CL:Glossary:array]]// according to a multi-dimensional Cartesian coordinate system. Such a //[[CL:Glossary:fixnum]]// must be greater than or equal to zero, and must be less than the corresponding //[[CL:Glossary:dimension|dimension₁]]// of the //[[CL:Glossary:array]]//. (Unless otherwise explicitly specified, the phrase "a //[[CL:Glossary:list]]// of //[[CL:Glossary:valid array index|valid array indices]]//" further implies that the //[[CL:Glossary:length]]// of the //[[CL:Glossary:list]]// must be the same as the //[[CL:Glossary:rank]]// of the //[[CL:Glossary:array]]//.) "For a ''2'' by ''3'' array, valid array indices for the first dimension are ''0'' and ''1'', and valid array indices for the second dimension are ''0'', ''1'' and ''2''." \issue{ARRAY-DIMENSION-LIMIT-IMPLICATIONS:ALL-FIXNUM} ===valid array row-major index=== //n.// (of an //[[CL:Glossary:array]]//, which might have any number of //[[CL:Glossary:dimension|dimensions₂]]//) * a single //[[CL:Glossary:fixnum]]// suitable for use in naming any //[[CL:Glossary:element]]// of the //[[CL:Glossary:array]]//, by viewing the array's storage as a linear series of //[[CL:Glossary:element|elements]]// in row-major order. Such a //[[CL:Glossary:fixnum]]// must be greater than or equal to zero, and less than the //[[CL:Glossary:array total size]]// of the //[[CL:Glossary:array]]//. \issue{ARRAY-DIMENSION-LIMIT-IMPLICATIONS:ALL-FIXNUM} ===valid fill pointer=== //n.// (of an //[[CL:Glossary:array]]//) * a //[[CL:Glossary:fixnum]]// suitable for use as a //[[CL:Glossary:fill pointer]]// for the //[[CL:Glossary:array]]//. Such a //[[CL:Glossary:fixnum]]// must be greater than or equal to zero, and less than or equal to the //[[CL:Glossary:array total size]]// of the //[[CL:Glossary:array]]//. \issue{ARRAY-DIMENSION-LIMIT-IMPLICATIONS:ALL-FIXNUM} ===valid logical pathname host=== //n.// * a //[[CL:Glossary:string]]// that has been defined as the name of a //[[CL:Glossary:logical host]]//. See **[[CL:Functions:load-logical-pathname-translations]]**. \issue{PATHNAME-UNSPECIFIC-COMPONENT:NEW-TOKEN} ===valid pathname device=== //n.// * a //[[CL:Glossary:string]]//, **[[CL:Constant Variables:nil]]**, **'':unspecific''**, or some other //[[CL:Glossary:object]]// defined by the //[[CL:Glossary:implementation]]// to be a //[[CL:Glossary:valid pathname device]]//. ===valid pathname directory=== //n.// * a //[[CL:Glossary:string]]//, a //[[CL:Glossary:list]]// of //[[CL:Glossary:string|strings]]//, **[[CL:Constant Variables:nil]]**, **'':wild''**, **'':unspecific''**, or some other //[[CL:Glossary:object]]// defined by the //[[CL:Glossary:implementation]]// to be a valid directory component. \Seeref\PathnameDirectoryComponent. \issue{PATHNAME-SUBDIRECTORY-LIST:NEW-REPRESENTATION} ===valid pathname host=== //n.// * a //[[CL:Glossary:valid physical pathname host]]// or a //[[CL:Glossary:valid logical pathname host]]//. ===valid pathname name=== //n.// * a //[[CL:Glossary:string]]//, **[[CL:Constant Variables:nil]]**, **'':wild''**, **'':unspecific''**, or some other //[[CL:Glossary:object]]// defined by the //[[CL:Glossary:implementation]]// to be a //[[CL:Glossary:valid pathname name]]//. ===valid pathname type=== //n.// * a //[[CL:Glossary:string]]//, **[[CL:Constant Variables:nil]]**, **'':wild''**, **'':unspecific''**. ===valid pathname version=== //n.// * a non-negative //[[CL:Glossary:integer]]//, or one of **'':wild''**, **'':newest''**, **'':unspecific''**, or **[[CL:Constant Variables:nil]]**. The symbols **'':oldest''**, **'':previous''**, and **'':installed''** are //[[CL:Glossary:semi-standard]]// special version symbols. ===valid physical pathname host=== //n.// * any of a //[[CL:Glossary:string]]//, a //[[CL:Glossary:list]]// of //[[CL:Glossary:string|strings]]//, or the symbol **'':unspecific''**, that is recognized by the implementation as the name of a host. ===valid sequence index=== //n.// (of a //[[CL:Glossary:sequence]]//) * an //[[CL:Glossary:integer]]// suitable for use to name an //[[CL:Glossary:element]]// of the //[[CL:Glossary:sequence]]//. Such an //[[CL:Glossary:integer]]// must be greater than or equal to zero, and must be less than the //[[CL:Glossary:length]]// of the //[[CL:Glossary:sequence]]//. (If the //[[CL:Glossary:sequence]]// is an //[[CL:Glossary:array]]//, the //[[CL:Glossary:valid sequence index]]// is further constrained to be a //[[CL:Glossary:fixnum]]//.) \issue{ARRAY-DIMENSION-LIMIT-IMPLICATIONS:ALL-FIXNUM} ===value=== //n.// * 1. a. one of possibly several //[[CL:Glossary:object|objects]]// that are the result of an //[[CL:Glossary:evaluation]]//. b. (in a situation where exactly one value is expected from the //[[CL:Glossary:evaluation]]// of a //[[CL:Glossary:form]]//) the //[[CL:Glossary:primary value]]// returned by the //[[CL:Glossary:form]]//. c. (of //[[CL:Glossary:form|forms]]// in an //[[CL:Glossary:implicit progn]]//) one of possibly several //[[CL:Glossary:object|objects]]// that result from the //[[CL:Glossary:evaluation]]// of the last //[[CL:Glossary:form]]//, or **[[CL:Constant Variables:nil]]** if there are no //[[CL:Glossary:form|forms]]//. * 2. an //[[CL:Glossary:object]]// associated with a //[[CL:Glossary:name]]// in a //[[CL:Glossary:binding]]//. * 3. (of a //[[CL:Glossary:symbol]]//) the //[[CL:Glossary:value]]// of the //[[CL:Glossary:dynamic variable]]// named by that symbol. * 4. an //[[CL:Glossary:object]]// associated with a //[[CL:Glossary:key]]// in an //[[CL:Glossary:association list]]//, a //[[CL:Glossary:property list]]//, or a //[[CL:Glossary:hash table]]//. ===value cell=== //n.// //Trad.// (of a //[[CL:Glossary:symbol]]//) * the //[[CL:Glossary:place]]// which holds the //[[CL:Glossary:value]]//, if any, of the //[[CL:Glossary:dynamic variable]]// named by that //[[CL:Glossary:symbol]]//, and which is //[[CL:Glossary:access|accessed]]// by **[[CL:Functions:symbol-value]]**. See //[[CL:Glossary:cell]]//. ===variable=== //n.// * a //[[CL:Glossary:binding]]// in the "variable" //[[CL:Glossary:name|namespace]]//. \Seesection\SymbolsAsForms. ===vector=== //n.// * a one-dimensional //[[CL:Glossary:array]]//. ===vertical-bar=== //n.// * the //[[CL:Glossary:standard character]]// that is called "vertical bar" (''|''). \Seefigure\StdCharsThree. =====W===== ===whitespace=== //n.// * 1. one or more //[[CL:Glossary:character|characters]]// that are either the //[[CL:Glossary:graphic]]// //[[CL:Glossary:character]]// ''#\Space'' or else //[[CL:Glossary:non-graphic]]// characters such as ''#\Newline'' that only move the print position. * 2. * a. //n.// the //[[CL:Glossary:syntax type]]// of a //[[CL:Glossary:character]]// that is a //[[CL:Glossary:token]]// separator. For details, \seesection\WhitespaceChars. * b. //adj.// (of a //[[CL:Glossary:character]]//) having the //[[CL:Glossary:whitespace|whitespace_2a]]// //[[CL:Glossary:syntax type|syntax type₂]]//. * c. //n.// a //[[CL:Glossary:whitespace|whitespace_2b]]// //[[CL:Glossary:character]]//. ===wild=== //adj.// * 1. (of a //[[CL:Glossary:name|namestring]]//) using an //[[CL:Glossary:implementation-defined]]// syntax for naming files, which might "match" any of possibly several possible //[[CL:Glossary:filename|filenames]]//, and which can therefore be used to refer to the aggregate of the //[[CL:Glossary:file|files]]// named by those //[[CL:Glossary:filename|filenames]]//. * 2. (of a //[[CL:Glossary:pathname]]//) a structured representation of a name which might "match" any of possibly several //[[CL:Glossary:pathname|pathnames]]//, and which can therefore be used to refer to the aggregate of the //[[CL:Glossary:file|files]]// named by those //[[CL:Glossary:pathname|pathnames]]//. The set of //[[CL:Glossary:wild]]// //[[CL:Glossary:pathname|pathnames]]// includes, but is not restricted to, //[[CL:Glossary:pathname|pathnames]]// which have a component which is **'':wild''**, or which have a directory component which contains **'':wild''** or **'':wild-inferors''**. See **[[CL:Functions:wild-pathname-p]]**. ===write=== //v.t.// * 1. (a //[[CL:Glossary:binding]]// or //[[CL:Glossary:slot]]// or component) to change the //[[CL:Glossary:value]]// of the //[[CL:Glossary:binding]]// or //[[CL:Glossary:slot]]//. * 2. (an //[[CL:Glossary:object]]// to a //[[CL:Glossary:stream]]//) to output a representation of the //[[CL:Glossary:object]]// to the //[[CL:Glossary:stream]]//. \issue{IGNORE-USE-TERMINOLOGY:VALUE-ONLY} ===writer=== //n.// * a //[[CL:Glossary:function]]// that //[[CL:Glossary:write|writes₁]]// a //[[CL:Glossary:variable]]// or //[[CL:Glossary:slot]]//. =====Y===== ===yield=== //v.t.// (//[[CL:Glossary:value|values]]//) * to produce the //[[CL:Glossary:value|values]]// as the result of //[[CL:Glossary:evaluation]]//. "The form ''([[CL:Functions:math-add|+]] 2 3)'' yields ''5''."