This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
⊲ Symbol defined in Common Lisp; esp. function, macro, spe-cial 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};
8<:foo
bar
baz
⊲ Either foo, or bar , or baz .
8<:
˛˛˛foo
bar
baz
⊲ Anything from none to each of foo, bar , and baz .
cfoo ⊲ Argument foo is not evaluated.
gbar ⊲ Argument bar is possibly modified.
fooP∗ ⊲ foo∗ is evaluated as in
sOprogn; see p. 20.
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, mono-tonically non-increasing, monotonically increasing, or mono-tonically 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
Pa or
Qa, respectively.
(Fu– a b∗)
(Fu/ a b∗)
⊲ Return a−P
b or a/Q
b, respectively. Without any bs,return −a or 1/a, respectively.
(Fu1+ a)
(Fu1– a)
⊲ Return a + 1 or a− 1, respectively.
(
MincfMdecf
ffplace [delta 1 ])
⊲ Increment or decrement the value of place by delta. Returnnew 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 denominator,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.
3
Common Lisp Quick Reference
(Fusinh a)
(Fucosh a)
(Futanh a)
⊲ sinh a, cosh a, or tanh a, respectively.
(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.
(
8>><>>:
{ Furound
Fufround}
{ Fufloor
Fuffloor}
{ Fuceiling
Fufceiling}
{ Futruncate
Fuftruncate}
9>>=>>;
n [d 1 ])
⊲ Return as integer or float, respectively, n/d rounded, orrounded towards −∞, +∞, or 0, respectively; and
2remain-
der.
(
FumodFurem
ffn d)
⊲ Same asFufloor or
Futruncate, respectively, but return remain-
der 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 randomstate; 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 .
MIN 4, 27MINIMIZE 24MINIMIZING 24MINUSP 3MISMATCH 12MOD 4, 32MOST-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 30MULTIPLE-
VALUE-BIND 21MULTIPLE-
VALUE-CALL 18MULTIPLE-
VALUE-LIST 18MULTIPLE-
VALUE-PROG1 20MULTIPLE-
VALUE-SETQ 17MULTIPLE-
VALUES-LIMIT 18
NAME-CHAR 7NAMED 22NAMESTRING 42
50
Common Lisp Quick Reference
(Fuupper-case-p character)
(Fulower-case-p character)
(Fuboth-case-p character)
⊲ Return T if character is uppercase, lowercase, or able to bein 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, mono-tonically non-increasing, monotonically increasing, or mono-tonically non-decreasing, respectively.
(Fuchar-greaterp character+)
(Fuchar-not-lessp character+)
(Fuchar-lessp character+)
(Fuchar-not-greaterp character+)
⊲ Return T if characters are monotonically decreasing, mono-tonically non-increasing, monotonically increasing, or mono-tonically non-decreasing, respectively, ignoring case.
⊲ 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.
⊲ Convert x (symbol, string, or character) into a string, astring with capitalized words, an all-uppercase string, or anall-lowercase string, respectively.
(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
ff var
(sOfunction function)
ff∗)
⊲ Suppress warnings about used/unused bindings.
(inline function∗)(notinline function∗)
⊲ Tell compiler to integrate/not to integrate, respectively,called functions into the calling routine.
(optimize
8>>>><>>>>:
˛˛˛˛˛
compilation-speed (compilation-speed n 3 )
debug (debug n 3 )
safety (safety n 3 )
space (space n 3 )
speed (speed n 3 )
9>>>>=>>>>;
)
⊲ Tell compiler how to optimize. n = 0 means unimpor-tant, 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.
(
8<:
Fulisp-implementationFusoftwareFumachine
9=;-
typeversion
ff)
⊲ Name or version of implementation, operating system, orhardware, respectively.
(Fumachine-instance) ⊲ Computer name.
48
Common Lisp Quick Reference
(Fusubsetp list-a list-b
8<:
˛˛˛
:test function #’eql
:test-not function
:key function
9=;)
⊲ 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 and
Fucdrs, e.g. (
Fucadr bar) is equivalent to (
Fucar (
Fucdr bar)). setfable.
(Fulast list [num 1 ]) ⊲ Return list of last num conses of list .
(
Fubutlast listFunbutlast flist
ff[num 1 ]) ⊲ list excluding last num conses.
(
FurplacaFurplacd
ffgcons 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 . Other-wise return list .
(Fuadjoin foo list
8<:
˛˛˛
:test function #’eql
:test-not function
:key function
9=;)
⊲ 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
8<:
˛˛˛
:test function #’eql
:test-not function
:key function
9=;)
⊲ Set place to (Fuadjoin foo place ).
(Fuappend [list∗ foo])
(Funconc [ flist∗ foo])
⊲ Return concatenated list. foo can be of any type.
(Furevappend list foo)
(Funreconc flist foo)
⊲ Return concatenated list after reversing order in list .
9
Common Lisp Quick Reference
(
FumapcarFumaplist
fffunction list+)
⊲ Return list of return values of function successively invokedwith corresponding arguments, either cars or cdrs, respec-tively, from each list .
(
FumapcanFumapcon
fffunction list+)
⊲ Return list of concatenated return values of function suc-cessively invoked with corresponding arguments, either carsor cdrs, respectively, from each list . function should return alist.
(
FumapcFumapl
fffunction list+)
⊲ Return first list after successively applying function to cor-responding arguments, either cars or cdrs, respectively, fromeach 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
fffoo alist
8<:
˛˛˛
:test test #’eql
:test-not test
:key function
9=;)
(
Fuassoc-if[-not]Furassoc-if[-not]
fftest alist [:key function])
⊲ First cons whose car, or cdr, respectively, satisfies test.
(Fucopy-alist alist) ⊲ Return copy of alist .
4.4 Trees
(Futree-equal foo bar
:test test #’eql
:test-not test
ff)
⊲ Return T if trees foo and bar have same shape and leavessatisfying test.
(
Fusubst new old treeFunsubst new old gtree
ff 8<:
˛˛˛
:test function #’eql
:test-not function
:key function
9=;)
⊲ Make copy of tree with each subtree or leaf matching old
replaced by new .
(
Fusubst-if[-not] new test treeFunsubst-if[-not] new test gtree
ff[:key function])
⊲ Make copy of tree with each subtree or leaf satisfying test
⊲ 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 ddecl∗)∗ 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 literalat run time.
(sOquote cfoo) ⊲ 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
ff)
⊲ Return a creation form and an2initialization form which on
evaluation construct an object equivalent to foo with slots
initialized with the corresponding values from foo.
(Fumacro-function symbol [environment ])
(Fucompiler-macro-function
name
(setf name)
ff[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.
15.3 REPL and Debuggingvar+
var++
var+++
var∗
var∗∗
var∗∗∗
var/
var//
var///⊲ Last, penultimate, or antepenultimate form evaluated inthe REPL, or their respective primary value, or a list of theirrespective values.
⊲ Return result of bitwise logical operations (cf. operations ofFuboole, p. 5) 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 arrayfor 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 . Oth-erwise replace element of vector pointed to by fill pointer withfoo; 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 after decre-mentation.
(Fufill-pointer vector) ⊲ Fill pointer of vector . setfable.
6 Sequences
6.1 Sequence Predicates
(
FueveryFunotevery
fftest sequence+)
⊲ Return NIL or T, respectively, as soon as test on any set ofcorresponding elements of sequences returns NIL.
(
FusomeFunotany
fftest sequence+)
⊲ Return value of test or NIL, respectively, as soon as test onany set of corresponding elements of sequences returns non-NIL.
(Fumismatch sequence-a sequence-b
8>>>>>>>>>><>>>>>>>>>>:
˛˛˛˛˛˛˛˛
: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
9>>>>>>>>>>=>>>>>>>>>>;
)
⊲ Return position in sequence-a where sequence-a andsequence-b begin to mismatch. Return NIL if they matchentirely.
12
Common Lisp Quick Reference
(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, give copythe 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.
⊲ Get/set documentation string of foo of given type.
cot
⊲ Truth; the supertype of every type including t; the super-class of every class except t;
var∗terminal-io∗.
conil
co()
⊲ Falsity; the empty list; the empty type, subtype of everytype;
var∗standard-input∗;
var∗standard-output∗; the global envi-
ronment.
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 type keyword.
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
8<:NIL definitionname
(setf name)
ff[definition ]
9=;)
⊲ Return compiled function or replace name ’s function defi-nition with the compiled function. Return
2T in case of warn-
ings or errors, and3T in case of warnings or errors excluding
style warnings.
(Fucompile-file file
8>><>>:
˛˛˛˛
:output-file out-path
:verbose bool var∗compile-verbose∗
:print bool var∗compile-print∗
:external-format file-format :default
9>>=>>;
)
⊲ 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.
45
Common Lisp Quick Reference
(Fufind-package name) ⊲ Package with name (case-sensitive).
(Fufind-all-symbols foo)
⊲ List of symbols foo from all registered packages.
(
FuinternFufind-symbol
fffoo [package var
∗package∗ ])
⊲ Intern or find, respectively, symbol foo in package . Secondreturn value is one of
2:internal,
2:external, or
2:inherited (or
2NIL
ifFuintern created a fresh symbol).
(Fuunintern symbol [package var
∗package∗ ])
⊲ Remove symbol from package, return T on success.
(
FuimportFushadowing-import
ffsymbols [package var
∗package∗ ])
⊲ Make symbols internal to package . Return T. In case of aname conflict signal correctable package-error or shadow theold symbol, respectively.
(Fushadow symbols [package var
∗package∗ ])
⊲ Make symbols of package shadow any otherwise accessible,equally named symbols from other packages. Return T.
(Fupackage-shadowing-symbols package)
⊲ List of symbols of package that shadow any otherwise ac-cessible, 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.
(
8<:
Mdo-symbolsMdo-external-symbols
ff(dvar
ˆpackage var
∗package∗ [result NIL ]˜)
Mdo-all-symbols (var [result NIL ])
9=;
(declare ddecl∗)∗
˛ ctagform
ff∗)
⊲ EvaluatesOtagbody-like body with var successively bound
to every symbol from package , to every external symbol frompackage , or to every symbol from all registered packages, re-spectively. Return values of result . Implicitly, the whole formis a
⊲ Return values of forms. In forms, successive invocationsof (foo) return: T if a symbol is returned; a symbol frompackages; accessibility (:internal, :external, or :inherited); andthe package the symbol belongs to.
(Furequire module [paths NIL ])
⊲ If not invar
∗modules∗, try paths to load module from. Signalerror if unsuccessful. Deprecated.
(Fuprovide module)
⊲ If not already there, add module tovar
∗modules∗. Depre-cated.
var∗modules∗ ⊲ List of names of loaded modules.
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
Fusubstitute new old sequenceFunsubstitute new old ˜sequence
ff
8>>>>>>>><>>>>>>>>:
˛˛˛˛˛˛˛
:from-end bool NIL:test function #’eql
:test-not function
:start start 0:end end NIL
:key function
:count count NIL
9>>>>>>>>=>>>>>>>>;
)
⊲ Make copy of sequence with all (or count) olds replaced bynew .
(
8>><>>:
Fusubstitute-ifFusubstitute-if-not
ffnew test sequence
Funsubstitute-ifFunsubstitute-if-not
ffnew test ˜sequence
9>>=>>;
8>>><>>>:
˛˛˛˛˛
:from-end bool NIL:start start 0:end end NIL
:key function
:count count NIL
9>>>=>>>;
)
⊲ Make copy of sequence with all (or count) elements satis-fying test replaced by new .
(Fureplace ˜sequence-a sequence-b
8>><>>:
˛˛˛˛
:start1 start-a 0
:start2 start-b 0
:end1 end-a NIL
:end2 end-b NIL
9>>=>>;
)
⊲ Replace elements of sequence-a with elements ofsequence-b.
(Fumap type function sequence+)
⊲ Apply function successively to corresponding elements ofthe sequences. Return values as a sequence of type. If type isNIL, return NIL.
(Fumap-into ˜result-sequence function sequence∗)
⊲ Store into result-sequence successively values of function
applied to corresponding elements of the sequences.
(Fureduce function sequence
8>>><>>>:
˛˛˛˛˛
:initial-value foo NIL
:from-end bool NIL:start start 0:end end NIL
:key function
9>>>=>>>;
)
⊲ 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.
14
Common Lisp Quick Reference
(Furename-file foo bar)
⊲ Rename file foo to bar . Unspecified components of path bar
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 .
⊲ Create or modify package foo with interned-symbols, sym-bols from used-packages, imported-symbol s, and shd-symbols.Add shd-symbols to foo’s shadowing list.
⊲ 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. 17) 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 :type with-out :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 ignoring type;or are equivalent pathnames; or are conses or arrays of thesame 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 keys in termsof :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.
(Fufboundp
foo
(setf foo)
ff) ⊲ T if foo is a global function or macro.
9.2 Variables
(
MdefconstantMdefparameter
ffcfoo form [ddoc])
⊲ Assign value of form to global constant/dynamic variablefoo.
(Mdefvar cfoo
ˆform [ddoc]
˜)
⊲ Unless bound already, assign value of form to dynamic vari-able foo.
(
MsetfMpsetf
ff{place form}∗)
⊲ Set places to primary values of forms. Return values oflast form/NIL; work sequentially/in parallel, respectively.
16
Common Lisp Quick Reference
(
8<:
Fuclear-outputFuforce-outputFufinish-output
9=; [stream var
∗standard-output∗ ])
⊲ End output to stream and return NIL immediately, afterinitiating flushing of buffers, or after flushing of buffers, re-spectively.
(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 ddecl∗)∗ form
P∗)⊲ Use
Fuopen with open-args to temporarily create stream to
path ; return values of forms.
(Mwith-open-stream (foo stream) (declare ddecl∗)∗ form
P∗)⊲ Evaluate forms with foo locally bound to stream . Returnvalues of forms.
(Mwith-input-from-string (foo string
8<:
˛˛˛:index index
:start start 0:end end NIL
9=;) (declare
ddecl∗)∗ formP∗)
⊲ Evaluate forms with foo locally bound to inputstring-stream from string . Return values of forms; store nextreading position into index .
(Mwith-output-to-string (foo [string NIL ] [:element-type type character ])
(declare ddecl∗)∗ formP∗)
⊲ 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.
: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
9>>>>>>>>>>>>>>>>>>>>>=>>>>>>>>>>>>>>>>>>>>>;
)
⊲ Construct pathname. For :case :local, leave case of compo-nents unchanged. For :case :common, leave mixed-case com-ponents unchanged; convert all-uppercase components intolocal customary case; do the opposite with all-lowercase com-ponents.
⊲ Return list of streams concatenated-stream still has to readfrom/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.
(Fufile-position stream [
8<:
:start:endposition
9=;])
⊲ 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.
40
Common Lisp Quick Reference
(
sOsetqMpsetq
ff{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 ffoo) ⊲ 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/in place ,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 starting
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, orNIL otherwise.
9.3 Functions
Below, ordinary lambda list (ord-λ∗) has the form
(var∗ˆ&optional
var
(varˆinit NIL [supplied-p]
˜)
ff∗˜[&rest var ]
ˆ&key
8<:var
(
var
(:key var)
ff ˆinit NIL [supplied-p]
˜)
9=;
∗
[&allow-other-keys]˜
ˆ&aux
var
(var [init NIL ])
ff∗˜).
supplied-p is T if there is a corresponding argument. init forms canrefer to any init and supplied-p to their left.
(
8<:
Mdefun
foo (ord-λ∗)(setf foo) (new-value ord-λ∗)
Mlambda (ord-λ∗)
9=; (declare ddecl∗)∗ [ddoc]
formP∗)
⊲ Define a function named foo or (setf foo), or an anonymousfunction, respectively, which applies forms to ord-λs. ForMdefun, forms are enclosed in an implicit
sOblock named foo.
(
sOfletsOlabels
ff((
foo (ord-λ∗)(setf foo) (new-value ord-λ∗)
ff(declare local-decl∗)∗
[ddoc] local-formP∗)∗) (declare ddecl∗)∗ form
P∗)⊲ Evaluate forms with locally defined functions foo. Globallydefined functions of the same name are shadowed. Each foo
is also the name of an implicitsOblock around its corresponding
local-form∗. Only forsOlabels, functions foo are visible inside
local-forms . Return values of forms.
17
Common Lisp Quick Reference
(sOfunction
foo
(Mlambda form∗)
ff)
⊲ Return lexically innermost function named foo or a lexicalclosure of the
Mlambda expression.
(Fuapply
function
(setf function)
ffarg∗ args)
⊲ Values of function called with args and the list elements ofargs. 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 argu-ments. 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)
ff)
⊲ 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 value canhave; ≥ 20.
9.4 Macros
Below, macro lambda list (macro-λ∗) has the form of either
([&whole var ] [E ]
var
(macro-λ∗)
ff∗[E ]
[&optional
8<:var
(
var
(macro-λ∗)
ff ˆinit NIL [supplied-p]
˜)
9=;
∗
] [E ]
[
&rest&body
ff rest-var
(macro-λ∗)
ff] [E ]
ˆ&key
8>><>>:
var
(
8<:
var
(:key
var
(macro-λ∗)
ff)
9=;
ˆinit NIL [supplied-p]
˜)
9>>=>>;
∗
[E ]
[&allow-other-keys]˜
[&aux
var
(var [init NIL ])
ff∗] [E ])
or
18
Common Lisp Quick Reference
⊲ Logical Block. Act like pprint-logical-block using body
asFuformat control string on the elements of the list argu-
ment or, with @, on the remaining arguments, which areextracted by pprint-pop. With :, prefix and suffix defaultto ( and ). When closed by ˜:@>, spaces in body arereplaced 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 :, calcu-late column numbers relative to the immediately enclos-ing section. 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, or x ≤ y ≤ z,respectively.
˜ [i ] [:] [@] [ [{text ˜;}∗ text] [˜:; default ] ˜]⊲ Conditional Expression. Use the zero-indexed argu-menth (or ith if given) text as a
Fuformat control subclause.
With :, use the first text if the argument value is NIL,or the second text if it is T. With @, do nothing for anargument value of NIL. Use the only text and leave theargument to be read again if it is T.
˜ [@] ?⊲ Recursive Processing. Process two arguments as con-trol string and argument list. With @, take one argumentas control string and use then the rest of the original ar-guments.
˜ˆprefix {,prefix}∗
˜[:] [@] /function/
⊲ Call Function. Call function with the argumentsstream, format-argument, colon-p, at-sign-p and prefixesfor 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.
39
Common Lisp Quick Reference
˜ [radix 10 ]ˆ,[width]
ˆ,[pad-char ’ ]
ˆ,[comma-char ’, ]ˆ
,comma-interval 3˜˜˜˜
[:] [@] R⊲ Radix. (With one or more prefix arguments.) Printargument as number; with :, group digits comma-interval
each; with @, always prepend a sign.
{˜R ˜:R ˜@R ˜@:R}⊲ Roman. Take argument as number and print it as En-glish cardinal number, as English ordinal number, as Ro-man numeral, or as old Roman numeral, respectively.
˜ [width]ˆ,[pad-char ’ ]
ˆ,[comma-char ’, ]ˆ
,comma-interval 3˜˜˜
[:] [@] {D B O X}⊲ Decimal/Binary/Octal/Hexadecimal. Print integer ar-gument as number. With :, group digits comma-interval
each; with @, always prepend a sign.
˜ [width]ˆ,[dec-digits]
ˆ,[shift 0 ]
ˆ,[overflow-char ]ˆ
,pad-char ’
˜˜˜˜[@] F
⊲ Fixed-Format Floating-Point. With @, always prependa sign.
˜ [width]ˆ,[int-digits]
ˆ,[exp-digits]
ˆ,[scale-factor 1 ]ˆ
,[overflow-char ]ˆ,[pad-char ’ ]
ˆ,exp-char
˜˜˜˜˜˜
[@] {E G}⊲ Exponential/General Floating-Point. Print argument asfloating-point number with int-digits before decimal pointand exp-digits in the signed exponent. With ˜G, chooseeither ˜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 (possibly non-printing) character.
{˜( text ˜) ˜:( text ˜) ˜@( text ˜) ˜:@( text ˜)}⊲ Case-Conversion. Convert text to lowercase, convertfirst letter of each word to uppercase, capitalize first wordand convert the rest to lowercase, or convert to uppercase,respectively.
{˜P ˜:P ˜@P ˜:@P}⊲ Plural. If argument eql 1 print nothing, otherwise prints; do the same for the previous argument; if argument eql1 print y, otherwise print ies; do the same for the previousargument, respectively.
˜ [n 1 ] % ⊲ Newline. Print n newlines.
˜ [n 1 ] &⊲ Fresh-Line. Print n− 1 newlines if output stream is atthe 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 follow-ing 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 characterson the current line, output nl-text first.
˜ [:] [@] <˘[prefix "" ˜;] [per-line-prefix ˜@;]
¯body
ˆ˜;
suffix ""
˜˜: [@] >
38
Common Lisp Quick Reference
([&whole var ] [E ]
var
(macro-λ∗)
ff∗[E ] [&optional
8<:var
(
var
(macro-λ∗)
ff ˆinit NIL [supplied-p]
˜)
9=;
∗
] [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 to anyinit and supplied-p to their left.
(
MdefmacroFudefine-compiler-macro
ff foo
(setf foo)
ff(macro-λ∗) (declare ddecl∗)∗
[ddoc] 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 evaluates ex-panded form.
⊲ Specify how to setf a place accessed by function .Short form: (setf (function arg∗) value-form) is replaced by(updater arg∗ value-form); the latter must return value-form.Long form: on invocation of (setf (function arg∗) value-form),forms must expand into code that sets the place accessedwhere setf-λ and s-var∗ describe the arguments of function
and the value(s) to be stored, respectively; and that returnsthe value(s) of s-var∗. forms are enclosed in an implicit
sOblock
named function .
(Mdefine-setf-expander function (macro-λ∗) (declare ddecl∗)∗ [ddoc]
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-λ∗ are boundto corresponding args. forms are enclosed in an implicit
sOblock
named function .
(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]
˜)
ff∗˜[&rest var ]) function [ddoc])
⊲ Define macro foo able to modify a place. On invocation of(foo place arg∗), the value of function applied to place andargs will be stored into place and returned.
19
Common Lisp Quick Reference
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 of else
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
fftest foo
P∗)
⊲ Evaluate foos and return their values if test returns T orNIL, respectively. Return NIL otherwise.
(Mcase test (
((dkey∗)dkey
)foo
P∗)∗ˆ(
otherwiseT
ffbar
P∗)NIL˜)
⊲ Return the values of the first foo∗ one of whose keys is eqltest . Return values of bar s if there is no matching key.
(
MecaseMccase
fftest (
((dkey∗)dkey
)foo
P∗)∗)
⊲ Return the values of the first foo∗ one of whose keys is eqltest . Signal non-correctable/correctable type-error and returnNIL if there is no matching key.
(Mand form∗
T )⊲ Evaluate forms from left to right. Immediately return NIL
if one form’s value is NIL. Return values of last form other-wise.
(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 .
(sOmultiple-value-prog1 form-r form∗)
(Mprog1 form-r form∗)
(Mprog2 form-a form-r form∗)
⊲ Evaluate forms in order. Return values/primary value, re-spectively, of form-r .
(
sOletsOlet∗
ff(
˛name
(name [value NIL ])
ff∗) (declare ddecl∗)∗ form
P∗)
⊲ Evaluate forms with names lexically bound (in parallel orsequentially, respectively) to values. Return values of forms.
20
Common Lisp Quick Reference
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 circular struc-ture.
var∗print-escape∗T
⊲ If NIL, do not print escape characters and package prefixes.
var∗print-gensym∗T ⊲ If T, print #: before uninterned symbols.
var∗print-length∗NIL
var∗print-level∗NIL
var∗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 printinga 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.
(Fuset-pprint-dispatch type function
ˆpriority 0
[table var∗print-pprint-dispatch∗ ]
˜)
⊲ Install entry comprising function of arguments stream andobject to print; and priority as type into table. If function isNIL, 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 returningNIL or any excess arguments.
(Fuformat {T NIL out-string out-stream} control arg∗)
⊲ Output string control which may contain ˜ directives possi-bly taking some args. Alternatively, control can be a functionreturned by
Mformatter which is then applied to out-stream and
arg∗. Output to out-string , out-stream or, if first argumentis T, to
var∗standard-output∗. Return NIL. If first 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.
⊲ Print foo to stream and return foo, or print foo into string,respectively, after dynamically setting printer variables corre-sponding to keyword parameters (∗print-bar∗ becoming :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 ˜//.
(Mpprint-logical-block (stream list
8<:
˛˛˛
:prefix string
:per-line-prefix string
ff
:suffix string ""
9=;)
(declare ddecl∗)∗ formP∗)
⊲ Evaluate forms, which should print list , with stream lo-cally bound to a pretty printing stream which outputs to theoriginal stream. If list is in fact not a list, it is printed byFuwrite. Return NIL.
(Mpprint-pop)
⊲ Take next element off list . If there is no remaining tailof list , or
var∗print-length∗ or
var∗print-circle∗ indicate printing
should end, send element together with an appropriateindicator to stream.
(Fupprint-tab
8>><>>:
:line:line-relative:section:section-relative
9>>=>>;
c i [stream var∗standard-output∗ ])
⊲ Move cursor forward to column number c + ki, k ≥ 0being as small as possible.
(Fupprint-indent
:block:current
ffn
ˆstream var
∗standard-output∗
˜)
⊲ Specify indentation for innermost logical block relativeto leftmost position/to current position. Return NIL.
(Mpprint-exit-if-list-exhausted)
⊲ If list is empty, terminate logical block. Return NIL
otherwise.
(Fupprint-newline
8>><>>:
:linear:fill:miser:mandatory
9>>=>>;
ˆstream var
∗standard-output∗
˜)
⊲ Print a conditional newline if stream is a pretty printingstream. Return NIL.
var∗print-array∗ ⊲ If T, print arrays
Fureadably.
var∗print-base∗10 ⊲ Radix for printing rationals, from 2 to 36.
36
Common Lisp Quick Reference
(
MprogMprog∗
ff(
˛name
(name [value NIL ])
ff∗) (declare ddecl∗)∗
ctagform
ff∗)
⊲ EvaluatesOtagbody-like body with names lexically bound (in
parallel or sequentially, respectively) to values. Return NIL
or explicitlyMreturned values. Implicitly, the whole form is a
sOblock named NIL.
(sOprogv symbols values form
P∗)⊲ Evaluate forms with locally established dynamic bindingsof symbols to values or NIL. Return values of forms.
(sOunwind-protect protected cleanup∗)
⊲ Evaluate protected and then, no matter how control leavesprotected , cleanups. Return values of protected .
(Mdestructuring-bind destruct-λ bar (declare ddecl∗)∗ form
P∗)⊲ Evaluate forms with variables from tree destruct-λ boundto corresponding elements of tree bar , and return their values.destruct-λ resembles macro-λ (section 9.4), but without any&environment clause.
⊲ 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 {ctag form}∗)
⊲ Evaluate forms in a lexical environment. tags (symbolsor integers) have lexical scope and dynamic extent, and aretargets for
sOgo. Return NIL.
(sOgo ctag)
⊲ 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∗
ff(
var
(varˆstart [step]
˜)
ff∗) (stop result
P∗) (declare ddecl∗)∗
ctagform
ff∗)
⊲ 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∗. Im-plicitly, the whole form is a
sOblock named NIL.
(Mdotimes (var i [result NIL ]) (declare ddecl∗)∗ {ctag form}∗)
⊲ EvaluatesOtagbody-like body with var successively bound to
integers from 0 to i − 1. Upon evaluation of result , var is i .Implicitly, the whole form is a
sOblock named NIL.
(Mdolist (var list [result NIL ]) (declare ddecl∗)∗ {ctag form}∗)
⊲ EvaluatesOtagbody-like body with var successively bound
to the elements of list . Upon evaluation of result , var is NIL.Implicitly, the whole form is a
sOblock named NIL.
21
Common Lisp Quick Reference
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∗)
ff[d-type] = foo}+
{and
var-p
(var-p∗)
ff[d-type] = bar}∗
where destructuring type specifier d-type has the formnfixnum float T NIL
˘of-type
type
(type∗)
ff¯o
⊲ Initialize (possibly trees of) local variables var-s se-quentially and var-p in parallel.
˘{for as}
var-s
(var-s∗)
ff[d-type]
+ ˘and
var-p
(var-p∗)
ff[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, respectively,of list .
by {step 1 function #’cdr}⊲ Specify the (positive) decrement or increment orthe function of one argument returning the next partof 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 of hash-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 symbols,or the present symbols, or the external symbolsrespectively, of package .
{do doing} form+
⊲ Evaluate forms in every iteration.
{if when unless} test i-clause {and j-clause}∗ [else k-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.
22
Common Lisp Quick Reference
#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 iffeature is NIL. feature is a symbol from
var∗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.
13.4 Printer
(
8>><>>:
Fuprin1FuprintFupprintFuprinc
9>>=>>;
foo [stream var∗standard-output∗ ])
⊲ Print foo to streamFureadably,
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
ff) 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 isalready at the start of a line.
(Fuwrite-char char [stream var
∗standard-output∗ ])
⊲ Output char to stream .
(
Fuwrite-stringFuwrite-line
ffstring
ˆstream var
∗standard-output∗
ˆ˛:start start 0:end end NIL
ff˜˜)
⊲ 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
ff)
⊲ Write elements of sequence to binary or character stream .
35
Common Lisp Quick Reference
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 [ ert var
∗readtable∗ ]˜)
⊲ Make char a macro character associated with function ofstream and char . Return T.
(Fuget-macro-character char [rt var
∗readtable∗ ])⊲ Reader macro function associated with char , and
2T 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 [ ert 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 .
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 .
{collect collecting} {form it} [into list ]⊲ Collect values of form or it into list . If no list is given,collect into an anonymous list which is returned after ter-mination.
{append appending nconc nconcing} {form it} [into list ]⊲ Concatenate values of form or it, which should be lists,into list by the means of
Fuappend or
Funconc, respectively.
If no list is given, collect into an anonymous list which isreturned 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, ofthe primary values of form or of it. If no max-min isgiven, use an anonymous variable which is returned aftertermination.
{initially finally} form+
⊲ Evaluate forms before begin, or after end, respectively,of iterations.
repeat num
⊲ TerminateMloop after num iterations; num is evaluated
once.
{while until} test
⊲ Continue iteration until test returns NIL or T, respec-tively.
{always never} test
⊲ TerminateMloop 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 )
(
8>>>>>>>>>>>>>>><>>>>>>>>>>>>>>>:
slot
(slot
8>>>>>>>>>>>>><>>>>>>>>>>>>>:
˛˛˛˛˛˛˛˛˛˛
{:reader reader}∗
{:writer
writer
(setf writer)
ff}∗
{:accessor accessor}∗
:allocation
:instance:class
ff:instance
{:initarg :initarg-name}∗:initform form
:type type
:documentation slot-doc
9>>>>>>>>>>>>>=>>>>>>>>>>>>>;
)
9>>>>>>>>>>>>>>>=>>>>>>>>>>>>>>>;
∗
)
8<:
˛˛˛(:default-initargs {name value}∗)(:documentation class-doc)(:metaclass name standard-class )
9=;)
24
Common Lisp Quick Reference
13.2 Reader
(
Fuy-or-n-pFuyes-or-no-p
ff[control arg∗])
⊲ Ask user a question and return T or NIL depending on theiranswer. See p. 37,
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
ff ˆ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
ˆ8<:
˛˛˛:start start 0:end end NIL
:preserve-whitespace bool NIL
9=;
˜˜˜)
⊲ Return object read from string and zero-indexed2position
of next character.
(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 ifmode is a character, next instance of it, from stream withoutremoving 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 and
2T 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.
33
Common Lisp Quick Reference
(
MctypecaseMetypecase
fffoo ( dtype 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. ReturnNIL.
(Fustream-element-type stream) ⊲ Return type of stream objects.
(Fuarray-element-type array) ⊲ Element type array can hold.
(Fuupgraded-array-element-type type [environment NIL ])
⊲ Element type of most specialized array capable of holdingelements of type.
(Mdeftype foo (macro-λ∗) (declare ddecl∗)∗ [ddoc] form
P∗)⊲ Define type foo which when referenced as (foo carg∗) 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.)
32
Common Lisp Quick Reference
⊲ 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 (accessor i),and writeable via (writer i value) or (setf (accessor i) value).With :allocation :class, slot is shared by all instances of classfoo.
(Fufind-class symbol
ˆerrorp T [environment ]
˜)
⊲ Return class named symbol . setfable.
(gFmake-instance class {:initarg value}∗ other-keyarg∗)
⊲ Return values of forms after evaluating them in a lexicalenvironment with slots of instance visible as setfable slots orvars/with accessor s of instance visible as setfable vars.
(gFclass-name class)
((setfgFclass-name) new-name class)
⊲ Get/set name of class .
(Fuclass-of foo) ⊲ Class foo is a direct instance of.
(:documentation string)(:generic-function-class class standard-generic-function )
(:method-class class standard-method )(:method-combination c-type standard c-arg∗)(:method defmethod-args)∗
9>>>>>>>>=>>>>>>>>;
)
⊲ Define generic function foo. defmethod-args resemble thoseof
Mdefmethod. For c-type see section 10.3.
(Fuensure-generic-function
foo
(setf foo)
ff
8>>>>>>>>><>>>>>>>>>:
˛˛˛˛˛˛˛˛
: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
9>>>>>>>>>=>>>>>>>>>;
)
⊲ Define or modify generic function foo.:generic-function-class and :lambda-list have to be com-patible 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)
ff[
8>><>>:
:before:after:aroundqualifier∗
9>>=>>;
primary method ]
(
8<:
var
(spec-var
class
(eql bar)
ff)
9=;
∗ˆ&optional
var
(varˆinit [supplied-p]
˜)
ff∗˜[&rest var ]
ˆ&key
8<:var
(
var
(:key var)
ffˆinit [supplied-p]
˜)
9=;
∗
[&allow-other-keys]˜
ˆ&aux
var
(var [init ])
ff∗˜)
(˛˛(declare ddecl∗)∗
ddoc
)form
P∗)
⊲ Define new method for generic function foo. spec-vars spe-cialize to either being of class or being eql bar , respectively.On invocation, vars and spec-vars of the new method act likeparameters of a function with body form∗. forms are en-closed in an implicit
sOblock foo. Applicable qualifiers depend
on the method-combination type; see section 10.3.
(
gFadd-methodgFremove-method
ffgeneric-function method)
⊲ Add (if necessary) or remove (if any) method to/fromgeneric-function.
(gFfind-method generic-function qualifiers specializers [error T ])
⊲ List of methods suitable for args, most specific first.
(Fucall-next-method arg∗
current args )⊲ From within a method, call next method with args; returnits values.
(gFno-applicable-method generic-function arg∗)
⊲ Called on invocation of generic-function on args if there isno applicable method. Default method signals error.
26
Common Lisp Quick Reference
Tato
m
readta
ble
pack
age
sym
bol
keyw
ord
boole
an
rest
art
random
-sta
te
hash
-table
stru
cture
-obje
ct
standar
d-o
bje
ct
null
class
built-
in-c
lass
standar
d-c
lass
stru
cture
-cla
ss
meth
od
standar
d-m
eth
od
meth
od-c
om
bin
ation
chara
cter
funct
ion
ˆ arg
-types
[valu
e-types]˜
com
piled-funct
ion
generic-
funct
ion
standar
d-g
eneric-
funct
ion
path
nam
e
logic
al-path
nam
enum
ber
com
ple
x[type
∗]
real
ˆ lower-
lim
it∗
[upper-
lim
it∗]˜
float
ˆ lower-
lim
it∗
[upper-
lim
it∗]˜
short
-float
ˆ lower-
lim
it∗
[upper-
lim
it∗]˜
single
-float
ˆ lower-
lim
it∗
[upper-
lim
it∗]˜
double
-float
ˆ lower-
lim
it∗
[upper-
lim
it∗]˜
long-fl
oat
ˆ lower-
lim
it∗
[upper-
lim
it∗]˜
rational
ˆ lower-
lim
it∗
[upper-
lim
it∗]˜
inte
ger
ˆ lower-
lim
it∗
[upper-
lim
it∗]˜
ratio
signed-b
yte
[size
∗]
fixn
um
big
num
unsigned-b
yte
[size
∗]
bit
list
sequence
cons
ˆ car-
type
∗[cdr-
type
∗]˜
arra
yˆ ty
pe
∗[rank
∗(d
imension∗)]
˜
sim
ple
-arr
ayˆ ty
pe
∗[rank
∗(d
imension∗)]
˜
vect
or
ˆ type
∗[size
∗]˜
string
[size
∗]
sim
ple
-str
ing
[size
∗]
base
-str
ing
[size
∗]
sim
ple
-base
-str
ing
[size
∗]
sim
ple
-vect
or
[size
∗]
bit-v
ect
or
[size
∗]
sim
ple
-bit-v
ect
or
[size
∗]
stre
am
file
-str
eam
two-w
ay-s
tream
synonym
-str
eam
string-s
tream
bro
adca
st-s
tream
conca
tenate
d-s
tream
ech
o-s
tream
ext
ended-c
har
base
-char
standar
d-c
har
conditio
n
serious-
conditio
nst
ora
ge-c
onditio
n
sim
ple
-typ
e-e
rror
type-e
rror
err
or pro
gra
m-e
rror
contr
ol-err
or
pack
age-e
rror
print-
not-
readable
stre
am
-err
or
par
se-e
rror
cell-e
rror
file
-err
or
arithm
etic-
err
or
sim
ple
-conditio
n
war
nin
g
styl
e-w
arnin
g
sim
ple
-err
or
sim
ple
-war
nin
g
end-o
f-file
reader-
err
or
unbound-v
ariable
undefined-funct
ion
unbound-s
lot
div
isio
n-b
y-ze
ro
floating-p
oin
t-in
exa
ct
floating-p
oin
t-ove
rflow
floating-p
oin
t-underfl
ow
floating-p
oin
t-in
valid-o
pera
tion
Figure 2: Precedence Order of System Classes ( ), Classes ( ),Types ( ), and Condition Types ( ).
31
Common Lisp Quick Reference
(
8>>><>>>:
FuabortFumuffle-warningFucontinueFustore-value valueFuuse-value value
9>>>=>>>;
[condition NIL ])
⊲ Transfer control to innermost applicable restart with samename (i.e. abort, . . . , continue . . . ) out of those either as-sociated with condition or un-associated at all; or, withoutcondition , out of all restarts. If no restart is found, signalcontrol-error for
Fuabort and
Fumuffle-warning, or return NIL for
the rest.
(Mwith-condition-restarts condition restarts form
P∗)⊲ Evaluate forms with restarts dynamically associated withcondition . Return values of forms.
(Fuarithmetic-error-operation condition)
(Fuarithmetic-error-operands condition)
⊲ List of function or of its operands respectively, used in theoperation 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, respec-
tively, 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 dtype form) ⊲ Declare values of form to be of type.
(Fucoerce object type) ⊲ Coerce object into type.
(Mtypecase foo ( dtype a-form
P∗)∗ˆ(
otherwiseT
ffb-form NIL
P∗)˜)
⊲ Return values of the a-forms whose type is foo of. Returnvalues of b-forms if no type matches.
⊲ Signal error on applicable method with invalid qualifiers,or on method combination. For control and args see format,p. 37.
(gFno-next-method generic-function method arg∗)
⊲ Called on invocation of call-next-method when there is nonext 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 if thereare any. If not, or if there are no :around methods at all, callall :before methods, most specific first, and the most spe-cific primary method which supplies the values of the callingFucall-next-method if any, or of the generic function; and whichcan call less specific primary methods via
Fucall-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.
⊲ Short Form. Define new method-combination c-type. Ina generic function using c-type, evaluate most specific:around method supplying the values of the generic func-tion. From within this method,
Fucall-next-method can
call less specific :around methods if there are any. Ifnot, or if there are no :around methods at all, re-turn from the calling call-next-method or from thegeneric function, respectively, the values of (operator(primary-method gen-arg∗)∗), gen-arg∗ being the argumentsof the generic function. The primary-methods are orderedˆ
⊲ Long Form. Define new method-combination c-type. A callto a generic function using c-type will be equivalent to a callto the forms returned by body∗ with ord-λ∗ bound to c-arg∗
(cf.Mdefgeneric), with symbol bound to the generic function,
with method-combination-λ∗ bound to the arguments of thegeneric function, and with groups bound to lists of meth-ods. An applicable method becomes a member of the left-most group whose predicate or qualifiers match. Methodscan be called via
Mcall-method. Lambda lists (ord-λ∗) and
(method-combination-λ∗) according to ord-λ on p. 17, thelatter enhanced by an optional &whole argument.
(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 31.
⊲ 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 (accessor i),and writeable via (writer i value) or (setf (accessor i) value).With :allocation :class, slot is shared by all conditions of typefoo. A condition is reported by string or by report-function
of arguments condition and stream.
(Fumake-condition type {:initarg-name value}∗)
⊲ Return new condition of type .
(
8<:
FusignalFuwarnFuerror
9=;
8<:condition
type {:initarg-name value}∗control arg∗
9=;)
⊲ Unless handled, signal as condition, warning or error,respectively, condition or a new condition of type or,with
Fuformat control and args (see p. 37), simple-condition,
simple-warning, or simple-error, respectively. FromFusignal and
Fuwarn, return NIL.
(Fucerror continue-control
8<:condition continue-arg∗
type {:initarg-name value}∗control arg∗
9=;)
⊲ Unless handled, signal as correctable error condition or anew condition of type or, with
Fuformat control and args (see
p. 37), 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 forms or, in case of errors, NIL and the
2condition.
28
Common Lisp Quick Reference
(Fuinvoke-debugger condition)
⊲ Invoke debugger with condition .
(Massert test
ˆ(place∗) [
8<:condition continue-arg∗
type {:initarg-name value}∗control arg∗
9=;]
˜)
⊲ 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. 37), error. When using
the debugger’s continue option, places can be altered beforere-evaluation of test. Return NIL.
⊲ 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, bindord-λs to values of foo and return values of forms or, withouta :no-error clause, return values of foo . See p. 17 for (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
ffcontrol arg∗) form
P∗)
⊲ Return values of forms unless restart is called during theirevaluation. In this case, describe restart using
Fuformat control
and args (see p. 37) and return NIL and2T.
(Mrestart-case form (foo (ord-λ∗)
8>><>>:
˛˛˛˛
:interactive arg-function
:report
report-function
string "foo"
:test test-function T
9>>=>>;
(declare ddecl∗)∗ 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 (of a stream)to print a description of restart foo and return the values ofits restart-forms. arg-function supplies appropriate args iffoo is called by
Fuinvoke-restart-interactively. If (test-function
condition) returns T, foo is made visible under condition .arg∗ matches (ord-λ∗); see p. 17 for the latter.
(Mrestart-bind ((
restart
NIL
ffrestart-function
8<:
˛˛˛:interactive-function function
:report-function function
:test-function function
9=;)∗) form
P∗)
⊲ Return values of forms evaluated with restarts dynamicallybound to restart-functions.
(Fuinvoke-restart restart arg∗)
(Fuinvoke-restart-interactively restart)
⊲ Call function associated with restart with arguments givenor prompted for, respectively. If restart function returns, re-turn its values.
(
Fucompute-restartsFufind-restart name
ff[condition ])
⊲ Return list of all restarts, or innermost restart name , re-spectively, out of those either associated with condition orun-associated at all; or, without condition , out of all restarts.Return NIL if search is unsuccessful.