Upload
buianh
View
245
Download
1
Embed Size (px)
Citation preview
Common Lisp Quick Reference
(Fuasinh a)(
Fuacosh a)(
Fuatanh a)
⊲ asinh a, acosh a, or atanh a, respectively.
(Fucis a) ⊲ Return ei a = cos a+ i sina.
(Fuconjugate a) ⊲ Return complex conjugate of a.
(Fumax num+)(
Fumin num+)
⊲ Greatest or least, respectively, of nums.
(
{ Furound
Fufround}
{ Fufloor
Fuffloor}
{ Fuceiling
Fufceiling}
{ Futruncate
Fuftruncate}
n [d 1 ])
⊲ Return as integer or float, respectively, n/d rounded, orrounded towards −∞, +∞, or 0, respectively; and
2remain-
der.
(
{ FumodFurem
}n d)
⊲ Same asFufloor or
Futruncate, respectively, but return re-
mainder only.
(Furandom limit [state var*random-state* ])
⊲ Return non-negative random number less than limit , andof the same type.
(Fumake-random-state
[{state NIL T}NIL
])
⊲ Copy of random-state object state or of the current ran-dom state; or a randomly initialized fresh random state.
var*random-state* ⊲ Current random state.
(Fufloat-sign num-a [num-b 1 ]) ⊲ num-b with num-a’s sign.
(Fusignum n)
⊲ Number of magnitude 1 representing sign or phase of n .
(Funumerator rational)(
Fudenominator rational)
⊲ Numerator or denominator, respectively, of rational ’scanonical form.
(Furealpart number)(
Fuimagpart number)
⊲ Real part or imaginary part, respectively, of number .
(Fucomplex real [imag 0 ]) ⊲ Make a complex number.
(Fuphase number) ⊲ Angle of number ’s polar representation.
(Fuabs n) ⊲ Return |n|.
(Furational real)(
Furationalize real)
⊲ Convert real to rational. Assume complete/limited accu-racy for real .
(Fufloat real [prototype 0.0F0 ])
⊲ Convert real into float with type of prototype .
1.3 Logic Functions
Negative integers are used in two’s complement representation.
(Fuboole operation int-a int-b)
⊲ Return value of bitwise logical operation . operations are
coboole-1 ⊲ int-a.coboole-2 ⊲ int-b.coboole-c1 ⊲ ¬int-a.coboole-c2 ⊲ ¬int-b.coboole-set ⊲ All bits set.coboole-clr ⊲ All bits zero.
4
Quick Reference
clCommon
lispBert Burgemeister
Common Lisp Quick Reference
Contents
1 Numbers 3
1.1 Predicates . . . . 31.2 Numeric Functns . 31.3 Logic Functions . 41.4 Integer Functions . 51.5 Implementation-
Dependent . . . . 6
2 Characters 6
3 Strings 7
4 Conses 8
4.1 Predicates . . . . 84.2 Lists . . . . . . 84.3 Association Lists . 94.4 Trees . . . . . . 104.5 Sets . . . . . . 10
5 Arrays 10
5.1 Predicates . . . . 105.2 Array Functions . 105.3 Vector Functions . 11
6 Sequences 12
6.1 Seq. Predicates . . 126.2 Seq. Functions . . 12
7 Hash Tables 14
8 Structures 15
9 Control Structure 15
9.1 Predicates . . . . 159.2 Variables . . . . 169.3 Functions . . . . 169.4 Macros . . . . . 18
9.5 Control Flow . . . 199.6 Iteration . . . . 209.7 Loop Facility . . . 21
10 CLOS 23
10.1 Classes . . . . . 2310.2 Generic Functns . 2510.3 Method Combi-
nation Types . . . 26
11 Conditions and Errors 27
12 Types and Classes 29
13 Input/Output 31
13.1 Predicates . . . . 3113.2 Reader . . . . . 3113.3 Character Syntax . 3313.4 Printer . . . . . 3413.5 Format . . . . . 3613.6 Streams . . . . . 3813.7 Paths and Files . . 40
14 Packages and Symbols 41
14.1 Predicates . . . . 4114.2 Packages . . . . 4114.3 Symbols . . . . . 4314.4 Std Packages . . 43
15 Compiler 43
15.1 Predicates . . . . 4315.2 Compilation . . . 4315.3 REPL & Debug . 4515.4 Declarations . . . 46
16 External Environment 46
Typographic Conventionsname;
Funame;
Mname;
sOname;
gFname;
var*name*; coname
⊲ Symbol defined in Common Lisp; esp. function, macro,special operator, generic function, variable, constant.
them ⊲ Placeholder for actual code.
me ⊲ Literal text.
[foo bar ] ⊲ Either one foo or nothing; defaults to bar.
foo∗; {foo}∗ ⊲ Zero or more foos.
foo+; {foo}+ ⊲ One or more foos.
foos ⊲ English plural denotes a list argument.
{foo bar baz};
foo
bar
baz
⊲ Either foo, or bar , or baz .
∣∣∣∣∣∣
foo
bar
baz
⊲ Anything from none to each of foo, bar , and baz .
foo ⊲ Argument foo is not evaluated.
bar ⊲ Argument bar is possibly modified.
fooP∗ ⊲ foo∗ is evaluated as in
sOprogn; see p. 19.
foo;2bar ;
n
baz ⊲ Primary, secondary, and nth return value.
T; NIL ⊲ t, or truth in general; and nil or ().
2
Common Lisp Quick Reference
1 Numbers
1.1 Predicates
(Fu= number+)(
Fu/= number+)
⊲ T if all numbers, or none, respectively, are equal in value.
(Fu> number+)(
Fu>= number+)(Fu< number+)(
Fu<= number+)
⊲ Return T if numbers are monotonically decreasing,monotonically non-increasing, monotonically increasing, ormonotonically non-decreasing, respectively.
(Fuminusp a)(
Fuzerop a)(
Fuplusp a)
⊲ T if a < 0, a = 0, or a > 0, respectively.
(Fuevenp integer)(
Fuoddp integer)
⊲ T if integer is even or odd, respectively.
(Funumberp foo)(
Furealp foo)(
Furationalp foo)(
Fufloatp foo)(
Fuintegerp foo)(
Fucomplexp foo)(
Furandom-state-p foo)
⊲ T if foo is of indicated type.
1.2 Numeric Functions
(Fu+ a 0
∗)(Fu* a 1
∗)⊲ Return
∑a or
∏a, respectively.
(Fu– a b∗)(Fu/ a b∗)
⊲ Return a−∑
b or a/∏
b, respectively. Without any bs,return −a or 1/a, respectively.
(Fu1+ a)(Fu1– a)
⊲ Return a+ 1 or a− 1, respectively.
(
{MincfMdecf
}place [delta 1 ])
⊲ Increment or decrement the value of place by delta. Re-turn new value.
(Fuexp p)(
Fuexpt b p)
⊲ Return ep or bp, respectively.
(Fulog a [b]) ⊲ Return logb a or, without b, ln a.
(Fusqrt n)(
Fuisqrt n)
⊲√n in complex or natural numbers, respectively.
(Fulcm integer∗ 1 )(
Fugcd integer∗)
⊲ Least common multiple or greatest common denomina-tor, respectively, of integers. (gcd) returns 0.
copi ⊲ long-float approximation of π, Ludolph’s number.
(Fusin a)(
Fucos a)(
Futan a)
⊲ sin a, cos a, or tan a, respectively. (a in radians.)
(Fuasin a)(
Fuacos a)
⊲ arcsin a or arccos a, respectively, in radians.
(Fuatan a [b 1 ]) ⊲ arctan a
bin radians.
(Fusinh a)(
Fucosh a)(
Futanh a)
⊲ sinh a, cosh a, or tanh a, respectively.
3
Common Lisp Quick Reference
(Fuchar string i)(
Fuschar string i)
⊲ Return zero-indexed ith character of string ignor-ing/obeying, respectively, fill pointer. setfable.
(Fuparse-integer string
∣∣∣∣∣∣∣∣
:start start 0:end end NIL
:radix int 10:junk-allowed bool NIL
)
⊲ Return integer parsed from string and2index of parse end.
4 Conses
4.1 Predicates
(Fuconsp foo)(
Fulistp foo)
⊲ Return T if foo is of indicated type.
(Fuendp list)(
Funull foo)
⊲ Return T if list/foo is NIL.
(Fuatom foo) ⊲ Return T if foo is not a cons.
(Futailp foo list) ⊲ Return T if foo is a tail of list .
(Fumember foo list
∣∣∣∣∣∣
{:test function#’eql
:test-not function
:key function
)
⊲ Return tail of list starting with its first element matchingfoo. Return NIL if there is no such element.
(
{ Fumember-ifFumember-if-not
}test list [:key function ])
⊲ Return tail of list starting with its first element satisfyingtest . Return NIL if there is no such element.
(Fusubsetp list-a list-b
∣∣∣∣∣∣
{:test function#’eql
:test-not function
:key function
)
⊲ Return T if list-a is a subset of list-b.
4.2 Lists
(Fucons foo bar) ⊲ Return new cons (foo . bar ).
(Fulist foo∗) ⊲ Return list of foos.
(Fulist* foo+)
⊲ Return list of foos with last foo becoming cdr of last cons.Return foo if only one foo given.
(Fumake-list num [:initial-element foo NIL ])
⊲ New list with num elements set to foo.
(Fulist-length list) ⊲ Length of list ; NIL for circular list .
(Fucar list) ⊲ Car of list or NIL if list is NIL. setfable.
(Fucdr list)(
Furest list)
⊲ Cdr of list or NIL if list is NIL. setfable.
(Funthcdr n list) ⊲ Return tail of list after calling
Fucdr n times.
({ Fufirst
Fusecond
Futhird
Fufourth
Fufifth
Fusixth . . .
Funinth
Futenth} list)
⊲ Return nth element of list if any, or NIL otherwise.setfable.
(Funth n list) ⊲ Zero-indexed nth element of list . setfable.
(FucX r list)
⊲ With X being one to four as and ds representingFucars
andFucdrs, e.g. (
Fucadr bar) is equivalent to (
Fucar (
Fucdr bar)).
setfable.
(Fulast list [num 1 ]) ⊲ Return list of last num conses of list .
8
Common Lisp Quick Reference
coboole-eqv ⊲ int-a ≡ int-b.coboole-and ⊲ int-a ∧ int-b.coboole-andc1 ⊲ ¬int-a ∧ int-b.coboole-andc2 ⊲ int-a ∧ ¬int-b.coboole-nand ⊲ ¬(int-a ∧ int-b).coboole-ior ⊲ int-a ∨ int-b.coboole-orc1 ⊲ ¬int-a ∨ int-b.coboole-orc2 ⊲ int-a ∨ ¬int-b.coboole-xor ⊲ ¬(int-a ≡ int-b).coboole-nor ⊲ ¬(int-a ∨ int-b).
(Fulognot integer) ⊲ ¬integer .
(Fulogeqv integer∗)(
Fulogand integer∗)
⊲ Return value of exclusive-nored or anded integer s, re-spectively. Without any integer , return −1.
(Fulogandc1 int-a int-b) ⊲ ¬int-a ∧ int-b.
(Fulogandc2 int-a int-b) ⊲ int-a ∧ ¬int-b.
(Fulognand int-a int-b) ⊲ ¬(int-a ∧ int-b).
(Fulogxor integer∗)(
Fulogior integer∗)
⊲ Return value of exclusive-ored or ored integer s, respec-tively. Without any integer , return 0.
(Fulogorc1 int-a int-b) ⊲ ¬int-a ∨ int-b.
(Fulogorc2 int-a int-b) ⊲ int-a ∨ ¬int-b.
(Fulognor int-a int-b) ⊲ ¬(int-a ∨ int-b).
(Fulogbitp i integer)
⊲ T if zero-indexed ith bit of integer is set.
(Fulogtest int-a int-b)
⊲ Return T if there is any bit set in int-a which is set inint-b as well.
(Fulogcount int)
⊲ Number of 1 bits in int ≥ 0, number of 0 bits in int < 0.
1.4 Integer Functions
(Fuinteger-length integer)
⊲ Number of bits necessary to represent integer .
(Fuldb-test byte-spec integer)
⊲ Return T if any bit specified by byte-spec in integer is set.
(Fuash integer count)
⊲ Return copy of integer arithmetically shifted left bycount adding zeros at the right, or, for count < 0, shiftedright discarding bits.
(Fuldb byte-spec integer)
⊲ Extract byte denoted by byte-spec from integer . setfable.
(
{ Fudeposit-fieldFudpb
}int-a byte-spec int-b)
⊲ Return int-b with bits denoted by byte-spec replacedby corresponding bits of int-a, or by the low (
Fubyte-size
byte-spec) bits of int-a, respectively.
(Fumask-field byte-spec integer)
⊲ Return copy of integer with all bits unset but those de-noted by byte-spec. setfable.
(Fubyte size position)
⊲ Byte specifier for a byte of size bits starting at a weightof 2position .
(Fubyte-size byte-spec)(
Fubyte-position byte-spec)
⊲ Size or position, respectively, of byte-spec.
5
Common Lisp Quick Reference
1.5 Implementation-Dependentcoshort-floatcosingle-floatcodouble-floatcolong-float
-
{epsilonnegative-epsilon
⊲ Smallest possible number making a difference whenadded or subtracted, respectively.
coleast-negativecoleast-negative-normalizedcoleast-positivecoleast-positive-normalized
-
short-floatsingle-floatdouble-floatlong-float
⊲ Available numbers closest to −0 or +0, respectively.
comost-negativecomost-positive
}-
short-floatsingle-floatdouble-floatlong-floatfixnum
⊲ Available numbers closest to −∞ or +∞, respectively.
(Fudecode-float n)(
Fuinteger-decode-float n)
⊲ Return significand,2exponent, and
3sign of float n.
(Fuscale-float n [i ]) ⊲ With n ’s radix b, return nbi.
(Fufloat-radix n)(
Fufloat-digits n)(
Fufloat-precision n)
⊲ Radix, number of digits in that radix, or precision in thatradix, respectively, of float n.
(Fuupgraded-complex-part-type foo [environment NIL ])
⊲ Type of most specialized complex number able to holdparts of type foo.
2 Characters
The standard-char type comprises a-z, A-Z, 0-9, Newline, Space, and!?$"’‘.:,;*+-/|\~ ^<=>#%@&()[]{}.
(Fucharacterp foo)(
Fustandard-char-p char)
⊲ T if argument is of indicated type.
(Fugraphic-char-p character)(
Fualpha-char-p character)(
Fualphanumericp character)
⊲ T if character is visible, alphabetic, or alphanumeric, re-spectively.
(Fuupper-case-p character)(
Fulower-case-p character)(
Fuboth-case-p character)
⊲ Return T if character is uppercase, lowercase, or able tobe in another case, respectively.
(Fudigit-char-p character [radix 10 ])
⊲ Return its weight if character is a digit, or NIL otherwise.
(Fuchar= character+)(
Fuchar/= character+)
⊲ Return T if all characters, or none, respectively, are equal.
(Fuchar-equal character+)(
Fuchar-not-equal character+)
⊲ Return T if all characters, or none, respectively, are equalignoring case.
(Fuchar> character+)(
Fuchar>= character+)(
Fuchar< character+)(
Fuchar<= character+)
⊲ Return T if characters are monotonically decreasing,monotonically non-increasing, monotonically increasing, ormonotonically non-decreasing, respectively.
6
Common Lisp Quick Reference
(Fuchar-greaterp character+)(
Fuchar-not-lessp character+)(
Fuchar-lessp character+)(
Fuchar-not-greaterp character+)
⊲ Return T if characters are monotonically decreasing,monotonically non-increasing, monotonically increasing, ormonotonically non-decreasing, respectively, ignoring case.
(Fuchar-upcase character)(
Fuchar-downcase character)
⊲ Return corresponding uppercase/lowercase character, re-spectively.
(Fudigit-char i [radix 10 ]) ⊲ Character representing digit i .
(Fuchar-name character) ⊲ character ’s name if any, or NIL.
(Funame-char foo) ⊲ Character named foo if any, or NIL.
(Fuchar-int character)(
Fuchar-code character)
⊲ Code of character .
(Fucode-char code) ⊲ Character with code .
cochar-code-limit ⊲ Upper bound of (
Fuchar-code char); ≥ 96.
(Fucharacter c) ⊲ Return #\c.
3 Strings
Strings can as well be manipulated by array and sequence functions;see pages 10 and 12.
(Fustringp foo)(
Fusimple-string-p foo)
⊲ T if foo is of indicated type.
(
{ Fustring=Fustring-equal
}foo bar
∣∣∣∣∣∣∣∣
:start1 start-foo 0
:start2 start-bar 0
:end1 end-foo NIL
:end2 end-bar NIL
)
⊲ Return T if subsequences of foo and bar are equal.Obey/ignore, respectively, case.
(
Fustring{/= -not-equal}Fustring{> -greaterp}Fustring{>= -not-lessp}Fustring{< -lessp}Fustring{<= -not-greaterp}
foo bar
∣∣∣∣∣∣∣∣
:start1 start-foo 0
:start2 start-bar 0
:end1 end-foo NIL
:end2 end-bar NIL
)
⊲ If foo is lexicographically not equal, greater, not less,less, or not greater, respectively, then return position offirst mismatching character in foo. Otherwise return NIL.Obey/ignore, respectively, case.
(Fumake-string size
{∣∣∣∣:initial-element char
:element-type type character
})
⊲ Return string of length size.
(Fustring x)
(
Fustring-capitalizeFustring-upcaseFustring-downcase
x
{∣∣∣∣:start start 0:end end NIL
})
⊲ Convert x (symbol, string, or character) into a string, astring with capitalized words, an all-uppercase string, or anall-lowercase string, respectively.
(
Funstring-capitalizeFunstring-upcaseFunstring-downcase
string
{∣∣∣∣:start start 0:end end NIL
})
⊲ Convert string into a string with capitalized words, anall-uppercase string, or an all-lowercase string, respectively.
(
Fustring-trimFustring-left-trimFustring-right-trim
char-bag string)
⊲ Return string with all characters in sequence char-bag
removed from both ends, from the beginning, or from theend, respectively.
7
Common Lisp Quick Reference
6 Sequences
6.1 Sequence Predicates
(
{ FueveryFunotevery
}test sequence+)
⊲ Return NIL or T, respectively, as soon as test on any setof corresponding elements of sequences returns NIL.
(
{ FusomeFunotany
}test sequence+)
⊲ Return value of test or NIL, respectively, as soon as test
on any set of corresponding elements of sequences returnsnon-NIL.
(Fumismatch sequence-a sequence-b
∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣
:from-end bool NIL{:test function#’eql
:test-not function
:start1 start-a 0
:start2 start-b 0
:end1 end-a NIL
:end2 end-b NIL
:key function
)
⊲ Return position in sequence-a where sequence-a andsequence-b begin to mismatch. Return NIL if they matchentirely.
6.2 Sequence Functions
(Fumake-sequence sequence-type size [:initial-element foo])
⊲ Make sequence of sequence-type with size elements.
(Fuconcatenate type sequence∗)
⊲ Return concatenated sequence of type.
(Fumerge type ˜sequence-a ˜sequence-b test [:key function NIL ])
⊲ Return interleaved sequence of type. Merged sequencewill be sorted if both sequence-a and sequence-b are sorted.
(Fufill ˜sequence foo
{∣∣∣∣:start start 0:end end NIL
})
⊲ Return sequence after setting elements between start andend to foo.
(Fulength sequence)
⊲ Return length of sequence (being value of fill pointer ifapplicable).
(Fucount foo sequence
∣∣∣∣∣∣∣∣∣∣∣∣
:from-end bool NIL{:test function#’eql
:test-not function
:start start 0:end end NIL
:key function
)
⊲ Return number of elements in sequence which match foo.
(
{ Fucount-ifFucount-if-not
}test sequence
∣∣∣∣∣∣∣∣
:from-end bool NIL:start start 0:end end NIL
:key function
)
⊲ Return number of elements in sequence which satisfy test.
(Fuelt sequence index)
⊲ Return element of sequence pointed to by zero-indexedindex . setfable.
(Fusubseq sequence start [end NIL ])
⊲ Return subsequence of sequence between start and end.setfable.
(
{ FusortFustable-sort
}˜sequence test [:key function ])
⊲ Return sequence sorted. Order of elements consideredequal is not guaranteed/retained, respectively.
(Fureverse sequence)(
Funreverse ˜sequence)
⊲ Return sequence in reverse order.
12
Common Lisp Quick Reference
(
{ Fubutlast listFunbutlast list
}[num 1 ]) ⊲ list excluding last num conses.
(
{ FurplacaFurplacd
}cons object)
⊲ Replace car, or cdr, respectively, of cons with object .
(Fuldiff list foo)
⊲ If foo is a tail of list , return preceding part of list . Oth-erwise return list .
(Fuadjoin foo list
∣∣∣∣∣∣
{:test function#’eql
:test-not function
:key function
)
⊲ Return list if foo is already member of list . If not, return(
Fucons foo list ).
(Mpop place) ⊲ Set place to (
Fucdr place), return (
Fucar place ).
(Mpush foo place) ⊲ Set place to (
Fucons foo place ).
(Mpushnew foo place
∣∣∣∣∣∣
{:test function#’eql
:test-not function
:key function
)
⊲ Set place to (Fuadjoin foo place ).
(Fuappend [proper-list∗ foo NIL ])
(Funconc [ ˜non-circular-list∗ foo NIL ])
⊲ Return concatenated list or, with only one argument, foo.foo can be of any type.
(Furevappend list foo)
(Funreconc list foo)
⊲ Return concatenated list after reversing order in list .
(
{ FumapcarFumaplist
}function list+)
⊲ Return list of return values of function successively in-voked with corresponding arguments, either cars or cdrs,respectively, from each list .
(
{ FumapcanFumapcon
}function list+)
⊲ Return list of concatenated return values of function suc-cessively invoked with corresponding arguments, either carsor cdrs, respectively, from each list . function should returna list.
(
{ FumapcFumapl
}function list+)
⊲ Return first list after successively applying function tocorresponding arguments, either cars or cdrs, respectively,from each list . function should have some side effects.
(Fucopy-list list) ⊲ Return copy of list with shared elements.
4.3 Association Lists
(Fupairlis keys values [alist NIL ])
⊲ Prepend to alist an association list made from lists keys
and values .
(Fuacons key value alist)
⊲ Return alist with a (key . value) pair added.
(
{ FuassocFurassoc
}foo alist
∣∣∣∣∣∣
{:test test#’eql
:test-not test
:key function
)
(
{ Fuassoc-if[-not]Furassoc-if[-not]
}test alist [:key function ])
⊲ First cons whose car, or cdr, respectively, satisfies test .
(Fucopy-alist alist) ⊲ Return copy of alist .
9
Common Lisp Quick Reference
4.4 Trees
(Futree-equal foo bar
{:test test#’eql
:test-not test
})
⊲ Return T if trees foo and bar have same shape and leavessatisfying test.
(
{ Fusubst new old treeFunsubst new old tree
}
∣∣∣∣∣∣
{:test function#’eql
:test-not function
:key function
)
⊲ Make copy of tree with each subtree or leaf matching old
replaced by new .
(
{ Fusubst-if[-not] new test treeFunsubst-if[-not] new test tree
}[:key function])
⊲ Make copy of tree with each subtree or leaf satisfying test
replaced by new .
(
{ Fusublis association-list treeFunsublis association-list tree
}
∣∣∣∣∣∣
{:test function#’eql
:test-not function
:key function
)
⊲ Make copy of tree with each subtree or leaf matching akey in association-list replaced by that key’s value.
(Fucopy-tree tree) ⊲ Copy of tree with same shape and leaves.
4.5 Sets
(
FuintersectionFuset-differenceFuunionFuset-exclusive-or
a b
FunintersectionFunset-difference
}a b
FununionFunset-exclusive-or
}a b
∣∣∣∣∣∣
{:test function#’eql
:test-not function
:key function
)
⊲ Return a ∩ b, a \ b, a ∪ b, or a△ b, respectively, of lists a
and b.
5 Arrays
5.1 Predicates
(Fuarrayp foo)(
Fuvectorp foo)(
Fusimple-vector-p foo)(
Fubit-vector-p foo)(
Fusimple-bit-vector-p foo)
⊲ T if foo is of indicated type.
(Fuadjustable-array-p array)(
Fuarray-has-fill-pointer-p array)
⊲ T if array is adjustable/has a fill pointer, respectively.
(Fuarray-in-bounds-p array [subscripts ])
⊲ Return T if subscripts are in array ’s bounds.
5.2 Array Functions
(
{ Fumake-array dimension-sizes
[:adjustable bool NIL
]Fuadjust-array array dimension-sizes
}
∣∣∣∣∣∣∣∣∣∣
:element-type type T
:fill-pointer {num bool}NIL:initial-element obj
:initial-contents sequence
:displaced-to array NIL [:displaced-index-offset i 0 ]
)
⊲ Return fresh, or readjust, respectively, vector or array.
(Fuaref array
[subscripts
])
⊲ Return array element pointed to by subscripts . setfable.
(Furow-major-aref array i)
⊲ Return ith element of array in row-major order. setfable.
10
Common Lisp Quick Reference
(Fuarray-row-major-index array [subscripts])
⊲ Index in row-major order of the element denoted bysubscripts.
(Fuarray-dimensions array)
⊲ List containing the lengths of array ’s dimensions.
(Fuarray-dimension array i)
⊲ Length of ith dimension of array .
(Fuarray-total-size array) ⊲ Number of elements in array .
(Fuarray-rank array) ⊲ Number of dimensions of array .
(Fuarray-displacement array) ⊲ Target array and
2offset.
(Fubit bit-array [subscripts ])(
Fusbit simple-bit-array [subscripts])
⊲ Return element of bit-array or of simple-bit-array. setf-able.
(Fubit-not ˜bit-array [ ˜result-bit-array NIL ])
⊲ Return result of bitwise negation of bit-array. Ifresult-bit-array is T, put result in bit-array ; if it is NIL,make a new array for result.
(
Fubit-eqvFubit-andFubit-andc1Fubit-andc2Fubit-nandFubit-iorFubit-orc1Fubit-orc2Fubit-xorFubit-nor
˜bit-array-a bit-array-b [ ˜result-bit-array NIL ])
⊲ Return result of bitwise logical operations (cf. opera-tions of
Fuboole, p. 4) on bit-array-a and bit-array-b. If
result-bit-array is T, put result in bit-array-a; if it is NIL,make a new array for result.
coarray-rank-limit ⊲ Upper bound of array rank; ≥ 8.
coarray-dimension-limit
⊲ Upper bound of an array dimension; ≥ 1024.
coarray-total-size-limit ⊲ Upper bound of array size; ≥ 1024.
5.3 Vector Functions
Vectors can as well be manipulated by sequence functions; see sec-tion 6.
(Fuvector foo∗) ⊲ Return fresh simple vector of foo s.
(Fusvref vector i) ⊲ Return element i of simple vector . setfable.
(Fuvector-push foo vector)
⊲ Return NIL if vector ’s fill pointer equals size of vector .Otherwise replace element of vector pointed to by fillpointer with foo; then increment fill pointer.
(Fuvector-push-extend foo vector [num])
⊲ Replace element of vector pointed to by fill pointer withfoo, then increment fill pointer. Extend vector ’s size by≥ num if necessary.
(Fuvector-pop vector)
⊲ Return element of vector its fillpointer points to afterdecrementation.
(Fufill-pointer vector) ⊲ Fill pointer of vector . setfable.
11
Common Lisp Quick Reference
(Fufboundp
{foo
(setf foo)
}) ⊲ T if foo is a global function or macro.
9.2 Variables
(
{MdefconstantMdefparameter
}foo form [doc])
⊲ Assign value of form to global constant/dynamic variablefoo.
(Mdefvar foo
[form [doc]
])
⊲ Unless bound already, assign value of form to dynamicvariable foo.
(
{MsetfMpsetf
}{place form}∗)
⊲ Set places to primary values of forms. Return values oflast form/NIL; work sequentially/in parallel, respectively.
(
{ sOsetqMpsetq
}{symbol form}∗)
⊲ Set symbols to primary values of forms. Return value oflast form/NIL; work sequentially/in parallel, respectively.
(Fuset symbol foo)
⊲ Set symbol ’s value cell to foo. Deprecated.
(Mmultiple-value-setq vars form)
⊲ Set elements of vars to the values of form. Return form ’sprimary value.
(Mshiftf place+ foo)
⊲ Store value of foo in rightmost place shifting values ofplaces left, returning first place .
(Mrotatef place∗)
⊲ Rotate values of places left, old first becoming new lastplace ’s value. Return NIL.
(Fumakunbound foo) ⊲ Delete special variable foo if any.
(Fuget symbol key
[default NIL
])
(Fugetf place key
[default NIL
])
⊲ First entry key from property list stored in symbol/inplace , respectively, or default if there is no key. setfable.
(Fuget-properties property-list keys)
⊲ Return key and2value of first entry from property-list
matching a key from keys, and3tail of property-list start-
ing with that key. Return NIL,2NIL, and
3NIL if there was no
matching key in property-list .
(Furemprop symbol key)
(Mremf place key)
⊲ Remove first entry key from property list stored insymbol/in place , respectively. Return T if key was there,or NIL otherwise.
9.3 Functions
Below, ordinary lambda list (ord-λ∗) has the form
(var∗[&optional
{var
(var[init NIL [supplied-p]
])
}∗][&rest var ]
[&key
var
(
{var
(:key var)
} [init NIL [supplied-p]
])
∗
[&allow-other-keys]] [
&aux
{var
(var [init NIL ])
}∗]).
supplied-p is T if there is a corresponding argument. init forms canrefer to any init and supplied-p to their left.
16
Common Lisp Quick Reference
(
{ FufindFuposition
}foo sequence
∣∣∣∣∣∣∣∣∣∣∣∣
:from-end bool NIL{:test function#’eql
:test-not test
:start start 0:end end NIL
:key function
)
⊲ Return first element in sequence which matches foo, orits position relative to the begin of sequence, respectively.
(
Fufind-ifFufind-if-notFuposition-ifFuposition-if-not
test sequence
∣∣∣∣∣∣∣∣
:from-end bool NIL:start start 0:end end NIL
:key function
)
⊲ Return first element in sequence which satisfies test , orits position relative to the begin of sequence, respectively.
(Fusearch sequence-a sequence-b
∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣
:from-end bool NIL{:test function#’eql
:test-not function
:start1 start-a 0
:start2 start-b 0
:end1 end-a NIL
:end2 end-b NIL
:key function
)
⊲ Search sequence-b for a subsequence matchingsequence-a. Return position in sequence-b, or NIL.
(
{ Furemove foo sequenceFudelete foo ˜sequence
}
∣∣∣∣∣∣∣∣∣∣∣∣∣∣
:from-end bool NIL{:test function#’eql
:test-not function
:start start 0:end end NIL
:key function
:count count NIL
)
⊲ Make copy of sequence without elements matching foo.
(
Furemove-ifFuremove-if-not
}test sequence
Fudelete-ifFudelete-if-not
}test ˜sequence
∣∣∣∣∣∣∣∣∣
:from-end bool NIL:start start 0:end end NIL
:key function
:count count NIL
)
⊲ Make copy of sequence with all (or count) elements sat-isfying test removed.
(
{ Furemove-duplicates sequenceFudelete-duplicates ˜sequence
}
∣∣∣∣∣∣∣∣∣∣∣∣
:from-end bool NIL{:test function#’eql
:test-not function
:start start 0:end end NIL
:key function
)
⊲ Make copy of sequence without duplicates.
(
{ Fusubstitute new old sequenceFunsubstitute new old ˜sequence
}
∣∣∣∣∣∣∣∣∣∣∣∣∣∣
:from-end bool NIL{:test function#’eql
:test-not function
:start start 0:end end NIL
:key function
:count count NIL
)
⊲ Make copy of sequence with all (or count) olds replacedby new .
(
Fusubstitute-ifFusubstitute-if-not
}new test sequence
Funsubstitute-ifFunsubstitute-if-not
}new test ˜sequence
∣∣∣∣∣∣∣∣∣
:from-end bool NIL:start start 0:end end NIL
:key function
:count count NIL
)
⊲ Make copy of sequence with all (or count) elements sat-isfying test replaced by new .
(Fureplace ˜sequence-a sequence-b
∣∣∣∣∣∣∣∣
:start1 start-a 0
:start2 start-b 0
:end1 end-a NIL
:end2 end-b NIL
)
⊲ Replace elements of sequence-a with elements ofsequence-b.
13
Common Lisp Quick Reference
(Fumap type function sequence+)
⊲ Apply function successively to corresponding elements ofthe sequences. Return values as a sequence of type. If typeis NIL, return NIL.
(Fumap-into ˜result-sequence function sequence∗)
⊲ Store into result-sequence successively values of functionapplied to corresponding elements of the sequences.
(Fureduce function sequence
∣∣∣∣∣∣∣∣∣
:initial-value foo NIL
:from-end bool NIL:start start 0:end end NIL
:key function
)
⊲ Starting with the first two elements of sequence, applyfunction successively to its last return value together withthe next element of sequence. Return last value of function.
(Fucopy-seq sequence)
⊲ Copy of sequence with shared elements.
7 Hash Tables
Key-value storage similar to hash tables can as well be achieved us-ing association lists and property lists; see pages 9 and 16.
(Fuhash-table-p foo) ⊲ Return T if foo is of type hash-table.
(Fumake-hash-table
∣∣∣∣∣∣∣∣
:test {Fueq Fueql
Fuequal
Fuequalp}#’eql
:size int
:rehash-size num
:rehash-threshold num
)
⊲ Make a hash table.
(Fugethash key hash-table [default NIL ])
⊲ Return object with key if any or default otherwise; and
2T if found,
2NIL otherwise. setfable.
(Fuhash-table-count hash-table)
⊲ Number of entries in hash-table.
(Furemhash key ˜hash-table)
⊲ Remove from hash-table entry with key and return T if itexisted. Return NIL otherwise.
(Fuclrhash ˜hash-table) ⊲ Empty hash-table .
(Fumaphash function hash-table)
⊲ Iterate over hash-table calling function on key and value.Return NIL.
(Mwith-hash-table-iterator (foo hash-table) (declare decl∗)∗ form
P∗)⊲ Return values of forms. In forms, invocations of (foo)return: T if an entry is returned; its key; its value.
(Fuhash-table-test hash-table)
⊲ Test function used in hash-table.
(Fuhash-table-size hash-table)(
Fuhash-table-rehash-size hash-table)(
Fuhash-table-rehash-threshold hash-table)
⊲ Current size, rehash-size, or rehash-threshold, respec-tively, as used in
Fumake-hash-table.
(Fusxhash foo)
⊲ Hash code unique for any argumentFuequal foo.
14
Common Lisp Quick Reference
8 Structures
(Mdefstruct
foo
(foo
∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣
{:conc-name
(:conc-name [ slot-prefix foo- ]){:constructor
(:constructor[maker MAKE-foo [(ord-λ∗)]
])
}∗
{:copier
(:copier [copier COPY-foo ])
(:include struct
slot
(slot [init
{∣∣∣∣∣:type sl-type
:read-only b
}])
∗
)
(:type
listvector
(vector type)
)
{∣∣∣∣:named(:initial-offset n)
{(:print-object [ o-printer ])
(:print-function [ f-printer ]){:predicate(:predicate [p-name foo-P ])
)
[doc]
slot
(slot [init
{∣∣∣∣∣:type slot-type
:read-only bool
}])
∗
)
⊲ Define structure foo together with functions MAKE-foo,COPY-foo and foo-P; and setfable accessors foo-slot . In-stances are of class foo or, if defstruct option :type is given,of the specified type. They can be created by (MAKE-foo{:slot value}∗) or, if ord-λ (see p. 16) is given, by (maker
arg∗ {:key value}∗). In the latter case, args and :keyscorrespond to the positional and keyword parameters de-fined in ord-λ whose vars in turn correspond to slots.:print-object/:print-function generate a
gFprint-object method
for an instance bar of foo calling (o-printer bar stream)or (f-printer bar stream print-level), respectively. If :typewithout :named is given, no foo-P is created.
(Fucopy-structure structure)
⊲ Return copy of structure with shared slot values.
9 Control Structure
9.1 Predicates
(Fueq foo bar) ⊲ T if foo and bar are identical.
(Fueql foo bar)
⊲ T if foo and bar are identical, or the same character, ornumbers of the same type and value.
(Fuequal foo bar)
⊲ T if foo and bar areFueql, or are equivalent pathnames,
or are conses withFuequal cars and cdrs, or are strings or
bit-vectors withFueql elements below their fill pointers.
(Fuequalp foo bar)
⊲ T if foo and bar are identical; or are the same characterignoring case; or are numbers of the same value ignoringtype; or are equivalent pathnames; or are conses or arraysof the same shape with
Fuequalp elements; or are structures
of the same type withFuequalp elements; or are hash-tables of
the same size with the same :test function, the same keysin terms of :test function, and
Fuequalp elements.
(Funot foo) ⊲ T if foo is NIL; NIL otherwise.
(Fuboundp symbol) ⊲ T if symbol is a special variable.
(Fuconstantp foo [environment NIL ])
⊲ T if foo is a constant form.
(Fufunctionp foo) ⊲ T if foo is of type function.
15
Common Lisp Quick Reference
(sOmultiple-value-prog1 form-r form∗)(
Mprog1 form-r form∗)(
Mprog2 form-a form-r form∗)
⊲ Evaluate forms in order. Return values/primary value,respectively, of form-r .
(
{sOletsOlet*} (
{∣∣∣∣name
(name [value NIL ])
}∗) (declare decl∗)∗ form
P∗)
⊲ Evaluate forms with names lexically bound (in parallelor sequentially, respectively) to values. Return values offorms.
(
{MprogMprog*} (
{∣∣∣∣name
(name [value NIL ])
}∗) (declare decl∗)∗
{tag
form
}∗)
⊲ EvaluatesOtagbody-like body with names lexically bound
(in parallel or sequentially, respectively) to values. ReturnNIL or explicitly
Mreturned values. Implicitly, the whole form
is asOblock named NIL.
(sOprogv symbols values form
P∗)⊲ Evaluate forms with locally established dynamic bind-ings of symbols to values or NIL. Return values of forms.
(sOunwind-protect protected cleanup∗)
⊲ Evaluate protected and then, no matter how controlleaves protected , cleanups. Return values of protected .
(Mdestructuring-bind destruct-λ bar (declare decl∗)∗ form
P∗)⊲ Evaluate forms with variables from tree destruct-λ boundto corresponding elements of tree bar , and return theirvalues. destruct-λ resembles macro-λ (section 9.4), butwithout any &environment clause.
(Mmultiple-value-bind (var∗) values-form (declare decl∗)∗
body-formP∗)
⊲ Evaluate body-forms with vars lexically bound to the re-turn values of values-form. Return values of body-form s.
(sOblock name form
P∗)⊲ Evaluate forms in a lexical environment, and return theirvalues unless interrupted by
sOreturn-from.
(sOreturn-from foo [result NIL ])(
Mreturn [result NIL ])
⊲ Have nearest enclosingsOblock named foo/named NIL, re-
spectively, return with values of result .
(sOtagbody {tag form}∗)
⊲ Evaluate forms in a lexical environment. tags (symbolsor integers) have lexical scope and dynamic extent, and aretargets for
sOgo. Return NIL.
(sOgo tag)
⊲ Within the innermost possible enclosingsOtagbody, jump
to a tag eql tag .
(sOcatch tag form
P∗)⊲ Evaluate forms and return their values unless interruptedby
sOthrow.
(sOthrow tag form)
⊲ Have the nearest dynamically enclosingsOcatch with a tag
Fueq tag return with the values of form.
(Fusleep n) ⊲ Wait n seconds, return NIL.
9.6 Iteration
(
{MdoMdo*} (
{var
(var[start [step]
])
}∗) (stop result
P∗) (declare decl∗)∗
{tag
form
}∗)
⊲ EvaluatesOtagbody-like body with vars successively bound
according to the values of the corresponding start and step
forms. vars are bound in parallel/sequentially, respectively.Stop iteration when stop is T. Return values of result∗.Implicitly, the whole form is a
sOblock named NIL.
20
Common Lisp Quick Reference
(
Mdefun
{foo (ord-λ∗)(setf foo) (new-value ord-λ∗)
Mlambda (ord-λ∗)
(declare decl∗)∗ [doc]
formP∗)
⊲ Define a function named foo or (setf foo), or an anony-mous function, respectively, which applies forms to ord-λs.For
Mdefun, forms are enclosed in an implicit
sOblock named
foo.
(
{sOfletsOlabels
}((
{foo (ord-λ∗)(setf foo) (new-value ord-λ∗)
}(declare local-decl∗)∗
[doc] local-formP∗)∗) (declare decl∗)∗ form
P∗)⊲ Evaluate forms with locally defined functions foo. Glob-ally defined functions of the same name are shadowed. Eachfoo is also the name of an implicit
sOblock around its corre-
sponding local-form∗. Only forsOlabels, functions foo are
visible inside local-forms . Return values of forms.
(sOfunction
{foo
(Mlambda form∗)
})
⊲ Return lexically innermost function named foo or a lexi-cal closure of the
Mlambda expression.
(Fuapply
{function
(setf function)
}arg∗ args)
⊲ Values of function called with args and the list elementsof args . setfable if function is one of
Fuaref,
Fubit, and
Fusbit.
(Fufuncall function arg∗) ⊲ Values of function called with args.
(sOmultiple-value-call function form∗)
⊲ Call function with all the values of each form as its ar-guments. Return values returned by function .
(Fuvalues-list list) ⊲ Return elements of list .
(Fuvalues foo∗)
⊲ Return as multiple values the primary values of the foos.setfable.
(Fumultiple-value-list form) ⊲ List of the values of form .
(Mnth-value n form)
⊲ Zero-indexed nth return value of form.
(Fucomplement function)
⊲ Return new function with same arguments and same sideeffects as function , but with complementary truth value.
(Fuconstantly foo)
⊲ Function of any number of arguments returning foo.
(Fuidentity foo) ⊲ Return foo.
(Fufunction-lambda-expression function)
⊲ If available, return lambda expression of function ,2NIL if
function was defined in an environment without bindings,and
3name of function .
(Fufdefinition
{foo
(setf foo)
})
⊲ Definition of global function foo. setfable.
(Fufmakunbound foo)
⊲ Remove global function or macro definition foo.
cocall-arguments-limitcolambda-parameters-limit
⊲ Upper bound of the number of function arguments orlambda list parameters, respectively; ≥ 50.
comultiple-values-limit
⊲ Upper bound of the number of values a multiple valuecan have; ≥ 20.
17
Common Lisp Quick Reference
9.4 Macros
Below, macro lambda list (macro-λ∗) has the form of either
([&whole var ] [E ]
{var
(macro-λ∗)
}∗[E ]
[&optional
var
(
{var
(macro-λ∗)
} [init NIL [supplied-p]
])
∗
] [E ]
[
{&rest&body
} {rest-var
(macro-λ∗)
}] [E ]
[&key
var
(
var
(:key
{var
(macro-λ∗)
})
[init NIL [supplied-p]
])
∗
[E ]
[&allow-other-keys]][&aux
{var
(var [init NIL ])
}∗] [E ])
or
([&whole var ] [E ]
{var
(macro-λ∗)
}∗[E ] [&optional
var
(
{var
(macro-λ∗)
} [init NIL [supplied-p]
])
∗
] [E ] . rest-var).
One toplevel [E ] may be replaced by &environment var . supplied-p
is T if there is a corresponding argument. init forms can refer toany init and supplied-p to their left.
(
{MdefmacroFudefine-compiler-macro
} {foo
(setf foo)
}(macro-λ∗) (declare
decl∗)∗ [doc] formP∗)
⊲ Define macro foo which on evaluation as (foo tree) appliesexpanded forms to arguments from tree, which correspondsto tree-shaped macro-λs. forms are enclosed in an implicitsOblock named foo.
(Mdefine-symbol-macro foo form)
⊲ Define symbol macro foo which on evaluation evaluatesexpanded form.
(sOmacrolet ((foo (macro-λ∗) (declare local-decl∗)∗ [doc]
macro-formP∗)∗) (declare decl∗)∗ form
P∗)⊲ Evaluate forms with locally defined mutually invisiblemacros foo which are enclosed in implicit
sOblocks of the same
name.
(sOsymbol-macrolet ((foo expansion-form)∗) (declare decl∗)∗ form
P∗)⊲ Evaluate forms with locally defined symbol macros foo.
(Mdefsetf function{
updater [doc]
(setf-λ∗) (s-var∗) (declare decl∗)∗ [doc] formP∗
})
where defsetf lambda list (setf-λ∗) has the form (var∗
[&optional
{var
(var[init NIL [supplied-p]
])
}∗][&rest var ]
[&key
var
(
{var
(:key var)
} [init NIL [supplied-p]
])
∗
[&allow-other-keys]] [
&environment var])
⊲ Specify how to setf a place accessed by function .Short form: (setf (function arg∗) value-form) is replacedby (updater arg∗ value-form); the latter must returnvalue-form. Long form: on invocation of (setf (functionarg∗) value-form), forms must expand into code that setsthe place accessed where setf-λ and s-var∗ describe the ar-guments of function and the value(s) to be stored, respec-tively; and that returns the value(s) of s-var∗. forms areenclosed in an implicit
sOblock named function .
(Mdefine-setf-expander function (macro-λ∗) (declare decl∗)∗ [doc]
formP∗)
⊲ Specify how to setf a place accessed by function . On in-vocation of (setf (function arg∗) value-form), form∗ mustexpand into code returning arg-vars , args , newval-vars ,set-form, and get-form as described with
Fuget-setf-expansion
where the elements of macro lambda list macro-λ∗ arebound to corresponding args. forms are enclosed in an im-plicit
sOblock named function.
18
Common Lisp Quick Reference
(Fuget-setf-expansion place [environment NIL ])
⊲ Return lists of temporary variables arg-vars and of cor-responding
2args as given with place , list
3newval-vars with
temporary variables corresponding to the new values, and
4set-form and
5get-form specifying in terms of arg-vars and
newval-vars how to setf and how to read place .
(Mdefine-modify-macro foo (
[&optional{
var
(var[init NIL [supplied-p]
])
}∗][&rest var ]) function [doc])
⊲ Define macro foo able to modify a place. On invocationof (foo place arg∗), the value of function applied to place
and args will be stored into place and returned.
colambda-list-keywords
⊲ List of macro lambda list keywords. These are at least:
&whole var
⊲ Bind var to the entire macro call form.
&optional var∗
⊲ Bind vars to corresponding arguments if any.
{&rest &body} var⊲ Bind var to a list of remaining arguments.
&key var∗
⊲ Bind vars to corresponding keyword arguments.
&allow-other-keys⊲ Suppress keyword argument checking. Callers can doso using :allow-other-keys T.
&environment var
⊲ Bind var to the lexical compilation environment.
&aux var∗ ⊲ Bind vars as insOlet*.
9.5 Control Flow
(sOif test then [else NIL ])
⊲ Return values of then if test returns T; return values ofelse otherwise.
(Mcond (test then
P∗test )
∗)⊲ Return the values of the first then∗ whose test returns T;return NIL if all tests return NIL.
(
{MwhenMunless
}test foo
P∗)
⊲ Evaluate foos and return their values if test returns T orNIL, respectively. Return NIL otherwise.
(Mcase test (
{(key∗)
key
}foo
P∗)∗[(
{otherwiseT
}bar
P∗)NIL])
⊲ Return the values of the first foo∗ one of whose keys iseql test . Return values of bar s if there is no matching key.
(
{MecaseMccase
}test (
{(key∗)
key
}foo
P∗)∗)
⊲ Return the values of the first foo∗ one of whose keys iseql test. Signal non-correctable/correctable type-error andreturn NIL if there is no matching key.
(Mand form∗
T )⊲ Evaluate forms from left to right. Immediately returnNIL if one form’s value is NIL. Return values of last form
otherwise.
(Mor form∗
NIL )⊲ Evaluate forms from left to right. Immediately returnprimary value of first non-NIL-evaluating form, or all valuesif last form is reached. Return NIL if no form returns T.
(sOprogn form∗
NIL )⊲ Evaluate forms sequentially. Return values of last form .
19
Common Lisp Quick Reference
(
slot
(slot
∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣
{:reader reader}∗
{:writer{writer
(setf writer)
}}∗
{:accessor accessor}∗
:allocation
{:instance:class
}:instance
{:initarg :initarg-name}∗:initform form
:type type
:documentation slot-doc
)
∗
)
∣∣∣∣∣∣
(:default-initargs {name value}∗)(:documentation class-doc)(:metaclass name standard-class )
)
⊲ Define, as a subclass of superclasses, class foo . In a newinstance i , a slot ’s value defaults to form unless set via:initarg-name ; it is readable via (reader i) or (accessori), and writeable via (writer value i) or (setf (accessori) value). With :allocation :class, slot is shared by all in-stances of class foo.
(Fufind-class symbol
[errorp T [environment ]
])
⊲ Return class named symbol . setfable.
(gFmake-instance class {:initarg value}∗ other-keyarg∗)
⊲ Make new instance of class .
(gFreinitialize-instance instance {:initarg value}∗ other-keyarg∗)
⊲ Change local slots of instance according to initargs.
(Fuslot-value foo slot) ⊲ Return value of slot in foo . setfable.
(Fuslot-makunbound instance slot)
⊲ Make slot in instance unbound.
(
{Mwith-slots ({slot (var slot)}∗)Mwith-accessors ((var accessor)∗)
}instance (declare decl∗)∗
formP∗)
⊲ Return values of forms after evaluating them in a lexicalenvironment with slots of instance visible as setfable slotsor vars/with accessors of instance visible as setfable vars.
(gFclass-name class)((setf
gFclass-name) new-name class)
⊲ Get/set name of class .
(Fuclass-of foo) ⊲ Class foo is a direct instance of.
(gFchange-class ˜instance new-class {:initarg value}∗ other-keyarg∗)
⊲ Change class of instance to new-class .
(gFmake-instances-obsolete class)
⊲ Update instances of class .
(
{ gFinitialize-instance (instance)gFupdate-instance-for-different-class previous current
}
{:initarg value}∗ other-keyarg∗)⊲ Its primary method sets slots on behalf ofgFmake-instance/of
gFchange-class by means of
gFshared-initialize.
(gFupdate-instance-for-redefined-class instances added-slots
discarded-slots property-list {:initarg value}∗other-keyarg∗)⊲ Its primary method sets slots on behalf ofgFmake-instances-obsolete by means of
gFshared-initialize.
(gFallocate-instance class {:initarg value}∗ other-keyarg∗)
⊲ Return uninitialized instance of class . Called bygFmake-instance.
(gFshared-initialize instance
{slots
T
}{:initarg value}∗ other-keyarg∗)
⊲ Fill instance’s slots using initargs and :initform forms.
(gFslot-missing class object slot
setfslot-boundpslot-makunboundslot-value
[value])
⊲ Called in case of attempted access to missing slot . Itsprimary method signals error.
24
Common Lisp Quick Reference
(Mdotimes (var i [result NIL ]) (declare decl∗)∗ {tag form}∗)
⊲ EvaluatesOtagbody-like body with var successively bound
to integers from 0 to i − 1. Upon evaluation of result , varis i . Implicitly, the whole form is a
sOblock named NIL.
(Mdolist (var list [result NIL ]) (declare decl∗)∗ {tag form}∗)
⊲ EvaluatesOtagbody-like body with var successively bound
to the elements of list . Upon evaluation of result , var isNIL. Implicitly, the whole form is a
sOblock named NIL.
9.7 Loop Facility
(Mloop form∗)
⊲ Simple Loop. If forms do not contain any atomic LoopFacility keywords, evaluate them forever in an implicit
sOblock
named NIL.
(Mloop clause∗)
⊲ Loop Facility. For Loop Facility keywords see below andFigure 1.
named n NIL ⊲ GiveMloop’s implicit
sOblock a name.
{with{var-s
(var-s∗)
}[d-type] [= foo]}+
{and{var-p
(var-p∗)
}[d-type] [= bar ]}∗
where destructuring type specifier d-type has the form{fixnum float T NIL
{of-type
{type
(type∗)
}}}
⊲ Initialize (possibly trees of) local variables var-s se-quentially and var-p in parallel.
{{for as}
{var-s
(var-s∗)
}[d-type]
}+ {and
{var-p
(var-p∗)
}[d-type]
}∗
⊲ Begin of iteration control clauses. Initialize and step(possibly trees of) local variables var-s sequentially andvar-p in parallel. Destructuring type specifier d-type aswith with.
{upfrom from downfrom} start⊲ Start stepping with start
{upto downto to below above} form⊲ Specify form as the end value for stepping.
{in on} list⊲ Bind var to successive elements/tails, respec-tively, of list .
by {step 1 function#’cdr}⊲ Specify the (positive) decrement or increment orthe function of one argument returning the nextpart of the list.
= foo [then bar foo ]
⊲ Bind var initially to foo and later to bar .
across vector
⊲ Bind var to successive elements of vector .
being {the each}⊲ Iterate over a hash table or a package.
{hash-key hash-keys} {of in} hash-table [using(hash-value value)]⊲ Bind var successively to the keys ofhash-table ; bind value to corresponding values.
{hash-value hash-values} {of in} hash-table [using(hash-key key)]⊲ Bind var successively to the values ofhash-table ; bind key to corresponding keys.
{symbol symbols present-symbol present-symbols
external-symbol external-symbols} [{of in}package var*package* ]⊲ Bind var successively to the accessible sym-bols, or the present symbols, or the externalsymbols respectively, of package .
21
Common Lisp Quick Reference
(loop[namednNIL]
with
{ var
(var∗)}
[d-type][=
foo]{a
nd
{ var
(var∗)}
[d-type][=
bar]}
∗
for
as
}{ v
ar
(var∗)}
[d-type]
[{upfrom
from
}start
0
][
upto
to below
form
]
from
start
{downto
above
}form
downfrom
start
[ downto
to above
form
]
[bystep1]
in on
}list
[byfunction
#’cdr]
=foo[thenbarfoo]
across
vector
being
{the
each
}
hash-key[s]
{of
in
}hash
[using(hash-valuev)]
hash-value[s]{
of
in
}hash
[using(hash-keyk)]
symbol[s]
present-symbol[s]
external-symbol[s]
[{
of
in
}package
var *package*]
F0
{ and
Fi
} ∗
T1
∗
do[ing]form
+
if when
unless
test
Ci{a
nd
Cj}∗
[else
Ck{a
nd
Cl}∗
][end]
return
{form
itco
llect[ing]
append[ing]
nco
nc[ing]
{form
it
}[into
list]
count[ing]
sum[m
ing]
maximize
maximizing
minim
ize
minim
izing
{form
it
}[into
num][type]
C0
initially
finally
}form
+
repeatnum
while
until
always
neve
rthereis
test
T2
∗ )
Figure 1: Loop Facility,Overview.
22
Common Lisp Quick Reference
{do doing} form+
⊲ Evaluate forms in every iteration.
{if when unless} test i-clause {and j-clause}∗ [elsek-clause {and l-clause}∗] [end]⊲ If test returns T, T, or NIL, respectively, evaluatei-clause and j-clauses; otherwise, evaluate k-clause andl-clauses.
it ⊲ Inside i-clause or k-clause: value of test .
return {form it}⊲ Return immediately, skipping any finally parts, withvalues of form or it.
{collect collecting} {form it} [into list ]⊲ Collect values of form or it into list . If no list isgiven, collect into an anonymous list which is returnedafter termination.
{append appending nconc nconcing} {form it} [into list ]⊲ Concatenate values of form or it, which should belists, into list by the means of
Fuappend or
Funconc, respec-
tively. If no list is given, collect into an anonymous listwhich is returned after termination.
{count counting} {form it} [into n ] [type]⊲ Count the number of times the value of form or of itis T. If no n is given, count into an anonymous variablewhich is returned after termination.
{sum summing} {form it} [into sum] [type]⊲ Calculate the sum of the primary values of form or ofit. If no sum is given, sum into an anonymous variablewhich is returned after termination.
{maximize maximizing minimize minimizing} {form it} [intomax-min] [type]⊲ Determine the maximum or minimum, respectively,of the primary values of form or of it. If no max-min
is given, use an anonymous variable which is returnedafter termination.
{initially finally} form+
⊲ Evaluate forms before begin, or after end, respec-tively, of iterations.
repeat num
⊲ TerminateMloop after num iterations; num is evalu-
ated once.
{while until} test⊲ Continue iteration until test returns NIL or T, respec-tively.
{always never} test⊲ Terminate
Mloop returning NIL and skipping any finally
parts as soon as test is NIL or T, respectively. Otherwisecontinue
Mloop with its default return value set to T.
thereis test
⊲ TerminateMloop when test is T and return value of test ,
skipping any finally parts. Otherwise continueMloop with
its default return value set to NIL.
(Mloop-finish)
⊲ TerminateMloop immediately executing any finally
clauses and returning any accumulated results.
10 CLOS
10.1 Classes
(Fuslot-exists-p foo bar) ⊲ T if foo has a slot bar .
(Fuslot-boundp instance slot) ⊲ T if slot in instance is bound.
(Mdefclass foo (superclass∗ standard-object )
23
Common Lisp Quick Reference
(Massert test
[(place∗) [
condition continue-arg∗
type {:initarg-name value}∗control arg∗
]
])
⊲ If test , which may depend on places, returns NIL, signalas correctable error condition or a new condition of type or,with
Fuformat control and args (see p. 36), error. When using
the debugger’s continue option, places can be altered beforere-evaluation of test . Return NIL.
(Mhandler-case foo (type ([var ]) (declare decl∗)∗ condition-form
P∗)∗
[(:no-error (ord-λ∗) (declare decl∗)∗ formP∗)])
⊲ If, on evaluation of foo, a condition of type is signalled,evaluate matching condition-forms with var bound to thecondition, and return their values. Without a condition,bind ord-λs to values of foo and return values of forms or,without a :no-error clause, return values of foo . See p. 16for (ord-λ∗).
(Mhandler-bind ((condition-type handler-function)∗) form
P∗)⊲ Return values of forms after evaluating them withcondition-types dynamically bound to their respectivehandler-functions of argument condition.
(Mwith-simple-restart (
{restart
NIL
}control arg∗) form
P∗)
⊲ Return values of forms unless restart is called duringtheir evaluation. In this case, describe restart using
Fuformat
control and args (see p. 36) and return NIL and2T.
(Mrestart-case form (foo (ord-λ∗)
∣∣∣∣∣∣∣∣
:interactive arg-function
:report
{report-function
string "foo"
:test test-function T
(declare decl∗)∗ restart-formP∗)∗)
⊲ Evaluate form with dynamically established restarts foo.Return values of form or, if by (
Fuinvoke-restart foo arg∗)
one restart foo is called, use string or report-function (ofa stream) to print a description of restart foo and returnthe values of its restart-forms. arg-function supplies ap-propriate args if foo is called by
Fuinvoke-restart-interactively.
If (test-function condition) returns T, foo is made visibleunder condition . arg∗ matches (ord-λ∗); see p. 16 for thelatter.
(Mrestart-bind ((
{restart
NIL
}restart-function
∣∣∣∣∣∣
:interactive-function function
:report-function function
:test-function function
)∗) form
P∗)
⊲ Return values of forms evaluated with restarts dynami-cally bound to restart-functions.
(Fuinvoke-restart restart arg∗)(
Fuinvoke-restart-interactively restart)
⊲ Call function associated with restart with argumentsgiven or prompted for, respectively. If restart function re-turns, return its values.
(
{ Fucompute-restartsFufind-restart name
}[condition ])
⊲ Return list of all restarts, or innermost restart name,respectively, out of those either associated with condition
or un-associated at all; or, without condition , out of allrestarts. Return NIL if search is unsuccessful.
(Furestart-name restart) ⊲ Name of restart .
(
FuabortFumuffle-warningFucontinueFustore-value valueFuuse-value value
[condition NIL ])
⊲ Transfer control to innermost applicable restart withsame name (i.e. abort, . . . , continue . . . ) out of thoseeither associated with condition or un-associated at all; or,without condition , out of all restarts. If no restart is found,signal control-error for
Fuabort and
Fumuffle-warning, or return
NIL for the rest.
28
Common Lisp Quick Reference
(gFslot-unbound class instance slot)
⊲ Called byFuslot-value in case of unbound slot . Its primary
method signals unbound-slot.
10.2 Generic Functions
(Funext-method-p)
⊲ T if enclosing method has a next method.
(Mdefgeneric
{foo
(setf foo)
}(required-var∗
[&optional
{var
(var)
}∗]
[&rest var
] [&key
{var
(var (:key var))
}∗
[&allow-other-keys]])
∣∣∣∣∣∣∣∣∣∣∣∣∣∣
(:argument-precedence-order required-var+)(declare (optimize arg∗)+)
(:documentation string)(:generic-function-class class standard-generic-function )
(:method-class class standard-method )(:method-combination c-type standard c-arg∗)(:method defmethod-args)∗
)
⊲ Define generic function foo. defmethod-args resemblethose of
Mdefmethod. For c-type see section 10.3.
(Fuensure-generic-function
{foo
(setf foo)
}
∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣
:argument-precedence-order required-var+
:declare (optimize arg∗)+
:documentation string
:generic-function-class class
:method-class class
:method-combination c-type c-arg∗
:lambda-list lambda-list
:environment environment
)
⊲ Define or modify generic function foo.:generic-function-class and :lambda-list have to be compat-ible with a pre-existing generic function or with existingmethods, respectively. Changes to :method-class do notpropagate to existing methods. For c-type see section 10.3.
(Mdefmethod
{foo
(setf foo)
}[
:before:after:aroundqualifier∗
primary method ]
(
var
(spec-var
{class
(eql bar)
})
∗[&optional
{var
(var[init [supplied-p]
])
}∗][&rest var ]
[&key
var
(
{var
(:key var)
}[init [supplied-p]
])
∗
[&allow-other-keys]]
[&aux
{var
(var [init ])
}∗])
{∣∣∣∣∣(declare decl∗)∗
doc
}form
P∗)
⊲ Define new method for generic function foo. spec-varsspecialize to either being of class or being eql bar , re-spectively. On invocation, vars and spec-vars of the newmethod act like parameters of a function with body form∗.forms are enclosed in an implicit
sOblock foo. Applicable
qualifiers depend on the method-combination type; see sec-tion 10.3.
(
{ gFadd-methodgFremove-method
}generic-function method)
⊲ Add (if necessary) or remove (if any) method to/fromgeneric-function.
(gFfind-method generic-function qualifiers specializers [error T ])
⊲ Return suitable method, or signal error.
(gFcompute-applicable-methods generic-function args)
⊲ List of methods suitable for args , most specific first.
25
Common Lisp Quick Reference
(Fucall-next-method arg∗ current args )
⊲ From within a method, call next method with args; re-turn its values.
(gFno-applicable-method generic-function arg∗)
⊲ Called on invocation of generic-function on args if thereis no applicable method. Default method signals error.
(
{ Fuinvalid-method-error methodFumethod-combination-error
}control arg∗)
⊲ Signal error on applicable method with invalid qualifiers,or on method combination. For control and args see format,p. 36.
(gFno-next-method generic-function method arg∗)
⊲ Called on invocation of call-next-method when there isno next method. Default method signals error.
(gFfunction-keywords method)
⊲ Return list of keyword parameters of method and2T if
other keys are allowed.
(gFmethod-qualifiers method) ⊲ List of qualifiers of method .
10.3 Method Combination Types
standard⊲ Evaluate most specific :around method supplying the val-ues of the generic function. From within this method,Fucall-next-method can call less specific :around methods ifthere are any. If not, or if there are no :around methodsat all, call all :before methods, most specific first, and themost specific primary method which supplies the values ofthe calling
Fucall-next-method if any, or of the generic func-
tion; and which can call less specific primary methods viaFucall-next-method. After its return, call all :after methods,least specific first.
and or append list nconc progn max min +⊲ Simple built-in method-combination types; have thesame usage as the c-types defined by the short form ofMdefine-method-combination.
(Mdefine-method-combination c-type
∣∣∣∣∣∣
:documentation string
:identity-with-one-argument bool NIL:operator operator c-type
)
⊲ Short Form. Define new method-combination c-type.In a generic function using c-type, evaluate most spe-cific :around method supplying the values of the genericfunction. From within this method,
Fucall-next-method
can call less specific :around methods if there are any.If not, or if there are no :around methods at all,return from the calling call-next-method or from thegeneric function, respectively, the values of (operator(primary-method gen-arg∗)∗), gen-arg∗ being the argu-ments of the generic function. The primary-method s are
ordered[{:most-specific-first
:most-specific-last
}:most-specific-first
](specified as
c-arg inMdefgeneric). Using c-type as the qualifier in
Mdefmethod makes the method primary.
(Mdefine-method-combination c-type (ord-λ∗) ((group
*(qualifier∗
[*])predicate
∣∣∣∣∣∣∣∣
:description control
:order
{:most-specific-first:most-specific-last
}:most-specific-first
:required bool
)∗)
∣∣∣∣∣∣∣∣
(:arguments method-combination-λ∗)(:generic-function symbol)
(declare decl∗)∗
doc
bodyP∗)
26
Common Lisp Quick Reference
⊲ Long Form. Define new method-combination c-type. Acall to a generic function using c-type will be equivalent toa call to the forms returned by body∗ with ord-λ∗ bound toc-arg∗ (cf.
Mdefgeneric), with symbol bound to the generic
function, with method-combination-λ∗ bound to the argu-ments of the generic function, and with groups bound tolists of methods. An applicable method becomes a mem-ber of the leftmost group whose predicate or qualifiersmatch. Methods can be called via
Mcall-method. Lambda
lists (ord-λ∗) and (method-combination-λ∗) according toord-λ on p. 16, the latter enhanced by an optional &wholeargument.
(Mcall-method
{method
(Mmake-method form)
}[(
{next-method
(Mmake-method form)
}∗)])
⊲ From within an effective method form, call method withthe arguments of the generic function and with informationabout its next-methods; return its values.
11 Conditions and Errors
For standardized condition types cf. Figure 2 on page 30.
(Mdefine-condition foo (parent-type∗ condition )
(
slot
(slot
∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣
{:reader reader}∗
{:writer{writer
(setf writer)
}}∗
{:accessor accessor}∗
:allocation
{:instance:class
}:instance
{:initarg :initarg-name}∗:initform form
:type type
:documentation slot-doc
)
∗
)
∣∣∣∣∣∣∣∣
(:default-initargs {name value}∗)(:documentation condition-doc)
(:report
{string
report-function
})
)
⊲ Define, as a subtype of parent-types, condition type foo.In a new condition, a slot ’s value defaults to form unless setvia :initarg-name ; it is readable via (reader i) or (accessori), and writeable via (writer value i) or (setf (accessor i)value). With :allocation :class, slot is shared by all condi-tions of type foo. A condition is reported by string or byreport-function of arguments condition and stream.
(Fumake-condition type {:initarg-name value}∗)
⊲ Return new condition of type .
(
FusignalFuwarnFuerror
condition
type {:initarg-name value}∗control arg∗
)
⊲ Unless handled, signal as condition, warning or error,respectively, condition or a new condition of type or,with
Fuformat control and args (see p. 36), simple-condition,
simple-warning, or simple-error, respectively. FromFusignal
andFuwarn, return NIL.
(Fucerror continue-control
condition continue-arg∗
type {:initarg-name value}∗control arg∗
)
⊲ Unless handled, signal as correctable error condition or anew condition of type or, with
Fuformat control and args (see
p. 36), simple-error. In the debugger, useFuformat arguments
continue-control and continue-args to tag the continue op-tion. Return NIL.
(Mignore-errors form
P∗)⊲ Return values of form s or, in case of errors, NIL and the
2condition.
(Fuinvoke-debugger condition)
⊲ Invoke debugger with condition .
27
Common Lisp Quick Reference
(Furead-delimited-list char
[stream var*standard-input* [recursive NIL ]
])
⊲ Continue reading until encountering char . Return list ofobjects read. Signal error if no char is found in stream.
(Furead-char
[stream var*standard-input* [
eof-err T [eof-val NIL
[recursive NIL ]]]])
⊲ Return next character from stream .
(Furead-char-no-hang
[stream var*standard-input* [
eof-error T [eof-val NIL
[recursive NIL ]]]])
⊲ Next character from stream or NIL if none is available.
(Fupeek-char
[mode NIL
[stream var*standard-input* [
eof-error T [eof-val NIL
[recursive NIL ]]]]]
)⊲ Next, or if mode is T, next non-whitespace character,or if mode is a character, next instance of it, from stream
without removing it there.
(Fuunread-char character [stream var*standard-input* ])
⊲ Put lastFuread-chared character back into stream ; return
NIL.
(Furead-byte stream
[eof-err T [eof-val NIL ]
])
⊲ Read next byte from binary stream.
(Furead-line
[stream var*standard-input* [
eof-err T [eof-val NIL
[recursive NIL ]]]])
⊲ Return a line of text from stream and2T if line has been
ended by end of file.
(Furead-sequence ˜sequence stream [:start start 0 ][:end end NIL ])
⊲ Replace elements of sequence between start and end withelements from binary or character stream . Return index ofsequence’s first unmodified element.
(Fureadtable-case readtable) :upcase
⊲ Case sensitivity attribute (one of :upcase, :downcase,:preserve, :invert) of readtable . setfable.
(Fucopy-readtable
[from-readtable var*readtable* [ ˜to-readtable NIL ]
])
⊲ Return copy of from-readtable .
(Fuset-syntax-from-char to-char from-char
[˜to-readtable var*readtable*
[from-readtable standard readtable ]])
⊲ Copy syntax of from-char to to-readtable . Return T.
var*readtable* ⊲ Current readtable.
var*read-base*10 ⊲ Radix for reading integers and ratios.
var*read-default-float-format*single-float
⊲ Floating point format to use when not indicated in thenumber read.
var*read-suppress*NIL
⊲ If T, reader is syntactically more tolerant.
(Fuset-macro-character char function
[non-term-p NIL [rt var*readtable* ]])
⊲ Make char a macro character associated with function
of stream and char . Return T.
(Fuget-macro-character char [rt var*readtable* ])
⊲ Reader macro function associated with char , and2T if
char is a non-terminating macro character.
(Fumake-dispatch-macro-character char
[non-term-p NIL
[rt var*readtable* ]])⊲ Make char a dispatching macro character. Return T.
(Fuset-dispatch-macro-character char sub-char function
[rt var*readtable* ])⊲ Make function of stream, n , sub-char a dispatch functionof char followed by n , followed by sub-char . Return T.
(Fuget-dispatch-macro-character char sub-char [rt var*readtable* ])
⊲ Dispatch function associated with char followed bysub-char .
32
Common Lisp Quick Reference
(Mwith-condition-restarts condition restarts form
P∗)⊲ Evaluate forms with restarts dynamically associatedwith condition . Return values of forms.
(Fuarithmetic-error-operation condition)(
Fuarithmetic-error-operands condition)
⊲ List of function or of its operands respectively, used inthe operation which caused condition .
(Fucell-error-name condition)
⊲ Name of cell which caused condition .
(Fuunbound-slot-instance condition)
⊲ Instance with unbound slot which caused condition .
(Fuprint-not-readable-object condition)
⊲ The object not readably printable under condition .
(Fupackage-error-package condition)(
Fufile-error-pathname condition)(
Fustream-error-stream condition)
⊲ Package, path, or stream, respectively, which caused thecondition of indicated type.
(Futype-error-datum condition)(
Futype-error-expected-type condition)
⊲ Object which caused condition of type type-error, or itsexpected type, respectively.
(Fusimple-condition-format-control condition)(
Fusimple-condition-format-arguments condition)
⊲ ReturnFuformat control or list of
Fuformat arguments, re-
spectively, of condition .
var*break-on-signals*NIL
⊲ Condition type debugger is to be invoked on.
var*debugger-hook*NIL
⊲ Function of condition and function itself. Called beforedebugger.
12 Types and Classes
For any class, there is always a corresponding type of the samename.
(Futypep foo type [environment NIL ]) ⊲ T if foo is of type.
(Fusubtypep type-a type-b [environment ])
⊲ Return T if type-a is a recognizable subtype of type-b,and
2NIL if the relationship could not be determined.
(sOthe type form) ⊲ Declare values of form to be of type.
(Fucoerce object type) ⊲ Coerce object into type.
(Mtypecase foo (type a-form
P∗)∗[(
{otherwiseT
}b-form NIL
P∗)])
⊲ Return values of the a-form s whose type is foo of. Returnvalues of b-forms if no type matches.
(
{MctypecaseMetypecase
}foo (type form
P∗)∗)
⊲ Return values of the form s whose type is foo of. Sig-nal correctable/non-correctable error, respectively if no type
matches.
(Futype-of foo) ⊲ Type of foo .
(Mcheck-type place type [string
{a an} type])
⊲ Signal correctable type-error if place is not of type. Re-turn NIL.
(Fustream-element-type stream) ⊲ Return type of stream objects.
(Fuarray-element-type array) ⊲ Element type array can hold.
29
Common Lisp Quick Reference
Tatom
readtable
package
symbol
keyw
ord
boolean
restart
random-state
hash-table
structure-object
standard-object
null
class
built-in-class
standard-class
structure-class
method
standard-m
ethod
method-combination
character
function[ arg-types[value-types]]
compiled-function
generic-function
standard-generic-function
pathname
logical-pathname
number
complex[type
*]real[ lo
wer-limit
*[upper-limit *]]
float[ lo
wer-limit
*[upper-limit *]]
short-float[ lo
wer-limit
*[upper-limit *]]
single-float[ lo
wer-limit
*[upper-limit *]]
double-float[ lo
wer-limit
*[upper-limit *]]
long-float[ lo
wer-limit
*[upper-limit *]]
rational[ lo
wer-limit
*[upper-limit *]]
integer[ lo
wer-limit
*[upper-limit *]]
ratio
signed-byte[size
*] fixnumbignum
unsigned-byte[size
*] bit
list
sequence
cons[ ca
r-type
*[cdr-type *]]
array[ ty
pe
*[rank *(dimension∗)]]
simple-array
[ type
*[rank *(dimension∗)]]
vector[ ty
pe
*[size *]]
string[size
*]simple-string[size
*]base-string[size
*]simple-base-string[size
*]simple-vector[size
*]bit-vector[size
*]simple-bit-vector[size
*]
stream
file-stream
two-w
ay-stream
synonym
-stream
string-stream
broadca
st-stream
conca
tenated-stream
ech
o-stream
extended-char
base-char
standard-char
condition
serious-co
ndition
storage-condition
simple-typ
e-error
type-error
error program-error
control-error
package-error
print-not-readable
stream-error
parse-error
cell-error
file-error
arithmetic-error
simple-condition
warning
style-w
arning
simple-error
simple-w
arning
end-of-file
reader-error
unbound-variable
undefined-function
unbound-slot
division-by-zero
floating-point-inexa
ct
floating-point-ove
rflow
floating-point-underflow
floating-point-inva
lid-operation
Figure 2: Precedence Order of System Classes ( ), Classes ( ),Types ( ), and Condition Types ( ).
30
Common Lisp Quick Reference
(Fuupgraded-array-element-type type [environment NIL ])
⊲ Element type of most specialized array capable of holdingelements of type.
(Mdeftype foo (macro-λ∗) (declare decl∗)∗ [doc] form
P∗)⊲ Define type foo which when referenced as (foo arg∗) ap-plies expanded forms to args returning the new type. For(macro-λ∗) see p. 18 but with default value of * instead ofNIL. forms are enclosed in an implicit
sOblock named foo.
(eql foo)(member foo∗)
⊲ Specifier for a type comprising foo or foos.
(satisfies predicate)⊲ Type specifier for all objects satisfying predicate .
(mod n) ⊲ Type specifier for all non-negative integers < n.
(not type) ⊲ Complement of type.
(and type∗ T ) ⊲ Type specifier for intersection of types.
(or type∗ NIL ) ⊲ Type specifier for union of types.
(values type∗[&optional type∗ [&rest other-args ]
])
⊲ Type specifier for multiple values.* ⊲ As a type argument (cf. Figure 2): no restriction.
13 Input/Output
13.1 Predicates
(Fustreamp foo)(
Fupathnamep foo)(
Fureadtablep foo)
⊲ T if foo is of indicated type.
(Fuinput-stream-p stream)(
Fuoutput-stream-p stream)(
Fuinteractive-stream-p stream)(
Fuopen-stream-p stream)
⊲ Return T if stream is for input, for output, interactive, oropen, respectively.
(Fupathname-match-p path wildcard)
⊲ T if path matches wildcard .
(Fuwild-pathname-p path
[{:host :device :directory :name :type
:version NIL}])
⊲ Return T if indicated component in path is wildcard. (NILindicates any component.)
13.2 Reader
(
{ Fuy-or-n-pFuyes-or-no-p
}[control arg∗])
⊲ Ask user a question and return T or NIL depending ontheir answer. See p. 36,
Fuformat, for control and args.
(Mwith-standard-io-syntax form
P∗)⊲ Evaluate forms with standard behaviour of reader andprinter. Return values of forms.
(
{ FureadFuread-preserving-whitespace
} [stream var*standard-input* [
eof-err T
[eof-val NIL [recursive NIL ]]]])
⊲ Read printed representation of object.
(Furead-from-string string
[eof-error T
[eof-val NIL
[
∣∣∣∣∣∣
:start start 0:end end NIL
:preserve-whitespace bool NIL
]]]
)
⊲ Return object read from string and zero-indexed2position
of next character.
31
Common Lisp Quick Reference
(Fuset-pprint-dispatch type function
[priority 0
[table var*print-pprint-dispatch* ]])⊲ Install entry comprising function of arguments streamand object to print; and priority as type into table. Iffunction is NIL, remove type from table. Return NIL.
(Fupprint-dispatch foo [table var*print-pprint-dispatch* ])
⊲ Return highest priority function associated with type offoo and
2T if there was a matching type specifier in table.
(Fucopy-pprint-dispatch [table var*print-pprint-dispatch* ])
⊲ Return copy of table or, if table is NIL, initial value ofvar*print-pprint-dispatch*.
var*print-pprint-dispatch* ⊲ Current pretty print dispatch table.
13.5 Format
(Mformatter control)
⊲ Return function of stream and a &rest argument applyingFuformat to stream, control , and the &rest argument return-ing NIL or any excess arguments.
(Fuformat {T NIL out-string out-stream} control arg∗)
⊲ Output string control which may contain ˜ directivespossibly taking some args. Alternatively, control can bea function returned by
Mformatter which is then applied to
out-stream and arg∗. Output to out-string, out-stream or,if first argument is T, to
var*standard-output*. Return NIL. Iffirst argument is NIL, return formatted output.
˜ [min-col 0 ][,[col-inc 1 ]
[,[min-pad 0 ]
[,pad-char ’
]]]
[:] [@] {A S}⊲ Aesthetic/Standard. Print argument of any type forconsumption by humans/by the reader, respectively.With :, print NIL as () rather than nil; with @, addpad-char s on the left rather than on the right.
˜ [radix 10 ][,[width]
[,[pad-char ’ ]
[,[comma-char ’, ][
,comma-interval 3]]]]
[:] [@] R⊲ Radix. (With one or more prefix arguments.)Print argument as number; with :, group digitscomma-interval each; with @, always prepend a sign.
{˜R ˜:R ˜@R ˜@:R}⊲ Roman. Take argument as number and print it asEnglish cardinal number, as English ordinal number, asRoman numeral, or as old Roman numeral, respectively.
˜ [width][,[pad-char ’ ]
[,[comma-char ’, ][
,comma-interval 3]]]
[:] [@] {D B O X}⊲ Decimal/Binary/Octal/Hexadecimal. Print integerargument as number. With :, group digitscomma-interval each; with @, always prepend a sign.
˜ [width][,[dec-digits]
[,[shift 0 ]
[,[overflow-char ][
,pad-char ’
]]]][@] F
⊲ Fixed-Format Floating-Point. With @, always pre-pend a sign.
˜ [width][,[int-digits]
[,[exp-digits]
[,[scale-factor 1 ][
,[overflow-char ][,[pad-char ’ ]
[,exp-char
]]]]]]
[@] {E G}⊲ Exponential/General Floating-Point. Print argumentas floating-point number with int-digits before decimalpoint and exp-digits in the signed exponent. With ˜G,choose either ˜E or ˜F. With @, always prepend a sign.
˜ [dec-digits 2 ][,[int-digits 1 ]
[,[width 0 ]
[,pad-char ’
]]][:]
[@] $⊲ Monetary Floating-Point. Print argument as fixed-format floating-point number. With :, put sign beforeany padding; with @, always prepend a sign.
{˜C ˜:C ˜@C ˜@:C}⊲ Character. Print, spell out, print in #\ syntax, ortell how to type, respectively, argument as (possiblynon-printing) character.
36
Common Lisp Quick Reference
13.3 Character Syntax
#| multi-line-comment∗ |#; one-line-comment∗
⊲ Comments. There are stylistic conventions:
;;;; title ⊲ Short title for a block of code.
;;; intro ⊲ Description before a block of code.
;; state ⊲ State of program or of following code.
;explanation; continuation
⊲ Regarding line on which it appears.
(foo∗[ . bar NIL ]) ⊲ List of foos with the terminating cdr bar .
” ⊲ Begin and end of a string.
’foo ⊲ (sOquote foo); foo unevaluated.
`([foo] [,bar ] [,@baz ] [,.quux ] [bing])⊲ Backquote.
sOquote foo and bing; evaluate bar and splice
the lists baz and quux into their elements. When nested,outermost commas inside the innermost backquote expres-sion belong to this backquote.
#\c ⊲ (Fucharacter "c"), the character c.
#Bn; #On ; n.; #Xn; #rRn⊲ Integer of radix 2, 8, 10, 16, or r ; 2 ≤ r ≤ 36.
n/d ⊲ The ratio nd.
{[m].n
[{S F D L E}x E0
]m[.[n ]
]{S F D L E}x
}
⊲ m.n · 10x as short-float, single-float, double-float,long-float, or the type from *read-default-float-format*.
#C(a b) ⊲ (Fucomplex a b), the complex number a + bi.
#’foo ⊲ (sOfunction foo); the function named foo.
#nAsequence ⊲ n-dimensional array.
#[n](foo∗)⊲ Vector of some (or n) foos filled with last foo if necessary.
#[n]*b∗⊲ Bit vector of some (or n) bs filled with last b if necessary.
#S(type {slot value}∗) ⊲ Structure of type.
#Pstring ⊲ A pathname.
#:foo ⊲ Uninterned symbol foo.
#.form ⊲ Read-time value of form .
var*read-eval*T ⊲ If NIL, a reader-error is signalled at #..
#integer= foo ⊲ Give foo the label integer .
#integer# ⊲ Object labelled integer .
#< ⊲ Have the reader signal reader-error.
#+feature when-feature
#–feature unless-feature
⊲ Means when-feature if feature is T; means unless-feature
if feature is NIL. feature is a symbol fromvar*features*, or
({and or} feature∗), or (not feature).
var*features*⊲ List of symbols denoting implementation-dependent fea-tures.
|c∗|; \c⊲ Treat arbitrary character(s) c as alphabetic preservingcase.
33
Common Lisp Quick Reference
13.4 Printer
(
Fuprin1FuprintFupprintFuprinc
foo [stream var*standard-output* ])⊲ Print foo to stream
Fureadably,
Fureadably between a newline
and a space,Fureadably after a newline, or human-readably
without any extra characters, respectively.Fuprin1,
Fuprint and
Fuprinc return foo.
(Fuprin1-to-string foo)(
Fuprinc-to-string foo)
⊲ Print foo to stringFureadably or human-readably, respec-
tively.
(gFprint-object object stream)
⊲ Print object to stream. Called by the Lisp printer.
(Mprint-unreadable-object (foo stream
{∣∣∣∣:type bool NIL:identity bool NIL
}) form
P∗)
⊲ Enclosed in #< and >, print foo by means of forms tostream . Return NIL.
(Futerpri [stream var*standard-output* ])
⊲ Output a newline to stream . Return NIL.
(Fufresh-line) [stream var*standard-output* ]
⊲ Output a newline to stream and return T unless stream
is already at the start of a line.
(Fuwrite-char char [stream var*standard-output* ])
⊲ Output char to stream .
(
{ Fuwrite-stringFuwrite-line
}string
[stream var*standard-output* [{∣∣∣∣
:start start 0:end end NIL
}]])
⊲ Write string to stream without/with a trailing newline.
(Fuwrite-byte byte stream) ⊲ Write byte to binary stream .
(Fuwrite-sequence sequence stream
{∣∣∣∣:start start 0:end end NIL
})
⊲ Write elements of sequence to binary or character stream.
(
{ FuwriteFuwrite-to-string
}foo
∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣
:array bool
:base radix
:case
:upcase:downcase:capitalize
:circle bool
:escape bool
:gensym bool
:length {int NIL}:level {int NIL}:lines {int NIL}:miser-width {int NIL}:pprint-dispatch dispatch-table
:pretty bool
:radix bool
:readably bool
:right-margin {int NIL}:stream stream var*standard-output*
)
⊲ Print foo to stream and return foo, or print foo intostring, respectively, after dynamically setting printer vari-ables corresponding to keyword parameters (*print-bar* be-coming :bar). (:stream keyword with
Fuwrite only.)
(Fupprint-fill stream foo
[parenthesis T [noop]
])
(Fupprint-tabular stream foo
[parenthesis T [noop [n 16 ]]
])
(Fupprint-linear stream foo
[parenthesis T [noop]
])
⊲ Print foo to stream. If foo is a list, print as many elementsper line as possible; do the same in a table with a columnwidth of n ems; or print either all elements on one line oreach on its own line, respectively. Return NIL. Usable withFuformat directive ˜//.
34
Common Lisp Quick Reference
(Mpprint-logical-block (stream list
∣∣∣∣∣∣
{:prefix string
:per-line-prefix string
}
:suffix string ""
)
(declare decl∗)∗ formP∗)
⊲ Evaluate forms, which should print list , with stream lo-cally bound to a pretty printing stream which outputs tothe original stream. If list is in fact not a list, it is printedby
Fuwrite. Return NIL.
(Mpprint-pop)
⊲ Take next element off list . If there is no remainingtail of list , or
var*print-length* orvar*print-circle* indicate
printing should end, send element together with an ap-propriate indicator to stream.
(Fupprint-tab
:line:line-relative:section:section-relative
c i [stream var*standard-output* ])⊲ Move cursor forward to column number c+ ki, k ≥ 0being as small as possible.
(Fupprint-indent
{:block:current
}n
[stream var*standard-output* ])
⊲ Specify indentation for innermost logical block rel-ative to leftmost position/to current position. ReturnNIL.
(Mpprint-exit-if-list-exhausted)
⊲ If list is empty, terminate logical block. Return NIL
otherwise.
(Fupprint-newline
:linear:fill:miser:mandatory
[stream var*standard-output* ])
⊲ Print a conditional newline if stream is a pretty printingstream. Return NIL.
var*print-array* ⊲ If T, print arraysFureadably.
var*print-base*10 ⊲ Radix for printing rationals, from 2 to 36.
var*print-case* :upcase
⊲ Print symbol names all uppercase (:upcase), all lowercase(:downcase), capitalized (:capitalize).
var*print-circle*NIL
⊲ If T, avoid indefinite recursion while printing circularstructure.
var*print-escape*T
⊲ If NIL, do not print escape characters and package pre-fixes.
var*print-gensym*T
⊲ If T, print #: before uninterned symbols.
var*print-length*NILvar*print-level*NILvar*print-lines*NIL
⊲ If integer, restrict printing of objects to that number ofelements per level/to that depth/to that number of lines.
var*print-miser-width*⊲ If integer and greater than the width available for print-ing a substructure, switch to the more compact miser style.
var*print-pretty* ⊲ If T, print pretty.
var*print-radix*NIL ⊲ If T, print rationals with a radix indicator.
var*print-readably*NIL
⊲ If T, printFureadably or signal error print-not-readable.
var*print-right-margin*NIL
⊲ Right margin width in ems while pretty-printing.
35
Common Lisp Quick Reference
13.7 Pathnames and Files
(Fumake-pathname
∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣
:host {host NIL :unspecific}:device {device NIL :unspecific}
:directory
{directory :wild NIL :unspecific}
(
{:absolute:relative
}
directory
:wild:wild-inferiors:up:back
∗
)
:name {file-name :wild NIL :unspecific}:type {file-type :wild NIL :unspecific}:version {:newest version :wild NIL :unspecific}:defaults path host from
var*default-pathname-defaults*:case {:local :common} :local
)
⊲ Construct pathname. For :case :local, leave case of com-ponents unchanged. For :case :common, leave mixed-casecomponents unchanged; convert all-uppercase componentsinto local customary case; do the opposite with all-lowercasecomponents.
(
Fupathname-hostFupathname-deviceFupathname-directoryFupathname-nameFupathname-type
path [:case
{:local:common
}:local ])
(Fupathname-version path)
⊲ Return pathname component.
(Fuparse-namestring foo
[host[
default-pathname var*default-pathname-defaults*
∣∣∣∣∣∣
:start start 0:end end NIL
:junk-allowed bool NIL
]])
⊲ Return pathname converted from string, pathname, orstream foo; and
2position where parsing stopped.
(Fumerge-pathnames pathname[
default-pathname var*default-pathname-defaults*[default-version :newest ]
])
⊲ Return pathname after filling in missing componentsfrom default-pathname .
var*default-pathname-defaults*⊲ Pathname to use if one is needed and none supplied.
(Fuuser-homedir-pathname [host ]) ⊲ User’s home directory.
(Fuenough-namestring path [root-path var*default-pathname-defaults* ])
⊲ Return minimal path string to sufficiently describe path
relative to root-path.
(Funamestring path)(
Fufile-namestring path)(
Fudirectory-namestring path)(
Fuhost-namestring path)
⊲ Return string representing full pathname; name, type,and version; directory name; or host name, respectively, ofpath .
(Futranslate-pathname path wildcard-path-a wildcard-path-b)
⊲ Translate path from wildcard-path-a into wildcard-path-b .Return new path.
(Fupathname path) ⊲ Pathname of path.
(Fulogical-pathname logical-path)
⊲ Logical pathname of logical-path . Logical pathnames are
represented as all-uppercase #P"[host:][:]{{{dir *}+**
};}∗
{name *}∗[.
{{type *}+LISP
}[.{version * newest NEWEST}]
]".
(Fulogical-pathname-translations logical-host )
⊲ List of (from-wildcard to-wildcard) translations forlogical-host . setfable.
40
Common Lisp Quick Reference
{˜( text ˜) ˜:( text ˜) ˜@( text ˜) ˜:@( text ˜)}⊲ Case-Conversion. Convert text to lowercase, convertfirst letter of each word to uppercase, capitalize firstword and convert the rest to lowercase, or convert touppercase, respectively.
{˜P ˜:P ˜@P ˜:@P}⊲ Plural. If argument eql 1 print nothing, otherwiseprint s; do the same for the previous argument; if ar-gument eql 1 print y, otherwise print ies; do the samefor the previous argument, respectively.
˜ [n 1 ] % ⊲ Newline. Print n newlines.
˜ [n 1 ] &⊲ Fresh-Line. Print n − 1 newlines if output stream isat the beginning of a line, or n newlines otherwise.
{˜ ˜: ˜@ ˜:@ }⊲ Conditional Newline. Print a newline likepprint-newline with argument :linear, :fill, :miser,or :mandatory, respectively.
{˜:← ˜@← ˜←}⊲ Ignored Newline. Ignore newline, or whitespace fol-lowing newline, or both, respectively.
˜ [n 1 ] | ⊲ Page. Print n page separators.
˜ [n 1 ] ˜ ⊲ Tilde. Print n tildes.
˜ [min-col 0 ][,[col-inc 1 ]
[,[min-pad 0 ]
[,pad-char ’
]]]
[:] [@] <[nl-text ˜[spare 0 [,width]]:;
]{text ˜;}∗ text
˜>⊲ Justification. Justify text produced by texts in a fieldof at least min-col columns. With :, right justify; with@, left justify. If this would leave less than spare char-acters on the current line, output nl-text first.
˜ [:] [@] <{[prefix "" ˜;] [per-line-prefix ˜@;]
}body
[˜;
suffix ""
]˜: [@] >
⊲ Logical Block. Act like pprint-logical-block using body
asFuformat control string on the elements of the list ar-
gument or, with @, on the remaining arguments, whichare extracted by pprint-pop. With :, prefix and suffix
default to ( and ). When closed by ˜:@>, spaces inbody are replaced with conditional newlines.
{˜ [n 0 ] i ˜ [n 0 ] :i}⊲ Indent. Set indentation to n relative to leftmost/tocurrent position.
˜ [c 1 ] [,i 1 ] [:] [@] T⊲ Tabulate. Move cursor forward to column numberc+ki, k ≥ 0 being as small as possible. With :, calculatecolumn numbers relative to the immediately enclosingsection. With @, move to column number c0 + c + kiwhere c0 is the current position.
{˜ [m 1 ] * ˜ [m 1 ] :* ˜ [n 0 ] @*}⊲ Go-To. Jump m arguments forward, or backward, orto argument n.
˜ [limit ] [:] [@] { text ˜}⊲ Iteration. Use text repeatedly, up to limit , as controlstring for the elements of the list argument or (with @)for the remaining arguments. With : or :@, list elementsor remaining arguments should be lists of which a newone is used at each iteration step.
˜[x[,y [,z ]
]]ˆ
⊲ Escape Upward. Leave immediately ˜< ˜>,
˜< ˜:>, ˜{ ˜}, ˜?, or the entireFuformat operation.
With one to three prefixes, act only if x = 0, x = y, orx ≤ y ≤ z, respectively.
˜ [i ] [:] [@] [ [{text ˜;}∗ text] [˜:; default ] ˜]⊲ Conditional Expression. Use the zero-indexed argu-menth (or ith if given) text as a
Fuformat control sub-
clause. With :, use the first text if the argument valueis NIL, or the second text if it is T. With @, do nothingfor an argument value of NIL. Use the only text andleave the argument to be read again if it is T.
37
Common Lisp Quick Reference
˜ [@] ?⊲ Recursive Processing. Process two arguments as con-trol string and argument list. With @, take one ar-gument as control string and use then the rest of theoriginal arguments.
˜[prefix {,prefix}∗
][:] [@] /
[package :[:]cl-user:
]function/
⊲ Call Function. Call all-uppercase package::functionwith the arguments stream, format-argument, colon-p,at-sign-p and prefixes for printing format-argument.
˜ [:] [@] W⊲ Write. Print argument of any type obeying everyprinter control variable. With :, pretty-print. With@, print without limits on length or depth.
{V #}⊲ In place of the comma-separated prefix parameters:use next argument or number of remaining unprocessedarguments, respectively.
13.6 Streams
(Fuopen path
∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣
:direction
:input:output:io:probe
:input
:element-type
{type
:default
}character
:if-exists
:new-version:error:rename:rename-and-delete:overwrite:append:supersedeNIL
:new-version if pathspecifies :newest;NIL otherwise
:if-does-not-exist
:error:createNIL
NIL for :direction :probe;
{:create :error} otherwise
:external-format format :default
)
⊲ Open file-stream to path .
(Fumake-concatenated-stream input-stream∗)(
Fumake-broadcast-stream output-stream∗)(
Fumake-two-way-stream input-stream-part output-stream-part )(
Fumake-echo-stream from-input-stream to-output-stream)(
Fumake-synonym-stream variable-bound-to-stream)
⊲ Return stream of indicated type.
(Fumake-string-input-stream string
[start 0 [end NIL ]
])
⊲ Return a string-stream supplying the characters fromstring .
(Fumake-string-output-stream [:element-type type character ])
⊲ Return a string-stream accepting characters (available viaFuget-output-stream-string).
(Fuconcatenated-stream-streams concatenated-stream)(
Fubroadcast-stream-streams broadcast-stream )
⊲ Return list of streams concatenated-stream still has toread from/broadcast-stream is broadcasting to.
(Futwo-way-stream-input-stream two-way-stream)(
Futwo-way-stream-output-stream two-way-stream)(
Fuecho-stream-input-stream echo-stream)(
Fuecho-stream-output-stream echo-stream)
⊲ Return source stream or sink stream of two-way-stream/echo-stream , respectively.
(Fusynonym-stream-symbol synonym-stream)
⊲ Return symbol of synonym-stream.
(Fuget-output-stream-string ˜string-stream)
⊲ Clear and return as a string characters on string-stream.
38
Common Lisp Quick Reference
(Fufile-position stream [
:start:endposition
])
⊲ Return position within stream, or set it to position andreturn T on success.
(Fufile-string-length stream foo)
⊲ Length foo would have in stream.
(Fulisten [stream var*standard-input* ])
⊲ T if there is a character in input stream .
(Fuclear-input [stream var*standard-input* ])
⊲ Clear input from stream , return NIL.
(
Fuclear-outputFuforce-outputFufinish-output
[stream var*standard-output* ])
⊲ End output to stream and return NIL immediately, afterinitiating flushing of buffers, or after flushing of buffers,respectively.
(Fuclose stream [:abort bool NIL ])
⊲ Close stream . Return T if stream had been open. If :abortis T, delete associated file.
(Mwith-open-file (stream path open-arg∗) (declare decl∗)∗ form
P∗)⊲ Use
Fuopen with open-args to temporarily create stream to
path; return values of forms.
(Mwith-open-stream (foo stream) (declare decl∗)∗ form
P∗)⊲ Evaluate forms with foo locally bound to stream . Returnvalues of forms.
(Mwith-input-from-string (foo string
∣∣∣∣∣∣
:index index
:start start 0:end end NIL
) (declare
decl∗)∗ formP∗)
⊲ Evaluate forms with foo locally bound to inputstring-stream from string. Return values of forms; storenext reading position into index .
(Mwith-output-to-string (foo
[string NIL [:element-type
type character ]]) (declare decl∗)∗ form
P∗)⊲ Evaluate forms with foo locally bound to an outputstring-stream. Append output to string and return valuesof forms if string is given. Return string containing outputotherwise.
(Fustream-external-format stream)
⊲ External file format designator.
var*terminal-io* ⊲ Bidirectional stream to user terminal.
var*standard-input*var*standard-output*var*error-output*
⊲ Standard input stream, standard output stream, or stan-dard error output stream, respectively.
var*debug-io*var*query-io*
⊲ Bidirectional streams for debugging and user interaction.
39
Common Lisp Quick Reference
(Fucompile-file file
∣∣∣∣∣∣∣∣
:output-file out-path
:verbose bool var*compile-verbose*:print bool var*compile-print*:external-format file-format :default
)
⊲ Write compiled contents of file to out-path. Return trueoutput path or NIL,
2T in case of warnings or errors,
3T in case
of warnings or errors excluding style warnings.
(Fucompile-file-pathname file [:output-file path ] [other-keyargs])
⊲ PathnameFucompile-file writes to if invoked with the same
arguments.
(Fuload path
∣∣∣∣∣∣∣∣
:verbose bool var*load-verbose*:print bool var*load-print*:if-does-not-exist bool T:external-format file-format :default
)
⊲ Load source file or compiled file into Lisp environment.Return T if successful.
var*compile-filevar*load }
-
{pathname*NIL
truename*NIL
⊲ Input file used byFucompile-file/by
Fuload.
var*compilevar*load }
-
{print*verbose*
⊲ Defaults used byFucompile-file/by
Fuload.
(sOeval-when (
∣∣∣∣∣∣
{:compile-toplevel compile}{:load-toplevel load}{:execute eval}
) form
P∗)
⊲ Return values of forms ifsOeval-when is in the top-level of a
file being compiled, in the top-level of a compiled file beingloaded, or anywhere, respectively. Return NIL if forms arenot evaluated. (compile, load and eval deprecated.)
(sOlocally (declare decl∗)∗ form
P∗)⊲ Evaluate forms in a lexical environment with declarationsdecl in effect. Return values of forms.
(Mwith-compilation-unit ([:override bool NIL ]) form
P∗)⊲ Return values of forms. Warnings deferred by the com-piler until end of compilation are deferred until the end ofevaluation of forms.
(sOload-time-value form [ read-only NIL ])
⊲ Evaluate form at compile time and treat its value as lit-eral at run time.
(sOquote foo) ⊲ Return unevaluated foo.
(gFmake-load-form foo [environment ])
⊲ Its methods are to return a creation form which on eval-uation at
Fuload time returns an object equivalent to foo, and
an optional2initialization form which on evaluation performs
some initialization of the object.
(Fumake-load-form-saving-slots foo
{∣∣∣∣:slot-names slots all local slots
:environment environment
})
⊲ Return a creation form and an2initialization form which
on evaluation construct an object equivalent to foo withslots initialized with the corresponding values from foo.
(Fumacro-function symbol [environment ])
(Fucompiler-macro-function
{name
(setf name)
}[environment ])
⊲ Return specified macro function, or compiler macro func-tion, respectively, if any. Return NIL otherwise. setfable.
(Fueval arg)
⊲ Return values of value of arg evaluated in global environ-ment.
44
Common Lisp Quick Reference
(Fuload-logical-pathname-translations logical-host )
⊲ Load logical-host ’s translations. Return NIL if alreadyloaded; return T if successful.
(Futranslate-logical-pathname pathname)
⊲ Physical pathname corresponding to (possibly logical)pathname .
(Fuprobe-file file)(
Futruename file)
⊲ Canonical name of file. If file does not exist, returnNIL/signal file-error, respectively.
(Fufile-write-date file) ⊲ Time at which file was last written.
(Fufile-author file) ⊲ Return name of file owner.
(Fufile-length stream) ⊲ Return length of stream .
(Furename-file foo bar)
⊲ Rename file foo to bar . Unspecified components of pathbar default to those of foo. Return new pathname,
2old
physical file name, and3new physical file name.
(Fudelete-file file) ⊲ Delete file. Return T.
(Fudirectory path) ⊲ List of pathnames matching path .
(Fuensure-directories-exist path [:verbose bool ])
⊲ Create parts of path if necessary. Second return value is
2T if something has been created.
14 Packages and Symbols
14.1 Predicates
(Fusymbolp foo)(
Fupackagep foo)(
Fukeywordp foo)
⊲ T if foo is of indicated type.
14.2 Packages
:bar keyword:bar ⊲ Keyword, evaluates to :bar .
package :symbol ⊲ Exported symbol of package .
package ::symbol ⊲ Possibly unexported symbol of package .
(Mdefpackage foo
∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣∣
(:nicknames nick∗)∗
(:documentation string)(:intern interned-symbol∗)∗
(:use used-package∗)∗
(:import-from pkg imported-symbol∗)∗
(:shadowing-import-from pkg shd-symbol∗)∗
(:shadow shd-symbol∗)∗
(:export exported-symbol∗)∗
(:size int)
)
⊲ Create or modify package foo with interned-symbols,symbols from used-packages, imported-symbols, andshd-symbols. Add shd-symbols to foo’s shadowing list.
(Fumake-package foo
{∣∣∣∣:nicknames (nick∗)NIL:use (used-package∗)
})
⊲ Create package foo .
(Furename-package package new-name [new-nicknames NIL ])
⊲ Rename package . Return renamed package.
(Min-package foo) ⊲ Make package foo current.
(
{ Fuuse-packageFuunuse-package
}other-packages [package var*package* ])
⊲ Make exported symbols of other-packages available inpackage, or remove them from package , respectively. Re-turn T.
41
Common Lisp Quick Reference
(Fupackage-use-list package)(
Fupackage-used-by-list package)
⊲ List of other packages used by/using package .
(Fudelete-package ˜package)
⊲ Delete package . Return T if successful.
var*package*common-lisp-user ⊲ The current package.
(Fulist-all-packages) ⊲ List of registered packages.
(Fupackage-name package) ⊲ Name of package .
(Fupackage-nicknames package) ⊲ List of nicknames of package .
(Fufind-package name) ⊲ Package with name (case-sensitive).
(Fufind-all-symbols foo)
⊲ List of symbols foo from all registered packages.
(
{ FuinternFufind-symbol
}foo [package var*package* ])
⊲ Intern or find, respectively, symbol foo in package . Sec-ond return value is one of
2:internal,
2:external, or
2:inherited
(or2NIL if
Fuintern created a fresh symbol).
(Fuunintern symbol [package var*package* ])
⊲ Remove symbol from package , return T on success.
(
{ FuimportFushadowing-import
}symbols [package var*package* ])
⊲ Make symbols internal to package . Return T. In case ofa name conflict signal correctable package-error or shadowthe old symbol, respectively.
(Fushadow symbols [package var*package* ])
⊲ Make symbols of package shadow any otherwise accessi-ble, equally named symbols from other packages. ReturnT.
(Fupackage-shadowing-symbols package)
⊲ List of symbols of package that shadow any otherwiseaccessible, equally named symbols from other packages.
(Fuexport symbols [package var*package* ])
⊲ Make symbols external to package . Return T.
(Fuunexport symbols [package var*package* ])
⊲ Revert symbols to internal status. Return T.
(
Mdo-symbolsMdo-external-symbols
}(var
[package var*package* [result NIL ]
])
Mdo-all-symbols (var [result NIL ])
(declare decl∗)∗{∣∣∣∣tag
form
}∗)
⊲ EvaluatesOtagbody-like body with var successively bound
to every symbol from package , to every external symbolfrom package , or to every symbol from all registered pack-ages, respectively. Return values of result . Implicitly, thewhole form is a
sOblock named NIL.
(Mwith-package-iterator (foo packages [:internal :external :inherited])
(declare decl∗)∗ formP∗)
⊲ Return values of forms. In forms, successive invocationsof (foo) return: T if a symbol is returned; a symbol frompackages ; accessibility (:internal, :external, or :inherited);and the package the symbol belongs to.
(Furequire module [paths NIL ])
⊲ If not invar*modules*, try paths to load module from. Sig-
nal error if unsuccessful. Deprecated.
(Fuprovide module)
⊲ If not already there, add module tovar*modules*. Depre-
cated.var*modules* ⊲ List of names of loaded modules.
42
Common Lisp Quick Reference
14.3 Symbols
A symbol has the attributes name, home package, property list, andoptionally value (of global constant or variable name) and function(function, macro, or special operator name).
(Fumake-symbol name)
⊲ Make fresh, uninterned symbol name .
(Fugensym [s G ])
⊲ Return fresh, uninterned symbol #:sn with n fromvar*gensym-counter*. Increment
var*gensym-counter*.(
Fugentemp
[prefix T [package var*package* ]])
⊲ Intern fresh symbol in package. Deprecated.
(Fucopy-symbol symbol [props NIL ])
⊲ Return uninterned copy of symbol . If props is T, givecopy the same value, function and property list.
(Fusymbol-name symbol)(
Fusymbol-package symbol)(
Fusymbol-plist symbol)(
Fusymbol-value symbol)(
Fusymbol-function symbol)
⊲ Name, package, property list, value, or function, respec-tively, of symbol . setfable.
(
{ gFdocumentation(setf
gFdocumentation) new-doc
}foo
’variable ’function’compiler-macro’method-combination
’structure ’type ’setf T
)
⊲ Get/set documentation string of foo of given type.
cot
⊲ Truth; the supertype of every type including t; the su-perclass of every class except t;
var*terminal-io*.conil
co()
⊲ Falsity; the empty list; the empty type, subtype of ev-ery type;
var*standard-input*; var*standard-output*; the globalenvironment.
14.4 Standard Packages
common-lisp cl⊲ Exports the defined names of Common Lisp except forthose in the keyword package.
common-lisp-user cl-user⊲ Current package after startup; uses package common-lisp.
keyword⊲ Contains symbols which are defined to be of typekeyword.
15 Compiler
15.1 Predicates
(Fuspecial-operator-p foo) ⊲ T if foo is a special operator.
(Fucompiled-function-p foo)
⊲ T if foo is of type compiled-function.
15.2 Compilation
(Fucompile
NIL definition{name
(setf name)
}[definition ]
)
⊲ Return compiled function or replace name ’s function def-inition with the compiled function. Return
2T in case of
warnings or errors, and3T in case of warnings or errors ex-
cluding style warnings.
43
Common Lisp Quick Reference
DOUBLE-FLOAT-NEGATIVE-EPSILON6
DOWNFROM 21DOWNTO 21DPB 5DRIBBLE 45DYNAMIC-EXTENT 46
EACH 21ECASE 19ECHO-STREAM 30ECHO-STREAM-
INPUT-STREAM 38ECHO-STREAM-
OUTPUT-STREAM38
ED 45EIGHTH 8ELSE 23ELT 12ENCODE-UNIVERSAL-
TIME 46END 23END-OF-FILE 30ENDP 8ENOUGH-
NAMESTRING 40ENSURE-
DIRECTORIES-EXIST 41
ENSURE-GENERIC-FUNCTION 25
EQ 15EQL 15, 31EQUAL 15EQUALP 15ERROR 27, 30ETYPECASE 29EVAL 44EVAL-WHEN 44EVENP 3EVERY 12EXP 3EXPORT 42EXPT 3EXTENDED-CHAR 30EXTERNAL-SYMBOL
21EXTERNAL-SYMBOLS
21
FBOUNDP 16FCEILING 4FDEFINITION 17FFLOOR 4FIFTH 8FILE-AUTHOR 41FILE-ERROR 30FILE-ERROR-
PATHNAME 29FILE-LENGTH 41FILE-NAMESTRING 40FILE-POSITION 39FILE-STREAM 30FILE-STRING-LENGTH
39FILE-WRITE-DATE 41FILL 12FILL-POINTER 11FINALLY 23FIND 13FIND-ALL-SYMBOLS
42FIND-CLASS 24FIND-IF 13FIND-IF-NOT 13FIND-METHOD 25FIND-PACKAGE 42FIND-RESTART 28FIND-SYMBOL 42FINISH-OUTPUT 39FIRST 8FIXNUM 30FLET 17FLOAT 4, 30FLOAT-DIGITS 6FLOAT-PRECISION 6FLOAT-RADIX 6FLOAT-SIGN 4FLOATING-
POINT-INEXACT 30FLOATING-
POINT-INVALID-OPERATION 30
FLOATING-POINT-OVERFLOW 30
FLOATING-POINT-UNDERFLOW 30
FLOATP 3FLOOR 4FMAKUNBOUND 17FOR 21FORCE-OUTPUT 39FORMAT 36FORMATTER 36FOURTH 8FRESH-LINE 34FROM 21FROUND 4FTRUNCATE 4FTYPE 46FUNCALL 17FUNCTION
17, 30, 33, 43FUNCTION-
KEYWORDS 26
FUNCTION-LAMBDA-EXPRESSION 17
FUNCTIONP 15
GCD 3GENERIC-FUNCTION
30GENSYM 43GENTEMP 43GET 16GET-DECODED-TIME
46GET-
DISPATCH-MACRO-CHARACTER 32
GET-INTERNAL-REAL-TIME 46
GET-INTERNAL-RUN-TIME 46
GET-MACRO-CHARACTER 32
GET-OUTPUT-STREAM-STRING 38
GET-PROPERTIES 16GET-SETF-
EXPANSION 19GET-UNIVERSAL-
TIME 46GETF 16GETHASH 14GO 20GRAPHIC-CHAR-P 6
HANDLER-BIND 28HANDLER-CASE 28HASH-KEY 21HASH-KEYS 21HASH-TABLE 30HASH-TABLE-COUNT
14HASH-TABLE-P 14HASH-TABLE-
REHASH-SIZE 14HASH-
TABLE-REHASH-THRESHOLD 14
HASH-TABLE-SIZE 14HASH-TABLE-TEST 14HASH-VALUE 21HASH-VALUES 21HOST-NAMESTRING
40
IDENTITY 17IF 19, 23IGNORABLE 46IGNORE 46IGNORE-ERRORS 27IMAGPART 4IMPORT 42IN 21IN-PACKAGE 41INCF 3INITIALIZE-INSTANCE
24INITIALLY 23INLINE 46INPUT-STREAM-P 31INSPECT 45INTEGER 30INTEGER-
DECODE-FLOAT 6INTEGER-LENGTH 5INTEGERP 3INTERACTIVE-
STREAM-P 31INTERN 42INTERNAL-
TIME-UNITS-PER-SECOND 46
INTERSECTION 10INTO 23INVALID-METHOD-
ERROR 26INVOKE-DEBUGGER
27INVOKE-RESTART 28INVOKE-RESTART-
INTERACTIVELY 28ISQRT 3IT 23
KEYWORD 30, 41, 43KEYWORDP 41
LABELS 17LAMBDA 17LAMBDA-LIST-
KEYWORDS 19LAMBDA-
PARAMETERS-LIMIT 17
LAST 8LCM 3LDB 5LDB-TEST 5LDIFF 9LEAST-NEGATIVE-
DOUBLE-FLOAT 6LEAST-NEGATIVE-
LONG-FLOAT 6LEAST-NEGATIVE-
NORMALIZED-DOUBLE-FLOAT 6
LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT 6
LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT 6
LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT 6
LEAST-NEGATIVE-SHORT-FLOAT 6
LEAST-NEGATIVE-SINGLE-FLOAT 6
LEAST-POSITIVE-DOUBLE-FLOAT 6
LEAST-POSITIVE-LONG-FLOAT 6
LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT 6
LEAST-POSITIVE-NORMALIZED-LONG-FLOAT 6
LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT 6
LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT 6
LEAST-POSITIVE-SHORT-FLOAT 6
LEAST-POSITIVE-SINGLE-FLOAT 6
LENGTH 12LET 20LET* 20LISP-
IMPLEMENTATION-TYPE 46
LISP-IMPLEMENTATION-VERSION 46
LIST 8, 26, 30LIST-ALL-PACKAGES
42LIST-LENGTH 8LIST* 8LISTEN 39LISTP 8LOAD 44LOAD-LOGICAL-
PATHNAME-TRANSLATIONS 41
LOAD-TIME-VALUE 44LOCALLY 44LOG 3LOGAND 5LOGANDC1 5LOGANDC2 5LOGBITP 5LOGCOUNT 5LOGEQV 5LOGICAL-PATHNAME
30, 40LOGICAL-PATHNAME-
TRANSLATIONS 40LOGIOR 5LOGNAND 5LOGNOR 5LOGNOT 5LOGORC1 5LOGORC2 5LOGTEST 5LOGXOR 5LONG-FLOAT 30, 33LONG-
FLOAT-EPSILON 6LONG-FLOAT-
NEGATIVE-EPSILON6
LONG-SITE-NAME 46LOOP 21LOOP-FINISH 23LOWER-CASE-P 6
MACHINE-INSTANCE46
MACHINE-TYPE 46MACHINE-VERSION 46MACRO-FUNCTION 44MACROEXPAND 45MACROEXPAND-1 45MACROLET 18MAKE-ARRAY 10MAKE-BROADCAST-
STREAM 38MAKE-
CONCATENATED-STREAM 38
MAKE-CONDITION 27MAKE-
DISPATCH-MACRO-CHARACTER 32
MAKE-ECHO-STREAM 38
MAKE-HASH-TABLE14
MAKE-INSTANCE 24MAKE-INSTANCES-
OBSOLETE 24MAKE-LIST 8MAKE-LOAD-FORM 44MAKE-LOAD-FORM-
SAVING-SLOTS 44MAKE-METHOD 27MAKE-PACKAGE 41MAKE-PATHNAME 40MAKE-
RANDOM-STATE 4MAKE-SEQUENCE 12MAKE-STRING 7
MAKE-STRING-INPUT-STREAM 38
MAKE-STRING-OUTPUT-STREAM38
MAKE-SYMBOL 43MAKE-SYNONYM-
STREAM 38MAKE-TWO-
WAY-STREAM 38MAKUNBOUND 16MAP 14MAP-INTO 14MAPC 9MAPCAN 9MAPCAR 9MAPCON 9MAPHASH 14MAPL 9MAPLIST 9MASK-FIELD 5MAX 4, 26MAXIMIZE 23MAXIMIZING 23MEMBER 8, 31MEMBER-IF 8MEMBER-IF-NOT 8MERGE 12MERGE-PATHNAMES
40METHOD 30METHOD-
COMBINATION30, 43
METHOD-COMBINATION-ERROR 26
METHOD-QUALIFIERS 26
MIN 4, 26MINIMIZE 23MINIMIZING 23MINUSP 3MISMATCH 12MOD 4, 31MOST-NEGATIVE-
DOUBLE-FLOAT 6MOST-NEGATIVE-
FIXNUM 6MOST-NEGATIVE-
LONG-FLOAT 6MOST-NEGATIVE-
SHORT-FLOAT 6MOST-NEGATIVE-
SINGLE-FLOAT 6MOST-POSITIVE-
DOUBLE-FLOAT 6MOST-POSITIVE-
FIXNUM 6MOST-POSITIVE-
LONG-FLOAT 6MOST-POSITIVE-
SHORT-FLOAT 6MOST-POSITIVE-
SINGLE-FLOAT 6MUFFLE-WARNING 28MULTIPLE-
VALUE-BIND 20MULTIPLE-
VALUE-CALL 17MULTIPLE-
VALUE-LIST 17MULTIPLE-
VALUE-PROG1 20MULTIPLE-
VALUE-SETQ 16MULTIPLE-
VALUES-LIMIT 17
NAME-CHAR 7NAMED 21NAMESTRING 40NBUTLAST 9NCONC 9, 23, 26NCONCING 23NEVER 23NEWLINE 6NEXT-METHOD-P 25NIL 2, 43NINTERSECTION 10NINTH 8NO-APPLICABLE-
METHOD 26NO-NEXT-METHOD
26NOT 15, 31, 33NOTANY 12NOTEVERY 12NOTINLINE 46NRECONC 9NREVERSE 12NSET-DIFFERENCE 10NSET-EXCLUSIVE-OR
10NSTRING-CAPITALIZE
7NSTRING-DOWNCASE
7NSTRING-UPCASE 7NSUBLIS 10NSUBST 10NSUBST-IF 10NSUBST-IF-NOT 10NSUBSTITUTE 13NSUBSTITUTE-IF 13NSUBSTITUTE-
IF-NOT 13NTH 8NTH-VALUE 17
48
Common Lisp Quick Reference
15.3 REPL and Debugging
var+
var++
var+++
var* var** var***var/
var//
var///⊲ Last, penultimate, or antepenultimate form evaluatedin the REPL, or their respective primary value, or a list oftheir respective values.
var– ⊲ Form currently being evaluated by the REPL.
(Fuapropos string [package NIL ])
⊲ Print interned symbols containing string.
(Fuapropos-list string [package NIL ])
⊲ List of interned symbols containing string.
(Fudribble [path ])
⊲ Save a record of interactive session to file at path . With-out path , close that file.
(Fued [file-or-function NIL ]) ⊲ Invoke editor if possible.
(
{ Fumacroexpand-1Fumacroexpand
}form [environment NIL ])
⊲ Return macro expansion, once or entirely, respectively,of form and
2T if form was a macro form. Return form and
2NIL otherwise.
var*macroexpand-hook*⊲ Function of arguments expansion function, macro form,and environment called by
Fumacroexpand-1 to generate
macro expansions.
(Mtrace
{function
(setf function)
}∗)
⊲ Cause functions to be traced. With no arguments, returnlist of traced functions.
(Muntrace
{function
(setf function)
}∗)
⊲ Stop functions, or each currently traced function, frombeing traced.
var*trace-output*⊲ Stream
Mtrace and
Mtime print their output on.
(Mstep form)
⊲ Step through evaluation of form. Return values of form .
(Fubreak [control arg∗])
⊲ Jump directly into debugger; return NIL. See p. 36,Fuformat, for control and args.
(Mtime form)
⊲ Evaluate forms and print timing information tovar*trace-output*. Return values of form .
(Fuinspect foo) ⊲ Interactively give information about foo.
(Fudescribe foo [stream var*standard-output* ])
⊲ Send information about foo to stream.
(gFdescribe-object foo [stream])
⊲ Send information about foo to stream . Not to be calledby user.
(Fudisassemble function)
⊲ Send disassembled representation of function tovar*standard-output*. Return NIL.
45
Common Lisp Quick Reference
15.4 Declarations
(Fuproclaim decl)
(Mdeclaim decl∗)
⊲ Globally make declaration(s) decl . decl can be:declaration, type, ftype, inline, notinline, optimize, orspecial. See below.
(declare decl∗)⊲ Inside certain forms, locally make declarations decl∗.decl can be: dynamic-extent, type, ftype, ignorable, ignore,inline, notinline, optimize, or special. See below.
(declaration foo∗)⊲ Make foos names of declarations.
(dynamic-extent variable∗ (sOfunction function)∗)
⊲ Declare lifetime of variables and/or functions to endwhen control leaves enclosing block.
([type] type variable∗)(ftype type function∗)
⊲ Declare variables or functions to be of type.
(
{ignorableignore
} {var
(sOfunction function)
}∗)
⊲ Suppress warnings about used/unused bindings.
(inline function∗)(notinline function∗)
⊲ Tell compiler to integrate/not to integrate, respec-tively, called functions into the calling routine.
(optimize
∣∣∣∣∣∣∣∣∣∣
compilation-speed (compilation-speed n 3 )
debug (debug n 3 )
safety (safety n 3 )
space (space n 3 )
speed (speed n 3 )
)
⊲ Tell compiler how to optimize. n = 0 means unim-portant, n = 1 is neutral, n = 3 means important.
(special var∗) ⊲ Declare vars to be dynamic.
16 External Environment
(Fuget-internal-real-time)(
Fuget-internal-run-time)
⊲ Current time, or computing time, respectively, in clockticks.
cointernal-time-units-per-second
⊲ Number of clock ticks per second.
(Fuencode-universal-time sec min hour date month year [zone curr ])(
Fuget-universal-time)
⊲ Seconds from 1900-01-01, 00:00, ignoring leap seconds.
(Fudecode-universal-time universal-time [time-zone current ])(
Fuget-decoded-time)
⊲ Return second,2minute,
3hour,
4date,
5month,
6year,
7day,
8daylight-p, and
9zone.
(Furoom [{NIL :default T}])
⊲ Print information about internal storage management.
(Fushort-site-name)(
Fulong-site-name)
⊲ String representing physical location of computer.
(
Fulisp-implementationFusoftwareFumachine
-
{typeversion
})
⊲ Name or version of implementation, operating system, orhardware, respectively.
(Fumachine-instance) ⊲ Computer name.
46
Common Lisp Quick Reference
Index” 33’ 33( 33() 43) 33* 3, 30, 31, 40, 45** 40, 45*** 45*BREAK-
ON-SIGNALS* 29*COMPILE-FILE-PATHNAME* 44*COMPILE-FILE-TRUENAME* 44*COMPILE-PRINT* 44*COMPILE-VERBOSE* 44*DEBUG-IO* 39*DEBUGGER-HOOK*29*DEFAULT-PATHNAME-DEFAULTS* 40*ERROR-OUTPUT* 39*FEATURES* 33*GENSYM-COUNTER* 43*LOAD-PATHNAME*44*LOAD-PRINT* 44*LOAD-TRUENAME*44*LOAD-VERBOSE* 44*MACROEXPAND-HOOK* 45*MODULES* 42*PACKAGE* 42*PRINT-ARRAY* 35*PRINT-BASE* 35*PRINT-CASE* 35*PRINT-CIRCLE* 35*PRINT-ESCAPE* 35*PRINT-GENSYM* 35*PRINT-LENGTH* 35*PRINT-LEVEL* 35*PRINT-LINES* 35*PRINT-MISER-WIDTH* 35*PRINT-PPRINT-DISPATCH* 36*PRINT-PRETTY* 35*PRINT-RADIX* 35*PRINT-READABLY*35*PRINT-RIGHT-MARGIN* 35*QUERY-IO* 39*RANDOM-STATE* 4*READ-BASE* 32*READ-DEFAULT-FLOAT-FORMAT*32*READ-EVAL* 33*READ-SUPPRESS*32*READTABLE* 32*STANDARD-INPUT*39*STANDARD-OUTPUT* 39*TERMINAL-IO* 39*TRACE-OUTPUT* 45
+ 3, 26, 45++ 45+++ 45, 33,. 33,@ 33– 3, 45. 33/ 3, 33, 45// 45/// 45/= 3: 41:: 41:ALLOW-
OTHER-KEYS 19; 33< 3<= 3= 3, 21> 3>= 3\ 33# 38#\ 33#’ 33#( 33#* 33#+ 33#– 33#. 33#: 33#< 33#= 33#A 33#B 33#C( 33#O 33#P 33#R 33#S( 33#X 33## 33#| |# 33
&ALLOW-OTHER-KEYS 19
&AUX 19&BODY 19&ENVIRONMENT 19&KEY 19&OPTIONAL 19&REST 19&WHOLE 19∼( ∼) 37∼* 37∼/ / 38∼< ∼:> 37∼< ∼> 37∼? 38∼A 36∼B 36∼C 36∼D 36∼E 36∼F 36∼G 36∼I 37∼O 36∼P 37∼R 36∼S 36∼T 37∼W 38∼X 36∼[ ∼] 37∼$ 36∼% 37∼& 37∼ˆ 37∼ 37∼| 37∼{ ∼} 37∼∼ 37∼← 37` 33| | 331+ 31– 3
ABORT 28ABOVE 21ABS 4ACONS 9ACOS 3ACOSH 4ACROSS 21ADD-METHOD 25ADJOIN 9ADJUST-ARRAY 10ADJUSTABLE-
ARRAY-P 10ALLOCATE-INSTANCE
24ALPHA-CHAR-P 6ALPHANUMERICP 6ALWAYS 23AND
19, 21, 23, 26, 31, 33APPEND 9, 23, 26APPENDING 23APPLY 17APROPOS 45APROPOS-LIST 45AREF 10ARITHMETIC-ERROR
30ARITHMETIC-ERROR-
OPERANDS 29ARITHMETIC-ERROR-
OPERATION 29ARRAY 30ARRAY-DIMENSION 11ARRAY-DIMENSION-
LIMIT 11ARRAY-DIMENSIONS
11ARRAY-
DISPLACEMENT 11ARRAY-
ELEMENT-TYPE 29ARRAY-HAS-
FILL-POINTER-P 10ARRAY-IN-BOUNDS-P
10ARRAY-RANK 11ARRAY-RANK-LIMIT
11ARRAY-ROW-
MAJOR-INDEX 11ARRAY-TOTAL-SIZE
11ARRAY-TOTAL-
SIZE-LIMIT 11ARRAYP 10AS 21ASH 5ASIN 3ASINH 4ASSERT 28ASSOC 9ASSOC-IF 9ASSOC-IF-NOT 9ATAN 3ATANH 4ATOM 8, 30
BASE-CHAR 30BASE-STRING 30BEING 21
BELOW 21BIGNUM 30BIT 11, 30BIT-AND 11BIT-ANDC1 11BIT-ANDC2 11BIT-EQV 11BIT-IOR 11BIT-NAND 11BIT-NOR 11BIT-NOT 11BIT-ORC1 11BIT-ORC2 11BIT-VECTOR 30BIT-VECTOR-P 10BIT-XOR 11BLOCK 20BOOLE 4BOOLE-1 4BOOLE-2 4BOOLE-AND 5BOOLE-ANDC1 5BOOLE-ANDC2 5BOOLE-C1 4BOOLE-C2 4BOOLE-CLR 4BOOLE-EQV 5BOOLE-IOR 5BOOLE-NAND 5BOOLE-NOR 5BOOLE-ORC1 5BOOLE-ORC2 5BOOLE-SET 4BOOLE-XOR 5BOOLEAN 30BOTH-CASE-P 6BOUNDP 15BREAK 45BROADCAST-
STREAM 30BROADCAST-
STREAM-STREAMS38
BUILT-IN-CLASS 30BUTLAST 9BY 21BYTE 5BYTE-POSITION 5BYTE-SIZE 5
CAAR 8CADR 8CALL-ARGUMENTS-
LIMIT 17CALL-METHOD 27CALL-NEXT-METHOD
26CAR 8CASE 19CATCH 20CCASE 19CDAR 8CDDR 8CDR 8CEILING 4CELL-ERROR 30CELL-ERROR-NAME
29CERROR 27CHANGE-CLASS 24CHAR 8CHAR-CODE 7CHAR-CODE-LIMIT 7CHAR-DOWNCASE 7CHAR-EQUAL 6CHAR-GREATERP 7CHAR-INT 7CHAR-LESSP 7CHAR-NAME 7CHAR-NOT-EQUAL 6CHAR-
NOT-GREATERP 7CHAR-NOT-LESSP 7CHAR-UPCASE 7CHAR/= 6CHAR< 6CHAR<= 6CHAR= 6CHAR> 6CHAR>= 6CHARACTER 7, 30, 33CHARACTERP 6CHECK-TYPE 29CIS 4CL 43CL-USER 43CLASS 30CLASS-NAME 24CLASS-OF 24CLEAR-INPUT 39CLEAR-OUTPUT 39CLOSE 39CLQR 1CLRHASH 14CODE-CHAR 7COERCE 29COLLECT 23COLLECTING 23COMMON-LISP 43COMMON-LISP-USER
43COMPILATION-SPEED
46COMPILE 43COMPILE-FILE 44
COMPILE-FILE-PATHNAME 44
COMPILED-FUNCTION 30
COMPILED-FUNCTION-P 43
COMPILER-MACRO 43COMPILER-MACRO-
FUNCTION 44COMPLEMENT 17COMPLEX 4, 30, 33COMPLEXP 3COMPUTE-
APPLICABLE-METHODS 25
COMPUTE-RESTARTS28
CONCATENATE 12CONCATENATED-
STREAM 30CONCATENATED-
STREAM-STREAMS38
COND 19CONDITION 30CONJUGATE 4CONS 8, 30CONSP 8CONSTANTLY 17CONSTANTP 15CONTINUE 28CONTROL-ERROR 30COPY-ALIST 9COPY-LIST 9COPY-PPRINT-
DISPATCH 36COPY-READTABLE 32COPY-SEQ 14COPY-STRUCTURE 15COPY-SYMBOL 43COPY-TREE 10COS 3COSH 3COUNT 12, 23COUNT-IF 12COUNT-IF-NOT 12COUNTING 23CTYPECASE 29
DEBUG 46DECF 3DECLAIM 46DECLARATION 46DECLARE 46DECODE-FLOAT 6DECODE-UNIVERSAL-
TIME 46DEFCLASS 23DEFCONSTANT 16DEFGENERIC 25DEFINE-COMPILER-
MACRO 18DEFINE-CONDITION
27DEFINE-METHOD-
COMBINATION 26DEFINE-MODIFY-
MACRO 19DEFINE-SETF-
EXPANDER 18DEFINE-SYMBOL-
MACRO 18DEFMACRO 18DEFMETHOD 25DEFPACKAGE 41DEFPARAMETER 16DEFSETF 18DEFSTRUCT 15DEFTYPE 31DEFUN 17DEFVAR 16DELETE 13DELETE-DUPLICATES
13DELETE-FILE 41DELETE-IF 13DELETE-IF-NOT 13DELETE-PACKAGE 42DENOMINATOR 4DEPOSIT-FIELD 5DESCRIBE 45DESCRIBE-OBJECT 45DESTRUCTURING-
BIND 20DIGIT-CHAR 7DIGIT-CHAR-P 6DIRECTORY 41DIRECTORY-
NAMESTRING 40DISASSEMBLE 45DIVISION-BY-ZERO 30DO 20, 23DO-ALL-SYMBOLS 42DO-EXTERNAL-
SYMBOLS 42DO-SYMBOLS 42DO* 20DOCUMENTATION 43DOING 23DOLIST 21DOTIMES 21DOUBLE-FLOAT 30, 33DOUBLE-
FLOAT-EPSILON 6
47
clCommon Lisp Quick Reference Revision 130 [2011-10-12]
Copyright © 2008, 2009, 2010, 2011 Bert Burgemeister
LATEX source: http://clqr.boundp.org
Permission is granted to copy, distribute and/or modify this document under the
terms of the GNU Free Documentation License, Version 1.2 or any later version
published by the Free Software Foundation; with no Invariant Sections, no Front-
Cover Texts and no Back-Cover Texts. http://www.gnu.org/licenses/fdl.html
Common Lisp Quick Reference
NTHCDR 8NULL 8, 30NUMBER 30NUMBERP 3NUMERATOR 4NUNION 10
ODDP 3OF 21OF-TYPE 21ON 21OPEN 38OPEN-STREAM-P 31OPTIMIZE 46OR 19, 26, 31, 33OTHERWISE 19, 29OUTPUT-STREAM-P
31
PACKAGE 30PACKAGE-ERROR 30PACKAGE-ERROR-
PACKAGE 29PACKAGE-NAME 42PACKAGE-
NICKNAMES 42PACKAGE-
SHADOWING-SYMBOLS 42
PACKAGE-USE-LIST 42PACKAGE-
USED-BY-LIST 42PACKAGEP 41PAIRLIS 9PARSE-ERROR 30PARSE-INTEGER 8PARSE-NAMESTRING
40PATHNAME 30, 40PATHNAME-DEVICE
40PATHNAME-
DIRECTORY 40PATHNAME-HOST 40PATHNAME-MATCH-P
31PATHNAME-NAME 40PATHNAME-TYPE 40PATHNAME-VERSION
40PATHNAMEP 31PEEK-CHAR 32PHASE 4PI 3PLUSP 3POP 9POSITION 13POSITION-IF 13POSITION-IF-NOT 13PPRINT 34PPRINT-DISPATCH 36PPRINT-EXIT-IF-LIST-
EXHAUSTED 35PPRINT-FILL 34PPRINT-INDENT 35PPRINT-LINEAR 34PPRINT-LOGICAL-
BLOCK 35PPRINT-NEWLINE 35PPRINT-POP 35PPRINT-TAB 35PPRINT-TABULAR 34PRESENT-SYMBOL 21PRESENT-SYMBOLS
21PRIN1 34PRIN1-TO-STRING 34PRINC 34PRINC-TO-STRING 34PRINT 34PRINT-
NOT-READABLE 30PRINT-
NOT-READABLE-OBJECT 29
PRINT-OBJECT 34PRINT-UNREADABLE-
OBJECT 34PROBE-FILE 41PROCLAIM 46PROG 20PROG1 20PROG2 20PROG* 20PROGN 19, 26PROGRAM-ERROR 30PROGV 20PROVIDE 42PSETF 16PSETQ 16PUSH 9PUSHNEW 9
QUOTE 33, 44
RANDOM 4RANDOM-STATE 30RANDOM-STATE-P 3RASSOC 9RASSOC-IF 9RASSOC-IF-NOT 9RATIO 30, 33RATIONAL 4, 30RATIONALIZE 4RATIONALP 3READ 31READ-BYTE 32READ-CHAR 32
READ-CHAR-NO-HANG 32
READ-DELIMITED-LIST 32
READ-FROM-STRING31
READ-LINE 32READ-PRESERVING-
WHITESPACE 31READ-SEQUENCE 32READER-ERROR 30READTABLE 30READTABLE-CASE 32READTABLEP 31REAL 30REALP 3REALPART 4REDUCE 14REINITIALIZE-
INSTANCE 24REM 4REMF 16REMHASH 14REMOVE 13REMOVE-
DUPLICATES 13REMOVE-IF 13REMOVE-IF-NOT 13REMOVE-METHOD 25REMPROP 16RENAME-FILE 41RENAME-PACKAGE 41REPEAT 23REPLACE 13REQUIRE 42REST 8RESTART 30RESTART-BIND 28RESTART-CASE 28RESTART-NAME 28RETURN 20, 23RETURN-FROM 20REVAPPEND 9REVERSE 12ROOM 46ROTATEF 16ROUND 4ROW-MAJOR-AREF 10RPLACA 9RPLACD 9
SAFETY 46SATISFIES 31SBIT 11SCALE-FLOAT 6SCHAR 8SEARCH 13SECOND 8SEQUENCE 30SERIOUS-CONDITION
30SET 16SET-DIFFERENCE 10SET-
DISPATCH-MACRO-CHARACTER 32
SET-EXCLUSIVE-OR10
SET-MACRO-CHARACTER 32
SET-PPRINT-DISPATCH 36
SET-SYNTAX-FROM-CHAR 32
SETF 16, 43SETQ 16SEVENTH 8SHADOW 42SHADOWING-IMPORT
42SHARED-INITIALIZE
24SHIFTF 16SHORT-FLOAT 30, 33SHORT-
FLOAT-EPSILON 6SHORT-FLOAT-
NEGATIVE-EPSILON6
SHORT-SITE-NAME 46SIGNAL 27SIGNED-BYTE 30SIGNUM 4SIMPLE-ARRAY 30SIMPLE-BASE-STRING
30SIMPLE-BIT-VECTOR
30SIMPLE-
BIT-VECTOR-P 10SIMPLE-CONDITION
30SIMPLE-CONDITION-
FORMAT-ARGUMENTS 29
SIMPLE-CONDITION-FORMAT-CONTROL29
SIMPLE-ERROR 30SIMPLE-STRING 30SIMPLE-STRING-P 7SIMPLE-TYPE-ERROR
30SIMPLE-VECTOR 30SIMPLE-VECTOR-P 10SIMPLE-WARNING 30SIN 3SINGLE-FLOAT 30, 33SINGLE-
FLOAT-EPSILON 6
SINGLE-FLOAT-NEGATIVE-EPSILON6
SINH 3SIXTH 8SLEEP 20SLOT-BOUNDP 23SLOT-EXISTS-P 23SLOT-MAKUNBOUND
24SLOT-MISSING 24SLOT-UNBOUND 25SLOT-VALUE 24SOFTWARE-TYPE 46SOFTWARE-VERSION
46SOME 12SORT 12SPACE 6, 46SPECIAL 46SPECIAL-
OPERATOR-P 43SPEED 46SQRT 3STABLE-SORT 12STANDARD 26STANDARD-CHAR
6, 30STANDARD-CHAR-P 6STANDARD-CLASS 30STANDARD-GENERIC-
FUNCTION 30STANDARD-METHOD
30STANDARD-OBJECT
30STEP 45STORAGE-
CONDITION 30STORE-VALUE 28STREAM 30STREAM-
ELEMENT-TYPE 29STREAM-ERROR 30STREAM-
ERROR-STREAM 29STREAM-EXTERNAL-
FORMAT 39STREAMP 31STRING 7, 30STRING-CAPITALIZE 7STRING-DOWNCASE 7STRING-EQUAL 7STRING-GREATERP 7STRING-LEFT-TRIM 7STRING-LESSP 7STRING-NOT-EQUAL7STRING-
NOT-GREATERP 7STRING-NOT-LESSP 7STRING-RIGHT-TRIM
7STRING-STREAM 30STRING-TRIM 7STRING-UPCASE 7STRING/= 7STRING< 7STRING<= 7STRING= 7STRING> 7STRING>= 7STRINGP 7STRUCTURE 43STRUCTURE-CLASS
30STRUCTURE-OBJECT
30STYLE-WARNING 30SUBLIS 10SUBSEQ 12SUBSETP 8SUBST 10SUBST-IF 10SUBST-IF-NOT 10SUBSTITUTE 13SUBSTITUTE-IF 13SUBSTITUTE-IF-NOT
13SUBTYPEP 29SUM 23SUMMING 23SVREF 11SXHASH 14SYMBOL 21, 30, 43SYMBOL-FUNCTION
43SYMBOL-MACROLET
18SYMBOL-NAME 43SYMBOL-PACKAGE 43SYMBOL-PLIST 43SYMBOL-VALUE 43SYMBOLP 41SYMBOLS 21SYNONYM-STREAM
30SYNONYM-STREAM-
SYMBOL 38
T 2, 30, 43TAGBODY 20TAILP 8TAN 3TANH 3TENTH 8TERPRI 34THE 21, 29THEN 21THEREIS 23THIRD 8
THROW 20TIME 45TO 21TRACE 45TRANSLATE-
LOGICAL-PATHNAME 41
TRANSLATE-PATHNAME 40
TREE-EQUAL 10TRUENAME 41TRUNCATE 4TWO-WAY-STREAM
30TWO-WAY-STREAM-
INPUT-STREAM 38TWO-WAY-STREAM-
OUTPUT-STREAM38
TYPE 43, 46TYPE-ERROR 30TYPE-ERROR-DATUM
29TYPE-ERROR-
EXPECTED-TYPE29TYPE-OF 29TYPECASE 29TYPEP 29
UNBOUND-SLOT 30UNBOUND-
SLOT-INSTANCE 29UNBOUND-VARIABLE
30UNDEFINED-
FUNCTION 30UNEXPORT 42UNINTERN 42UNION 10UNLESS 19, 23UNREAD-CHAR 32UNSIGNED-BYTE 30UNTIL 23UNTRACE 45UNUSE-PACKAGE 41UNWIND-PROTECT 20UPDATE-INSTANCE-
FOR-DIFFERENT-CLASS 24
UPDATE-INSTANCE-FOR-REDEFINED-CLASS 24
UPFROM 21UPGRADED-ARRAY-
ELEMENT-TYPE 31UPGRADED-
COMPLEX-PART-TYPE 6
UPPER-CASE-P 6UPTO 21USE-PACKAGE 41USE-VALUE 28USER-HOMEDIR-
PATHNAME 40USING 21
V 38VALUES 17, 31VALUES-LIST 17VARIABLE 43VECTOR 11, 30VECTOR-POP 11VECTOR-PUSH 11VECTOR-
PUSH-EXTEND 11VECTORP 10
WARN 27WARNING 30WHEN 19, 23WHILE 23WILD-PATHNAME-P
31WITH 21WITH-ACCESSORS 24WITH-COMPILATION-
UNIT 44WITH-CONDITION-
RESTARTS 29WITH-HASH-TABLE-
ITERATOR 14WITH-INPUT-
FROM-STRING 39WITH-OPEN-FILE 39WITH-OPEN-STREAM
39WITH-OUTPUT-
TO-STRING 39WITH-PACKAGE-
ITERATOR 42WITH-SIMPLE-
RESTART 28WITH-SLOTS 24WITH-STANDARD-
IO-SYNTAX 31WRITE 34WRITE-BYTE 34WRITE-CHAR 34WRITE-LINE 34WRITE-SEQUENCE 34WRITE-STRING 34WRITE-TO-STRING 34
Y-OR-N-P 31YES-OR-NO-P 31
ZEROP 3
49