This document describes a set of Emacs Lisp facilities borrowed from Common Lisp. All the facilities are described here in detail. While this document does not assume any prior knowledge of Common Lisp, it does assume a basic familiarity with Emacs Lisp.
Common Lisp is a huge language, and Common Lisp systems tend to be massive and extremely complex. Emacs Lisp, by contrast, is rather minimalist in the choice of Lisp features it offers the programmer. As Emacs Lisp programmers have grown in number, and the applications they write have grown more ambitious, it has become clear that Emacs Lisp could benefit from many of the conveniences of Common Lisp.
The CL package adds a number of Common Lisp functions and control structures to Emacs Lisp. While not a 100% complete implementation of Common Lisp, CL adds enough functionality to make Emacs Lisp programming significantly more convenient.
Some Common Lisp features have been omitted from this package for various reasons:
assoc
function is incompatible with the
Common Lisp assoc
. In such cases, this package usually
adds the suffix *
to the function name of the Common
Lisp version of the function (e.g., assoc*
).
The package described here was written by Dave Gillespie,
daveg@synaptics.com
. It is a total rewrite of the original
1986 cl.el
package by Cesar Quiroz. Most features of the
the Quiroz package have been retained; any incompatibilities are
noted in the descriptions below. Care has been taken in this
version to ensure that each function is defined efficiently,
concisely, and with minimal impact on the rest of the Emacs
environment.
Lisp code that uses features from the CL package should include at the beginning:
(require 'cl)
If you want to ensure that the new (Gillespie) version of CL
is the one that is present, add an additional (require 'cl-19)
call:
(require 'cl) (require 'cl-19)
The second call will fail (with "cl-19.el
not found") if
the old cl.el
package was in use.
It is safe to arrange to load CL at all times, e.g.,
in your .emacs
file. But it's a good idea, for portability,
to (require 'cl)
in your code even if you do this.
The Common Lisp package is organized into four files:
cl.el
cl-extra.el
cadr
function won't need to pay
the overhead of loading the more advanced functions.
cl-seq.el
delete-if
and assoc*
.
cl-macs.el
.emacs
file). Most of
the macros of this package are isolated in cl-macs.el
so
that they won't take up memory unless you are compiling.
The file cl.el
includes all necessary autoload
commands for the functions and macros in the other three files.
All you have to do is (require 'cl)
, and cl.el
will take care of pulling in the other files when they are
needed.
There is another file, cl-compat.el
, which defines some
routines from the older cl.el
package that are no longer
present in the new package. This includes internal routines
like setelt
and zip-lists
, deprecated features
like defkeyword
, and an emulation of the old-style
multiple-values feature. See Old CL Compatibility.
Installation of the CL package is simple: Just put the
byte-compiled files cl.elc
, cl-extra.elc
,
cl-seq.elc
, cl-macs.elc
, and cl-compat.elc
into a directory on your load-path
.
There are no special requirements to compile this package: The files do not have to be loaded before they are compiled, nor do they need to be compiled in any particular order.
You may choose to put the files into your main lisp/
directory, replacing the original cl.el
file there. Or,
you could put them into a directory that comes before lisp/
on your load-path
so that the old cl.el
is
effectively hidden.
Also, format the cl.texinfo
file and put the resulting
Info files in the info/
directory or another suitable place.
You may instead wish to leave this package's components all in
their own directory, and then add this directory to your
load-path
and (Emacs 19 only) Info-directory-list
.
Add the directory to the front of the list so the old CL
package and its documentation are hidden.
Except where noted, all functions defined by this package have the same names and calling conventions as their Common Lisp counterparts.
Following is a complete list of functions whose names were changed
from Common Lisp, usually to avoid conflicts with Emacs. In each
case, a *
has been appended to the Common Lisp name to obtain
the Emacs name:
defun* defsubst* defmacro* function* member* assoc* rassoc* get* remove* delete* mapcar* sort* floor* ceiling* truncate* round* mod* rem* random* last*
Internal function and variable names in the package are prefixed
by cl-
. Here is a complete list of functions not
prefixed by cl-
which were not taken from Common Lisp:
member delete remove remq rassoc floatp-safe lexical-let lexical-let* callf callf2 letf letf* defsubst* defalias add-hook eval-when-compile
(Most of these are Emacs 19 features provided to Emacs 18 users,
or introduced, like remq
, for reasons of symmetry
with similar features.)
The following simple functions and macros are defined in cl.el
;
they do not cause other components like cl-extra
to be loaded.
eql floatp-safe abs endp evenp oddp plusp minusp butlast nbutlast caar .. cddddr list* ldiff rest first .. tenth member [1] copy-list subst mapcar* [2] adjoin [3] acons pairlis when unless pop [4] push [4] pushnew [3,4] incf [4] decf [4] proclaim declaim add-hook
[1] This is the Emacs 19-compatible function, not member*
.
[2] Only for one sequence argument or two list arguments.
[3] Only if :test
is eq
, equal
, or unspecified,
and :key
is not used.
[4] Only when place is a plain variable name.
This section describes features of the CL package which have to
do with programs as a whole: advanced argument lists for functions,
and the eval-when
construct.
Emacs Lisp's notation for argument lists of functions is a subset of
the Common Lisp notation. As well as the familiar &optional
and &rest
markers, Common Lisp allows you to specify default
values for optional arguments, and it provides the additional markers
&key
and &aux
.
Since argument parsing is built-in to Emacs, there is no way for this package to implement Common Lisp argument lists seamlessly. Instead, this package defines alternates for several Lisp forms which you must use if you need Common Lisp argument lists.
defun* name arglist body... | Special Form |
This form is identical to the regular defun form, except
that arglist is allowed to be a full Common Lisp argument
list. Also, the function body is enclosed in an implicit block
called name; see Blocks and Exits.
|
defsubst* name arglist body... | Special Form |
This is just like defun* , except that the function that
is defined is automatically proclaimed inline , i.e.,
calls to it may be expanded into in-line code by the byte compiler.
This is analogous to the defsubst form in Emacs 19;
defsubst* uses a different method (compiler macros) which
works in all version of Emacs, and also generates somewhat more
efficient inline expansions. In particular, defsubst*
arranges for the processing of keyword arguments, default values,
etc., to be done at compile-time whenever possible.
|
defmacro* name arglist body... | Special Form |
This is identical to the regular defmacro form,
except that arglist is allowed to be a full Common Lisp
argument list. The &environment keyword is supported as
described in Steele. The &whole keyword is supported only
within destructured lists (see below); top-level &whole
cannot be implemented with the current Emacs Lisp interpreter.
The macro expander body is enclosed in an implicit block called
name.
|
function* symbol-or-lambda | Special Form |
This is identical to the regular function form,
except that if the argument is a lambda form then that
form may use a full Common Lisp argument list.
|
Also, all forms (such as defsetf
and flet
) defined
in this package that include arglists in their syntax allow
full Common Lisp argument lists.
Note that it is not necessary to use defun*
in
order to have access to most CL features in your function.
These features are always present; defun*
's only
difference from defun
is its more flexible argument
lists and its implicit block.
The full form of a Common Lisp argument list is
(var... &optional (var initform svar)... &rest var &key ((keyword var) initform svar)... &aux (var initform)...)
Each of the five argument list sections is optional. The svar,
initform, and keyword parts are optional; if they are
omitted, then (var)
may be written simply var
.
The first section consists of zero or more required arguments. These arguments must always be specified in a call to the function; there is no difference between Emacs Lisp and Common Lisp as far as required arguments are concerned.
The second section consists of optional arguments. These
arguments may be specified in the function call; if they are not,
initform specifies the default value used for the argument.
(No initform means to use nil
as the default.) The
initform is evaluated with the bindings for the preceding
arguments already established; (a &optional (b (1+ a)))
matches one or two arguments, with the second argument defaulting
to one plus the first argument. If the svar is specified,
it is an auxiliary variable which is bound to t
if the optional
argument was specified, or to nil
if the argument was omitted.
If you don't use an svar, then there will be no way for your
function to tell whether it was called with no argument, or with
the default value passed explicitly as an argument.
The third section consists of a single rest argument. If
more arguments were passed to the function than are accounted for
by the required and optional arguments, those extra arguments are
collected into a list and bound to the "rest" argument variable.
Common Lisp's &rest
is equivalent to that of Emacs Lisp.
Common Lisp accepts &body
as a synonym for &rest
in
macro contexts; this package accepts it all the time.
The fourth section consists of keyword arguments. These are optional arguments which are specified by name rather than positionally in the argument list. For example,
(defun* foo (a &optional b &key c d (e 17)))
defines a function which may be called with one, two, or more
arguments. The first two arguments are bound to a
and
b
in the usual way. The remaining arguments must be
pairs of the form :c
, :d
, or :e
followed
by the value to be bound to the corresponding argument variable.
(Symbols whose names begin with a colon are called keywords,
and they are self-quoting in the same way as nil
and
t
.)
For example, the call (foo 1 2 :d 3 :c 4)
sets the five
arguments to 1, 2, 4, 3, and 17, respectively. If the same keyword
appears more than once in the function call, the first occurrence
takes precedence over the later ones. Note that it is not possible
to specify keyword arguments without specifying the optional
argument b
as well, since (foo 1 :c 2)
would bind
b
to the keyword :c
, then signal an error because
2
is not a valid keyword.
If a keyword symbol is explicitly specified in the argument list as shown in the above diagram, then that keyword will be used instead of just the variable name prefixed with a colon. You can specify a keyword symbol which does not begin with a colon at all, but such symbols will not be self-quoting; you will have to quote them explicitly with an apostrophe in the function call.
Ordinarily it is an error to pass an unrecognized keyword to
a function, e.g., (foo 1 2 :c 3 :goober 4)
. You can ask
Lisp to ignore unrecognized keywords, either by adding the
marker &allow-other-keys
after the keyword section
of the argument list, or by specifying an :allow-other-keys
argument in the call whose value is non-nil
. If the
function uses both &rest
and &key
at the same time,
the "rest" argument is bound to the keyword list as it appears
in the call. For example:
(defun* find-thing (thing &rest rest &key need &allow-other-keys) (or (apply 'member* thing thing-list :allow-other-keys t rest) (if need (error "Thing not found"))))
This function takes a :need
keyword argument, but also
accepts other keyword arguments which are passed on to the
member*
function. allow-other-keys
is used to
keep both find-thing
and member*
from complaining
about each others' keywords in the arguments.
As a (significant) performance optimization, this package
implements the scan for keyword arguments by calling memq
to search for keywords in a "rest" argument. Technically
speaking, this is incorrect, since memq
looks at the
odd-numbered values as well as the even-numbered keywords.
The net effect is that if you happen to pass a keyword symbol
as the value of another keyword argument, where that
keyword symbol happens to equal the name of a valid keyword
argument of the same function, then the keyword parser will
become confused. This minor bug can only affect you if you
use keyword symbols as general-purpose data in your program;
this practice is strongly discouraged in Emacs Lisp.
The fifth section of the argument list consists of auxiliary
variables. These are not really arguments at all, but simply
variables which are bound to nil
or to the specified
initforms during execution of the function. There is no
difference between the following two functions, except for a
matter of stylistic taste:
(defun* foo (a b &aux (c (+ a b)) d) body) (defun* foo (a b) (let ((c (+ a b)) d) body))
Argument lists support destructuring. In Common Lisp,
destructuring is only allowed with defmacro
; this package
allows it with defun*
and other argument lists as well.
In destructuring, any argument variable (var in the above
diagram) can be replaced by a list of variables, or more generally,
a recursive argument list. The corresponding argument value must
be a list whose elements match this recursive argument list.
For example:
(defmacro* dolist ((var listform &optional resultform) &rest body) ...)
This says that the first argument of dolist
must be a list
of two or three items; if there are other arguments as well as this
list, they are stored in body
. All features allowed in
regular argument lists are allowed in these recursive argument lists.
In addition, the clause &whole var
is allowed at the
front of a recursive argument list. It binds var to the
whole list being matched; thus (&whole all a b)
matches
a list of two things, with a
bound to the first thing,
b
bound to the second thing, and all
bound to the
list itself. (Common Lisp allows &whole
in top-level
defmacro
argument lists as well, but Emacs Lisp does not
support this usage.)
One last feature of destructuring is that the argument list may be
dotted, so that the argument list (a b . c)
is functionally
equivalent to (a b &rest c)
.
If the optimization quality safety
is set to 0
(see Declarations), error checking for wrong number of
arguments and invalid keyword arguments is disabled. By default,
argument lists are rigorously checked.
Normally, the byte-compiler does not actually execute the forms in
a file it compiles. For example, if a file contains (setq foo t)
,
the act of compiling it will not actually set foo
to t
.
This is true even if the setq
was a top-level form (i.e., not
enclosed in a defun
or other form). Sometimes, though, you
would like to have certain top-level forms evaluated at compile-time.
For example, the compiler effectively evaluates defmacro
forms
at compile-time so that later parts of the file can refer to the
macros that are defined.
eval-when (situations...) forms... | Special Form |
This form controls when the body forms are evaluated.
The situations list may contain any set of the symbols
compile , load , and eval (or their long-winded
ANSI equivalents, :compile-toplevel , :load-toplevel ,
and :execute ).
The For compiled top-level For non-compiled-top-level forms, only the The rules become more subtle when Some simple examples: ;; Top-level forms in foo.el: (eval-when (compile) (setq foo1 'bar)) (eval-when (load) (setq foo2 'bar)) (eval-when (compile load) (setq foo3 'bar)) (eval-when (eval) (setq foo4 'bar)) (eval-when (eval compile) (setq foo5 'bar)) (eval-when (eval load) (setq foo6 'bar)) (eval-when (eval compile load) (setq foo7 'bar)) When foo1 foo3 foo5 foo7 ; `compile' When foo2 foo3 foo6 foo7 ; `load' And if foo4 foo5 foo6 foo7 ; `eval' If these seven Note that |
Emacs 19 includes two special forms related to eval-when
.
One of these, eval-when-compile
, is not quite equivalent to
any eval-when
construct and is described below. This package
defines a version of eval-when-compile
for the benefit of
Emacs 18 users.
The other form, (eval-and-compile ...)
, is exactly
equivalent to (eval-when (compile load eval) ...)
and
so is not itself defined by this package.
eval-when-compile forms... | Special Form |
The forms are evaluated at compile-time; at execution time,
this form acts like a quoted constant of the resulting value. Used
at top-level, eval-when-compile is just like eval-when
(compile eval) . In other contexts, eval-when-compile
allows code to be evaluated once at compile-time for efficiency
or other reasons.
This form is similar to the |
load-time-value form | Special Form |
The form is evaluated at load-time; at execution time,
this form acts like a quoted constant of the resulting value.
Early Common Lisp had a In a compiled file, (defun report () (insert "This function was executed on: " (current-time-string) ", compiled on: " (eval-when-compile (current-time-string)) ;; or '#.(current-time-string) in real Common Lisp ", and loaded on: " (load-time-value (current-time-string)))) Byte-compiled, the above defun will result in the following code
(or its compiled equivalent, of course) in the (setq --temp-- (current-time-string)) (defun report () (insert "This function was executed on: " (current-time-string) ", compiled on: " '"Wed Jun 23 18:33:43 1993" ", and loaded on: " --temp--)) |
This section describes a feature from GNU Emacs 19 which this package makes available in other versions of Emacs.
defalias symbol function | Function |
This function sets symbol's function cell to function.
It is equivalent to fset , except that in GNU Emacs 19 it also
records the setting in load-history so that it can be undone
by a later unload-feature .
In other versions of Emacs, |
This section describes functions for testing whether various facts are true or false.
The CL package defines a version of the Common Lisp typep
predicate.
typep object type | Function |
Check if object is of type type, where type is a
(quoted) type name of the sort used by Common Lisp. For example,
(typep foo 'integer) is equivalent to (integerp foo) .
|
The type argument to the above function is either a symbol or a list beginning with a symbol.
-p
to the
symbol name to form the name of a predicate function for testing
the type. (Built-in predicates whose names end in p
rather
than -p
are used when appropriate.)
t
stands for the union of all types.
(typep object t)
is always true. Likewise, the
type symbol nil
stands for nothing at all, and
(typep object nil)
is always false.
null
represents the symbol nil
.
Thus (typep object 'null)
is equivalent to
(null object)
.
real
is a synonym for number
, and
fixnum
is a synonym for integer
.
character
and string-char
match
integers in the range from 0 to 255.
float
uses the floatp-safe
predicate
defined by this package rather than floatp
, so it will work
correctly even in Emacs versions without floating-point support.
(integer low high)
represents all
integers between low and high, inclusive. Either bound
may be a list of a single integer to specify an exclusive limit,
or a *
to specify no limit. The type (integer * *)
is thus equivalent to integer
.
float
, real
, or
number
represent numbers of that type falling in a particular
range.
and
, or
, and not
form
combinations of types. For example, (or integer (float 0 *))
represents all objects that are integers or non-negative floats.
member
or member*
represent
objects eql
to any of the following values. For example,
(member 1 2 3 4)
is equivalent to (integer 1 4)
,
and (member nil)
is equivalent to null
.
(satisfies predicate)
represent
all objects for which predicate returns true when called
with that object as an argument.
The following function and macro (not technically predicates) are
related to typep
.
coerce object type | Function |
This function attempts to convert object to the specified
type. If object is already of that type as determined by
typep , it is simply returned. Otherwise, certain types of
conversions will be made: If type is any sequence type
(string , list , etc.) then object will be
converted to that type if possible. If type is
character , then strings of length one and symbols with
one-character names can be coerced. If type is float ,
then integers can be coerced in versions of Emacs that support
floats. In all other circumstances, coerce signals an
error.
|
deftype name arglist forms... | Special Form |
This macro defines a new type called name. It is similar
to defmacro in many ways; when name is encountered
as a type name, the body forms are evaluated and should
return a type specifier that is equivalent to the type. The
arglist is a Common Lisp argument list of the sort accepted
by defmacro* . The type specifier (name args...)
is expanded by calling the expander with those arguments; the type
symbol name is expanded by calling the expander with
no arguments. The arglist is processed the same as for
defmacro* except that optional arguments without explicit
defaults use * instead of nil as the "default"
default. Some examples:
(deftype null () '(satisfies null)) ; predefined (deftype list () '(or null cons)) ; predefined (deftype unsigned-byte (&optional bits) (list 'integer 0 (if (eq bits '*) bits (1- (lsh 1 bits))))) (unsigned-byte 8) == (integer 0 255) (unsigned-byte) == (integer 0 *) unsigned-byte == (integer 0 *) The last example shows how the Common Lisp |
The typecase
and check-type
macros also use type
names. See Conditionals. See Assertions. The map
,
concatenate
, and merge
functions take type-name
arguments to specify the type of sequence to return. See Sequences.
This package defines two Common Lisp predicates, eql
and
equalp
.
eql a b | Function |
This function is almost the same as eq , except that if a
and b are numbers of the same type, it compares them for numeric
equality (as if by equal instead of eq ). This makes a
difference only for versions of Emacs that are compiled with
floating-point support, such as Emacs 19. Emacs floats are allocated
objects just like cons cells, which means that (eq 3.0 3.0)
will not necessarily be true--if the two 3.0 s were allocated
separately, the pointers will be different even though the numbers are
the same. But (eql 3.0 3.0) will always be true.
The types of the arguments must match, so Note that Emacs integers are "direct" rather than allocated, which
basically means There is a slight inconsistency with Common Lisp in the treatment of
positive and negative zeros. Some machines, notably those with IEEE
standard arithmetic, represent |
equalp a b | Function |
This function is a more flexible version of equal . In
particular, it compares strings case-insensitively, and it compares
numbers without regard to type (so that (equalp 3 3.0) is
true). Vectors and conses are compared recursively. All other
objects are compared as if by equal .
This function differs from Common Lisp |
Also note that the Common Lisp functions member
and assoc
use eql
to compare elements, whereas Emacs Lisp follows the
MacLisp tradition and uses equal
for these two functions.
In Emacs, use member*
and assoc*
to get functions
which use eql
for comparisons.
The features described in the following sections implement
various advanced control structures, including the powerful
setf
facility and a number of looping and conditional
constructs.
The psetq
form is just like setq
, except that multiple
assignments are done in parallel rather than sequentially.
psetq [symbol form]... | Special Form |
This special form (actually a macro) is used to assign to several
variables simultaneously. Given only one symbol and form,
it has the same effect as setq . Given several symbol
and form pairs, it evaluates all the forms in advance
and then stores the corresponding variables afterwards.
(setq x 2 y 3) (setq x (+ x y) y (* x y)) x => 5 y ; The simplest use of
|
A "generalized variable" or "place form" is one of the many places in Lisp memory where values can be stored. The simplest place form is a regular Lisp variable. But the cars and cdrs of lists, elements of arrays, properties of symbols, and many other locations are also places where Lisp values are stored.
The setf
form is like setq
, except that it accepts
arbitrary place forms on the left side rather than just
symbols. For example, (setf (car a) b)
sets the car of
a
to b
, doing the same operation as (setcar a b)
but without having to remember two separate functions for setting
and accessing every type of place.
Generalized variables are analogous to "lvalues" in the C
language, where x = a[i]
gets an element from an array
and a[i] = x
stores an element using the same notation.
Just as certain forms like a[i]
can be lvalues in C, there
is a set of forms that can be generalized variables in Lisp.
The setf
macro is the most basic way to operate on generalized
variables.
setf [place form]... | Special Form |
This macro evaluates form and stores it in place, which
must be a valid generalized variable form. If there are several
place and form pairs, the assignments are done sequentially
just as with setq . setf returns the value of the last
form.
The following Lisp forms will work as generalized variables, and
so may legally appear in the place argument of
Using any forms other than these in the place argument to
The (setf (aref vec (incf i)) i) looks like it will evaluate However, if the place form is a macro which explicitly evaluates its arguments in an unusual order, this unusual order will be preserved. Adapting an example from Steele, given (defmacro wrong-order (x y) (list 'aref y x)) the form |
This package defines a number of other macros besides setf
that operate on generalized variables. Many are interesting and
useful even when the place is just a variable name.
psetf [place form]... | Special Form |
This macro is to setf what psetq is to setq :
When several places and forms are involved, the
assignments take place in parallel rather than sequentially.
Specifically, all subforms are evaluated from left to right, then
all the assignments are done (in an undefined order).
|
incf place &optional x | Special Form |
This macro increments the number stored in place by one, or
by x if specified. The incremented value is returned. For
example, (incf i) is equivalent to (setq i (1+ i)) , and
(incf (car x) 2) is equivalent to (setcar x (+ (car x) 2)) .
Once again, care is taken to preserve the "apparent" order of evaluation. For example, (incf (aref vec (incf i))) appears to increment (setf (aref vec (incf i)) (1+ (aref vec (incf i)))) ; Wrong! but rather to something more like (let ((temp (incf i))) (setf (aref vec temp) (1+ (aref vec temp)))) Again, all of this is taken care of automatically by As a more Emacs-specific example of |
decf place &optional x | Special Form |
This macro decrements the number stored in place by one, or by x if specified. |
pop place | Special Form |
This macro removes and returns the first element of the list stored
in place. It is analogous to (prog1 (car place)
(setf place (cdr place))) , except that it takes care
to evaluate all subforms only once.
|
push x place | Special Form |
This macro inserts x at the front of the list stored in
place. It is analogous to (setf place (cons
x place)) , except for evaluation of the subforms.
|
pushnew x place &key :test :test-not :key | Special Form |
This macro inserts x at the front of the list stored in
place, but only if x was not eql to any
existing element of the list. The optional keyword arguments
are interpreted in the same way as for adjoin .
See Lists as Sets.
|
shiftf place... newvalue | Special Form |
This macro shifts the places left by one, shifting in the
value of newvalue (which may be any Lisp expression, not just
a generalized variable), and returning the value shifted out of
the first place. Thus, (shiftf a b c
d) is equivalent to
(prog1 a (psetf a b b c c d)) except that the subforms of a, b, and c are actually evaluated only once each and in the apparent order. |
rotatef place... | Special Form |
This macro rotates the places left by one in circular fashion.
Thus, (rotatef a b c d) is equivalent to
(psetf a b b c c d d a) except for the evaluation of subforms. |
The following macros were invented for this package; they have no analogues in Common Lisp.
letf (bindings...) forms... | Special Form |
This macro is analogous to let , but for generalized variables
rather than just symbols. Each binding should be of the form
(place value) ; the original contents of the
places are saved, the values are stored in them, and
then the body forms are executed. Afterwards, the places
are set back to their original saved contents. This cleanup happens
even if the forms exit irregularly due to a throw or an
error.
For example, (letf (((point) (point-min)) (a 17)) ...) moves "point" in the current buffer to the beginning of the buffer,
and also binds Note that Since generalized variables look like lists, However, a binding specifier may be a one-element list
In most cases, the place must have a well-defined value on
entry to the |
letf* (bindings...) forms... | Special Form |
This macro is to letf what let* is to let :
It does the bindings in sequential rather than parallel order.
|
callf function place args... | Special Form |
This is the "generic" modify macro. It calls function,
which should be an unquoted function name, macro name, or lambda.
It passes place and args as arguments, and assigns the
result back to place. For example, (incf place
n) is the same as (callf + place n) .
Some more examples:
(callf abs my-number) (callf concat (buffer-name) "<" (int-to-string n) ">") (callf union happy-people (list joe bob) :test 'same-person) See Customizing Setf, for |
callf2 function arg1 place args... | Special Form |
This macro is like callf , except that place is
the second argument of function rather than the
first. For example, (push x place) is
equivalent to (callf2 cons x place) .
|
The callf
and callf2
macros serve as building
blocks for other macros like incf
, pushnew
, and
define-modify-macro
. The letf
and letf*
macros are used in the processing of symbol macros;
see Macro Bindings.
Common Lisp defines three macros, define-modify-macro
,
defsetf
, and define-setf-method
, that allow the
user to extend generalized variables in various ways.
define-modify-macro name arglist function [doc-string] | Special Form |
This macro defines a "read-modify-write" macro similar to
incf and decf . The macro name is defined
to take a place argument followed by additional arguments
described by arglist. The call
(name place args...) will be expanded to (callf func place args...) which in turn is roughly equivalent to (setf place (func place args...)) For example: (define-modify-macro incf (&optional (n 1)) +) (define-modify-macro concatf (&rest args) concat) Note that Most of the modify macros defined by Common Lisp do not exactly
follow the pattern of |
defsetf access-fn update-fn | Special Form |
This is the simpler of two defsetf forms. Where
access-fn is the name of a function which accesses a place,
this declares update-fn to be the corresponding store
function. From now on,
(setf (access-fn arg1 arg2 arg3) value) will be expanded to (update-fn arg1 arg2 arg3 value) The update-fn is required to be either a true function, or
a macro which evaluates its arguments in a function-like way. Also,
the update-fn is expected to return value as its result.
Otherwise, the above expansion would not obey the rules for the way
As a special (non-Common-Lisp) extension, a third argument of (let ((temp value)) (update-fn arg1 arg2 arg3 temp) temp) Some examples of the use of (defsetf car setcar) (defsetf symbol-value set) (defsetf buffer-name rename-buffer t) |
defsetf access-fn arglist (store-var) forms... | Special Form |
This is the second, more complex, form of defsetf . It is
rather like defmacro except for the additional store-var
argument. The forms should return a Lisp form which stores
the value of store-var into the generalized variable formed
by a call to access-fn with arguments described by arglist.
The forms may begin with a string which documents the setf
method (analogous to the doc string that appears at the front of a
function).
For example, the simple form of (defsetf access-fn (&rest args) (store) (append '(update-fn) args (list store))) The Lisp form that is returned can access the arguments from
arglist and store-var in an unrestricted fashion;
macros like Another example drawn from the standard package: (defsetf nth (n x) (store) (list 'setcar (list 'nthcdr n x) store)) |
define-setf-method access-fn arglist forms... | Special Form |
This is the most general way to create new place forms. When
a setf to access-fn with arguments described by
arglist is expanded, the forms are evaluated and
must return a list of five items:
This is exactly like the Common Lisp macro of the same name, except that the method returns a list of five values rather than the five values themselves, since Emacs Lisp does not support Common Lisp's notion of multiple return values. Once again, the forms may begin with a documentation string. A setf-method should be maximally conservative with regard to
temporary variables. In the setf-methods generated by
|
get-setf-method place &optional env | Function |
This function returns the setf-method for place, by
invoking the definition previously recorded by defsetf
or define-setf-method . The result is a list of five
values as described above. You can use this function to build
your own incf -like modify macros. (Actually, it is
better to use the internal functions cl-setf-do-modify
and cl-setf-do-store , which are a bit easier to use and
which also do a number of optimizations; consult the source
code for the incf function for a simple example.)
The argument env specifies the "environment" to be
passed on to See also the source code for the setf-methods for |
Modern Common Lisp defines a second, independent way to specify
the setf
behavior of a function, namely "setf
functions" whose names are lists (setf name)
rather than symbols. For example, (defun (setf foo) ...)
defines the function that is used when setf
is applied to
foo
. This package does not currently support setf
functions. In particular, it is a compile-time error to use
setf
on a form which has not already been defsetf
'd
or otherwise declared; in newer Common Lisps, this would not be
an error since the function (setf func)
might be
defined later.
These Lisp forms make bindings to variables and function names,
analogous to Lisp's built-in let
form.
See Modify Macros, for the letf
and letf*
forms which
are also related to variable bindings.
The standard let
form binds variables whose names are known
at compile-time. The progv
form provides an easy way to
bind variables whose names are computed at run-time.
progv symbols values forms... | Special Form |
This form establishes let -style variable bindings on a
set of variables computed at run-time. The expressions
symbols and values are evaluated, and must return lists
of symbols and values, respectively. The symbols are bound to the
corresponding values for the duration of the body forms.
If values is shorter than symbols, the last few symbols
are made unbound (as if by makunbound ) inside the body.
If symbols is shorter than values, the excess values
are ignored.
|
The CL package defines the following macro which
more closely follows the Common Lisp let
form:
lexical-let (bindings...) forms... | Special Form |
This form is exactly like let except that the bindings it
establishes are purely lexical. Lexical bindings are similar to
local variables in a language like C: Only the code physically
within the body of the lexical-let (after macro expansion)
may refer to the bound variables.
(setq a 5) (defun foo (b) (+ a b)) (let ((a 2)) (foo a)) => 4 (lexical-let ((a 2)) (foo a)) => 7 In this example, a regular The most important use of lexical bindings is to create closures. A closure is a function object that refers to an outside lexical variable. For example: (defun make-adder (n) (lexical-let ((n n)) (function (lambda (m) (+ n m))))) (setq add17 (make-adder 17)) (funcall add17 4) => 21 The call (defun make-counter () (lexical-let ((n 0)) (function* (lambda (&optional (m 1)) (incf n m))))) (setq count-1 (make-counter)) (funcall count-1 3) => 3 (funcall count-1 14) => 17 (setq count-2 (make-counter)) (funcall count-2 5) => 5 (funcall count-1 2) => 19 (funcall count-2) => 6 Here we see that each call to Closed-over lexical variables persist until the last reference to
them goes away, just like all other Lisp objects. For example,
Many closures are used only during the extent of the bindings they
refer to; these are known as "downward funargs" in Lisp parlance.
When a closure is used in this way, regular Emacs Lisp dynamic
bindings suffice and will be more efficient than (defun add-to-list (x list) (mapcar (function (lambda (y) (+ x y))) list)) (add-to-list 7 '(1 2 5)) => (8 9 12) Since this lambda is only used while You can use The |
lexical-let* (bindings...) forms... | Special Form |
This form is just like lexical-let , except that the bindings
are made sequentially in the manner of let* .
|
These forms make let
-like bindings to functions instead
of variables.
flet (bindings...) forms... | Special Form |
This form establishes let -style bindings on the function
cells of symbols rather than on the value cells. Each binding
must be a list of the form (name arglist
forms...) , which defines a function exactly as if
it were a defun* form. The function name is defined
accordingly for the duration of the body of the flet ; then
the old function definition, or lack thereof, is restored.
While You can use (flet ((message (&rest args) (push args saved-msgs))) (do-something)) This code attempts to replace the built-in function Functions defined by |
labels (bindings...) forms... | Special Form |
The labels form is like flet , except that it
makes lexical bindings of the function names rather than
dynamic bindings. (In true Common Lisp, both flet and
labels make lexical bindings of slightly different sorts;
since Emacs Lisp is dynamically bound by default, it seemed
more appropriate for flet also to use dynamic binding.
The labels form, with its lexical binding, is fully
compatible with Common Lisp.)
Lexical scoping means that all references to the named
functions must appear physically within the body of the
A "reference" to a function name is either a call to that
function, or a use of its name quoted by |
These forms create local macros and "symbol macros."
macrolet (bindings...) forms... | Special Form |
This form is analogous to flet , but for macros instead of
functions. Each binding is a list of the same form as the
arguments to defmacro* (i.e., a macro name, argument list,
and macro-expander forms). The macro is defined accordingly for
use within the body of the macrolet .
Because of the nature of macros, |
symbol-macrolet (bindings...) forms... | Special Form |
This form creates symbol macros, which are macros that look
like variable references rather than function calls. Each
binding is a list (var expansion) ;
any reference to var within the body forms is
replaced by expansion.
(setq bar '(5 . 9)) (symbol-macrolet ((foo (car bar))) (incf foo)) bar => (6 . 9) A Likewise, a There is no analogue of (defmacro* my-dolist ((x list) &rest body) (let ((var (gensym))) (list 'loop 'for var 'on list 'do (list* 'symbol-macrolet (list (list x (list 'car var))) body)))) (setq mylist '(1 2 3 4)) (my-dolist (x mylist) (incf x)) mylist => (2 3 4 5) In this example, the (loop for G1234 on mylist do (symbol-macrolet ((x (car G1234))) (incf x))) which in turn expands to (loop for G1234 on mylist do (incf (car G1234))) See Loop Facility, for a description of the |
These conditional forms augment Emacs Lisp's simple if
,
and
, or
, and cond
forms.
when test forms... | Special Form |
This is a variant of if where there are no "else" forms,
and possibly several "then" forms. In particular,
(when test a b c) is entirely equivalent to (if test (progn a b c) nil) |
unless test forms... | Special Form |
This is a variant of if where there are no "then" forms,
and possibly several "else" forms:
(unless test a b c) is entirely equivalent to (when (not test) a b c) |
case keyform clause... | Special Form |
This macro evaluates keyform, then compares it with the key
values listed in the various clauses. Whichever clause matches
the key is executed; comparison is done by eql . If no clause
matches, the case form returns nil . The clauses are
of the form
(keylist body-forms...) where keylist is a list of key values. If there is exactly
one value, and it is not a cons cell or the symbol For example, this expression reads a keystroke, then does one of
four things depending on whether it is an (case (read-char) (?a (do-a-thing)) (?b (do-b-thing)) ((?\r ?\n) (do-ret-thing)) (t (do-other-thing))) |
ecase keyform clause... | Special Form |
This macro is just like case , except that if the key does
not match any of the clauses, an error is signaled rather than
simply returning nil .
|
typecase keyform clause... | Special Form |
This macro is a version of case that checks for types
rather than values. Each clause is of the form
(type body...) . See Type Predicates,
for a description of type specifiers. For example,
(typecase x (integer (munch-integer x)) (float (munch-float x)) (string (munch-integer (string-to-int x))) (t (munch-anything x))) The type specifier |
etypecase keyform clause... | Special Form |
This macro is just like typecase , except that if the key does
not match any of the clauses, an error is signaled rather than
simply returning nil .
|
Common Lisp blocks provide a non-local exit mechanism very
similar to catch
and throw
, but lexically rather than
dynamically scoped. This package actually implements block
in terms of catch
; however, the lexical scoping allows the
optimizing byte-compiler to omit the costly catch
step if the
body of the block does not actually return-from
the block.
block name forms... | Special Form |
The forms are evaluated as if by a progn . However,
if any of the forms execute (return-from name) ,
they will jump out and return directly from the block form.
The block returns the result of the last form unless
a return-from occurs.
The In true Common Lisp, The Common Lisp looping constructs defined by this package,
such as Because they are implemented in terms of Emacs Lisp |
return-from name [result] | Special Form |
This macro returns from the block named name, which must be
an (unevaluated) symbol. If a result form is specified, it
is evaluated to produce the result returned from the block .
Otherwise, nil is returned.
|
return [result] | Special Form |
This macro is exactly like (return-from nil result) .
Common Lisp loops like do and dolist implicitly enclose
themselves in nil blocks.
|
The macros described here provide more sophisticated, high-level
looping constructs to complement Emacs Lisp's basic while
loop.
loop forms... | Special Form |
The CL package supports both the simple, old-style meaning of
loop and the extremely powerful and flexible feature known as
the Loop Facility or Loop Macro. This more advanced
facility is discussed in the following section; see Loop Facility.
The simple form of loop is described here.
If (loop (foo) (if (no-more) (return 72)) (bar)) is exactly equivalent to (block nil (while t (foo) (if (no-more) (return 72)) (bar))) If any of the expressions are plain symbols, the loop is instead interpreted as a Loop Macro specification as described later. (This is not a restriction in practice, since a plain symbol in the above notation would simply access and throw away the value of a variable.) |
do (spec...) (end-test [result...]) forms... | Special Form |
This macro creates a general iterative loop. Each spec is
of the form
(var [init [step]]) The loop works as follows: First, each var is bound to the
associated init value as if by a The entire If there are no result forms, the loop returns This example (from Steele) illustrates a loop which applies the
function (do ((x foo (cdr x)) (y bar (cdr y)) (z nil (cons (f (car x) (car y)) z))) ((or (null x) (null y)) (nreverse z))) |
do* (spec...) (end-test [result...]) forms... | Special Form |
This is to do what let* is to let . In
particular, the initial values are bound as if by let*
rather than let , and the steps are assigned as if by
setq rather than psetq .
Here is another way to write the above loop: (do* ((xp foo (cdr xp)) (yp bar (cdr yp)) (x (car xp) (car xp)) (y (car yp) (car yp)) z) ((or (null xp) (null yp)) (nreverse z)) (push (f x y) z)) |
dolist (var list [result]) forms... | Special Form |
This is a more specialized loop which iterates across the elements
of a list. list should evaluate to a list; the body forms
are executed with var bound to each element of the list in
turn. Finally, the result form (or nil ) is evaluated
with var bound to nil to produce the result returned by
the loop. The loop is surrounded by an implicit nil block.
|
dotimes (var count [result]) forms... | Special Form |
This is a more specialized loop which iterates a specified number
of times. The body is executed with var bound to the integers
from zero (inclusive) to count (exclusive), in turn. Then
the result form is evaluated with var bound to the total
number of iterations that were done (i.e., (max 0 count) )
to get the return value for the loop form. The loop is surrounded
by an implicit nil block.
|
do-symbols (var [obarray [result]]) forms... | Special Form |
This loop iterates over all interned symbols. If obarray
is specified and is not nil , it loops over all symbols in
that obarray. For each symbol, the body forms are evaluated
with var bound to that symbol. The symbols are visited in
an unspecified order. Afterward the result form, if any,
is evaluated (with var bound to nil ) to get the return
value. The loop is surrounded by an implicit nil block.
|
do-all-symbols (var [result]) forms... | Special Form |
This is identical to do-symbols except that the obarray
argument is omitted; it always iterates over the default obarray.
|
See Mapping over Sequences, for some more functions for iterating over vectors or lists.
A common complaint with Lisp's traditional looping constructs is
that they are either too simple and limited, such as Common Lisp's
dotimes
or Emacs Lisp's while
, or too unreadable and
obscure, like Common Lisp's do
loop.
To remedy this, recent versions of Common Lisp have added a new
construct called the "Loop Facility" or "loop
macro,"
with an easy-to-use but very powerful and expressive syntax.
The loop
macro essentially creates a mini-language within
Lisp that is specially tailored for describing loops. While this
language is a little strange-looking by the standards of regular Lisp,
it turns out to be very easy to learn and well-suited to its purpose.
Since loop
is a macro, all parsing of the loop language
takes place at byte-compile time; compiled loop
s are just
as efficient as the equivalent while
loops written longhand.
loop clauses... | Special Form |
A loop construct consists of a series of clauses, each
introduced by a symbol like for or do . Clauses
are simply strung together in the argument list of loop ,
with minimal extra parentheses. The various types of clauses
specify initializations, such as the binding of temporary
variables, actions to be taken in the loop, stepping actions,
and final cleanup.
Common Lisp specifies a certain general order of clauses in a loop: (loop name-clause var-clauses... action-clauses...) The name-clause optionally gives a name to the implicit
block that surrounds the loop. By default, the implicit block
is named The Emacs version of the Loops generally return |
The following sections give some examples of the Loop Macro in
action, and describe the particular loop clauses in great detail.
Consult the second edition of Steele's Common Lisp, the Language,
for additional discussion and examples of the loop
macro.
Before listing the full set of clauses that are allowed, let's
look at a few example loops just to get a feel for the loop
language.
(loop for buf in (buffer-list) collect (buffer-file-name buf))
This loop iterates over all Emacs buffers, using the list
returned by buffer-list
. For each buffer buf
,
it calls buffer-file-name
and collects the results into
a list, which is then returned from the loop
construct.
The result is a list of the file names of all the buffers in
Emacs' memory. The words for
, in
, and collect
are reserved words in the loop
language.
(loop repeat 20 do (insert "Yowsa\n"))
This loop inserts the phrase "Yowsa" twenty times in the current buffer.
(loop until (eobp) do (munch-line) (forward-line 1))
This loop calls munch-line
on every line until the end
of the buffer. If point is already at the end of the buffer,
the loop exits immediately.
(loop do (munch-line) until (eobp) do (forward-line 1))
This loop is similar to the above one, except that munch-line
is always called at least once.
(loop for x from 1 to 100 for y = (* x x) until (>= y 729) finally return (list x (= y 729)))
This more complicated loop searches for a number x
whose
square is 729. For safety's sake it only examines x
values up to 100; dropping the phrase to 100
would
cause the loop to count upwards with no limit. The second
for
clause defines y
to be the square of x
within the loop; the expression after the =
sign is
reevaluated each time through the loop. The until
clause gives a condition for terminating the loop, and the
finally
clause says what to do when the loop finishes.
(This particular example was written less concisely than it
could have been, just for the sake of illustration.)
Note that even though this loop contains three clauses (two
for
s and an until
) that would have been enough to
define loops all by themselves, it still creates a single loop
rather than some sort of triple-nested loop. You must explicitly
nest your loop
constructs if you want nested loops.
Most loops are governed by one or more for
clauses.
A for
clause simultaneously describes variables to be
bound, how those variables are to be stepped during the loop,
and usually an end condition based on those variables.
The word as
is a synonym for the word for
. This
word is followed by a variable name, then a word like from
or across
that describes the kind of iteration desired.
In Common Lisp, the phrase being the
sometimes precedes
the type of iteration; in this package both being
and
the
are optional. The word each
is a synonym
for the
, and the word that follows it may be singular
or plural: for x being the elements of y
or
for x being each element of y
. Which form you use
is purely a matter of style.
The variable is bound around the loop as if by let
:
(setq i 'happy) (loop for i from 1 to 10 do (do-something-with i)) i => happy
for var from expr1 to expr2 by expr3
for
clause creates a counting loop. Each of
the three sub-terms is optional, though there must be at least one
term so that the clause is marked as a counting clause.
The three expressions are the starting value, the ending value, and
the step value, respectively, of the variable. The loop counts
upwards by default (expr3 must be positive), from expr1
to expr2 inclusively. If you omit the from
term, the
loop counts from zero; if you omit the to
term, the loop
counts forever without stopping (unless stopped by some other
loop clause, of course); if you omit the by
term, the loop
counts in steps of one.
You can replace the word from
with upfrom
or
downfrom
to indicate the direction of the loop. Likewise,
you can replace to
with upto
or downto
.
For example, for x from 5 downto 1
executes five times
with x
taking on the integers from 5 down to 1 in turn.
Also, you can replace to
with below
or above
,
which are like upto
and downto
respectively except
that they are exclusive rather than inclusive limits:
(loop for x to 10 collect x) => (0 1 2 3 4 5 6 7 8 9 10) (loop for x below 10 collect x) => (0 1 2 3 4 5 6 7 8 9)
The by
value is always positive, even for downward-counting
loops. Some sort of from
value is required for downward
loops; for x downto 5
is not a legal loop clause all by
itself.
for var in list by function
by
term, then function
is used to traverse the list instead of cdr
; it must be a
function taking one argument. For example:
(loop for x in '(1 2 3 4 5 6) collect (* x x)) => (1 4 9 16 25 36) (loop for x in '(1 2 3 4 5 6) by 'cddr collect (* x x)) => (1 9 25)
for var on list by function
(loop for x on '(1 2 3 4) collect x) => ((1 2 3 4) (2 3 4) (3 4) (4))
With by
, there is no real reason that the on
expression
must be a list. For example:
(loop for x on first-animal by 'next-animal collect x)
where (next-animal x)
takes an "animal" x and returns
the next in the (assumed) sequence of animals, or nil
if
x was the last animal in the sequence.
for var in-ref list by function
in
clause, but var becomes
a setf
-able "reference" onto the elements of the list
rather than just a temporary variable. For example,
(loop for x in-ref my-list do (incf x))
increments every element of my-list
in place. This clause
is an extension to standard Common Lisp.
for var across array
(loop for x across "aeiou" do (use-vowel (char-to-string x)))
for var across-ref array
setf
-able
reference onto the elements; see in-ref
above.
for var being the elements of sequence
in
or
across
. The clause may be followed by the additional term
using (index var2)
to cause var2 to be bound to
the successive indices (starting at 0) of the elements.
This clause type is taken from older versions of the loop
macro,
and is not present in modern Common Lisp. The using (sequence ...)
term of the older macros is not supported.
for var being the elements of-ref sequence
setf
-able
reference onto the elements; see in-ref
above.
for var being the symbols [of obarray]
As an example,
(loop for sym being the symbols when (fboundp sym) when (string-match "^map" (symbol-name sym)) collect sym)
returns a list of all the functions whose names begin with map
.
The Common Lisp words external-symbols
and present-symbols
are also recognized but are equivalent to symbols
in Emacs Lisp.
Due to a minor implementation restriction, it will not work to have
more than one for
clause iterating over symbols, hash tables,
keymaps, overlays, or intervals in a given loop
. Fortunately,
it would rarely if ever be useful to do so. It is legal to mix
one of these types of clauses with other clauses like for ... to
or while
.
for var being the hash-keys of hash-table
the hash-values
instead, var is bound to the values
of the entries. The clause may be followed by the additional
term using (hash-values var2)
(where hash-values
is the opposite word of the word following the
) to cause
var and var2 to be bound to the two parts of each
hash table entry.
for var being the key-codes of keymap
the key-bindings
to access the commands bound to
the keys rather than the key codes, and you can add a using
clause to access both the codes and the bindings together.
for var being the key-seqs of keymap
using (key-bindings ...)
clause to get the command bindings as well.
for var being the overlays [of buffer] ...
extents
is synonymous
with overlays
). Under Emacs 18, this clause iterates zero
times. If the of
term is omitted, the current buffer is used.
This clause also accepts optional from pos
and
to pos
terms, limiting the clause to overlays which
overlap the specified region.
for var being the intervals [of buffer] ...
of
,
from
, to
, and property
terms, where the latter
term restricts the search to just the specified property. The
of
term may specify either a buffer or a string. This
clause is useful only in GNU Emacs 19; in other versions, all
buffers and strings consist of a single interval.
for var being the frames
screens
is a synonym for frames
. The frames
are visited in next-frame
order starting from
selected-frame
.
for var being the windows [of frame]
of
term is not
allowed there.)
for var being the buffers
for var in (buffer-list)
.
for var = expr1 then expr2
(loop for x on my-list by 'cddr do ...) (loop for x = my-list then (cddr x) while x do ...)
Note that this type of for
clause does not imply any sort
of terminating condition; the above example combines it with a
while
clause to tell when to end the loop.
If you omit the then
term, expr1 is used both for
the initial setting and for successive settings:
(loop for x = (random) when (> x 0) return x)
This loop keeps taking random numbers from the (random)
function until it gets a positive one, which it then returns.
If you include several for
clauses in a row, they are
treated sequentially (as if by let*
and setq
).
You can instead use the word and
to link the clauses,
in which case they are processed in parallel (as if by let
and psetq
).
(loop for x below 5 for y = nil then x collect (list x y)) => ((0 nil) (1 1) (2 2) (3 3) (4 4)) (loop for x below 5 and y = nil then x collect (list x y)) => ((0 nil) (1 0) (2 1) (3 2) (4 3))
In the first loop, y
is set based on the value of x
that was just set by the previous clause; in the second loop,
x
and y
are set simultaneously so y
is set
based on the value of x
left over from the previous time
through the loop.
Another feature of the loop
macro is destructuring,
similar in concept to the destructuring provided by defmacro
.
The var part of any for
clause can be given as a list
of variables instead of a single variable. The values produced
during loop execution must be lists; the values in the lists are
stored in the corresponding variables.
(loop for (x y) in '((2 3) (4 5) (6 7)) collect (+ x y)) => (5 9 13)
In loop destructuring, if there are more values than variables
the trailing values are ignored, and if there are more variables
than values the trailing variables get the value nil
.
If nil
is used as a variable name, the corresponding
values are ignored. Destructuring may be nested, and dotted
lists of variables like (x . y)
are allowed.
Aside from for
clauses, there are several other loop clauses
that control the way the loop operates. They might be used by
themselves, or in conjunction with one or more for
clauses.
repeat integer
(loop repeat n do ...) (loop for temp to n do ...)
are identical except that the second one forces you to choose
a name for a variable you aren't actually going to use.
while condition
nil
. For example, the following two
loops are equivalent, except for the implicit nil
block
that surrounds the second one:
(while cond forms...) (loop while cond do forms...)
until condition
nil
.
always condition
nil
.
Unlike while
, it stops the loop using return nil
so that
the finally
clauses are not executed. If all the conditions
were non-nil
, the loop returns t
:
(if (loop for size in size-list always (> size 10)) (some-big-sizes) (no-big-sizes))
never condition
always
, except that the loop returns
t
if any conditions were false, or nil
otherwise.
thereis condition
nil
;
in this case, it returns that non-nil
value. If all the
values were nil
, the loop returns nil
.
These clauses cause the loop to accumulate information about the
specified Lisp form. The accumulated result is returned
from the loop unless overridden, say, by a return
clause.
collect form
collect
appear elsewhere in this manual.
The word collecting
is a synonym for collect
, and
likewise for the other accumulation clauses.
append form
append
.
nconc form
concat form
vconcat form
count form
nil
value.
sum form
maximize form
maximize
is executed zero times.
minimize form
Accumulation clauses can be followed by into var
to
cause the data to be collected into variable var (which is
automatically let
-bound during the loop) rather than an
unnamed temporary variable. Also, into
accumulations do
not automatically imply a return value. The loop must use some
explicit mechanism, such as finally return
, to return
the accumulated result.
It is legal for several accumulation clauses of the same type to accumulate into the same place. From Steele:
(loop for name in '(fred sue alice joe june) for kids in '((bob ken) () () (kris sunshine) ()) collect name append kids) => (fred bob ken sue alice joe kris sunshine june)
This section describes the remaining loop clauses.
with var = value
(loop with x = 17 do ...) (let ((x 17)) (loop do ...)) (loop for x = 17 then x do ...)
Naturally, the variable var might be used for some purpose in the rest of the loop. For example:
(loop for x in my-list with res = nil do (push x res) finally return res)
This loop inserts the elements of my-list
at the front of
a new list being accumulated in res
, then returns the
list res
at the end of the loop. The effect is similar
to that of a collect
clause, but the list gets reversed
by virtue of the fact that elements are being pushed onto the
front of res
rather than the end.
If you omit the =
term, the variable is initialized to
nil
. (Thus the = nil
in the above example is
unnecessary.)
Bindings made by with
are sequential by default, as if
by let*
. Just like for
clauses, with
clauses
can be linked with and
to cause the bindings to be made by
let
instead.
if condition clause
do
, return
, if
, or unless
clause.
Several clauses may be linked by separating them with and
.
These clauses may be followed by else
and a clause or clauses
to execute if the condition was false. The whole construct may
optionally be followed by the word end
(which may be used to
disambiguate an else
or and
in a nested if
).
The actual non-nil
value of the condition form is available
by the name it
in the "then" part. For example:
(setq funny-numbers '(6 13 -1)) => (6 13 -1) (loop for x below 10 if (oddp x) collect x into odds and if (memq x funny-numbers) return (cdr it) end else collect x into evens finally return (vector odds evens)) => [(1 3 5 7 9) (0 2 4 6 8)] (setq funny-numbers '(6 7 13 -1)) => (6 7 13 -1) (loop <same thing again>) => (13 -1)
Note the use of and
to put two clauses into the "then"
part, one of which is itself an if
clause. Note also that
end
, while normally optional, was necessary here to make
it clear that the else
refers to the outermost if
clause. In the first case, the loop returns a vector of lists
of the odd and even values of x. In the second case, the
odd number 7 is one of the funny-numbers
so the loop
returns early; the actual returned value is based on the result
of the memq
call.
when condition clause
if
.
unless condition clause
unless
clause is just like if
except that the
sense of the condition is reversed.
named name
nil
to the implicit
block surrounding the loop. The name is the symbol to be
used as the block name.
initially [do] forms...
for
or with
have been bound to their
initial values). initially
clauses can appear anywhere;
if there are several, they are executed in the order they appear
in the loop. The keyword do
is optional.
finally [do] forms...
for
or while
).
initially
and finally
clauses may appear anywhere
in the loop construct, but they are executed (in the specified
order) at the beginning or end, respectively, of the loop.
finally return form
collect
or return
, the loop will simply
return nil
.) Variables bound by for
, with
,
or into
will still contain their final values when form
is executed.
do forms...
do
may be followed by any number of Lisp expressions
which are executed as an implicit progn
in the body of the
loop. Many of the examples in this section illustrate the use of
do
.
return form
loop
form. The finally
clauses, if any, are not executed.
Of course, return
is generally used inside an if
or
unless
, as its use in a top-level loop clause would mean
the loop would never get to "loop" more than once.
The clause return form
is equivalent to
do (return form)
(or return-from
if the loop
was named). The return
clause is implemented a bit more
efficiently, though.
While there is no high-level way to add user extensions to loop
(comparable to defsetf
for setf
, say), this package
does offer two properties called cl-loop-handler
and
cl-loop-for-handler
which are functions to be called when
a given symbol is encountered as a top-level loop clause or
for
clause, respectively. Consult the source code in
file cl-macs.el
for details.
This package's loop
macro is compatible with that of Common
Lisp, except that a few features are not implemented: loop-finish
and data-type specifiers. Naturally, the for
clauses which
iterate over keymaps, overlays, intervals, frames, windows, and
buffers are Emacs-specific extensions.
Common Lisp functions can return zero or more results. Emacs Lisp
functions, by contrast, always return exactly one result. This
package makes no attempt to emulate Common Lisp multiple return
values; Emacs versions of Common Lisp functions that return more
than one value either return just the first value (as in
compiler-macroexpand
) or return a list of values (as in
get-setf-method
). This package does define placeholders
for the Common Lisp functions that work with multiple values, but
in Emacs Lisp these functions simply operate on lists instead.
The values
form, for example, is a synonym for list
in Emacs.
multiple-value-bind (var...) values-form forms... | Special Form |
This form evaluates values-form, which must return a list of
values. It then binds the vars to these respective values,
as if by let , and then executes the body forms.
If there are more vars than values, the extra vars
are bound to nil . If there are fewer vars than
values, the excess values are ignored.
|
multiple-value-setq (var...) form | Special Form |
This form evaluates form, which must return a list of values.
It then sets the vars to these respective values, as if by
setq . Extra vars or values are treated the same as
in multiple-value-bind .
|
The older Quiroz package attempted a more faithful (but still
imperfect) emulation of Common Lisp multiple values. The old
method "usually" simulated true multiple values quite well,
but under certain circumstances would leave spurious return
values in memory where a later, unrelated multiple-value-bind
form would see them.
Since a perfect emulation is not feasible in Emacs Lisp, this package opts to keep it as simple and predictable as possible.
This package implements the various Common Lisp features of
defmacro
, such as destructuring, &environment
,
and &body
. Top-level &whole
is not implemented
for defmacro
due to technical difficulties.
See Argument Lists.
Destructuring is made available to the user by way of the following macro:
destructuring-bind arglist expr forms... | Special Form |
This macro expands to code which executes forms, with
the variables in arglist bound to the list of values
returned by expr. The arglist can include all
the features allowed for defmacro argument lists,
including destructuring. (The &environment keyword
is not allowed.) The macro expansion will signal an error
if expr returns a list of the wrong number of arguments
or with incorrect keyword arguments.
|
This package also includes the Common Lisp define-compiler-macro
facility, which allows you to define compile-time expansions and
optimizations for your functions.
define-compiler-macro name arglist forms... | Special Form |
This form is similar to defmacro , except that it only expands
calls to name at compile-time; calls processed by the Lisp
interpreter are not expanded, nor are they expanded by the
macroexpand function.
The argument list may begin with a For example, here is a simplified version of a definition that appears as a standard part of this package: (define-compiler-macro member* (&whole form a list &rest keys) (if (and (null keys) (eq (car-safe a) 'quote) (not (floatp-safe (cadr a)))) (list 'memq a list) form)) This definition causes |
compiler-macroexpand form | Function |
This function is analogous to macroexpand , except that it
expands compiler macros rather than regular macros. It returns
form unchanged if it is not a call to a function for which
a compiler macro has been defined, or if that compiler macro
decided to punt by returning its &whole argument. Like
macroexpand , it expands repeatedly until it reaches a form
for which no further expansion is possible.
|
See Macro Bindings, for descriptions of the macrolet
and symbol-macrolet
forms for making "local" macro
definitions.
Common Lisp includes a complex and powerful "declaration"
mechanism that allows you to give the compiler special hints
about the types of data that will be stored in particular variables,
and about the ways those variables and functions will be used. This
package defines versions of all the Common Lisp declaration forms:
declare
, locally
, proclaim
, declaim
,
and the
.
Most of the Common Lisp declarations are not currently useful in
Emacs Lisp, as the byte-code system provides little opportunity
to benefit from type information, and special
declarations
are redundant in a fully dynamically-scoped Lisp. A few
declarations are meaningful when the optimizing Emacs 19 byte
compiler is being used, however. Under the earlier non-optimizing
compiler, these declarations will effectively be ignored.
proclaim decl-spec | Function |
This function records a "global" declaration specified by
decl-spec. Since proclaim is a function, decl-spec
is evaluated and thus should normally be quoted.
|
declaim decl-specs... | Special Form |
This macro is like proclaim , except that it takes any number
of decl-spec arguments, and the arguments are unevaluated and
unquoted. The declaim macro also puts an (eval-when
(compile load eval) ...) around the declarations so that they will
be registered at compile-time as well as at run-time. (This is vital,
since normally the declarations are meant to influence the way the
compiler treats the rest of the file that contains the declaim
form.)
|
declare decl-specs... | Special Form |
This macro is used to make declarations within functions and other
code. Common Lisp allows declarations in various locations, generally
at the beginning of any of the many "implicit progn s"
throughout Lisp syntax, such as function bodies, let bodies,
etc. Currently the only declaration understood by declare
is special .
|
locally declarations... forms... | Special Form |
In this package, locally is no different from progn .
|
the type form | Special Form |
Type information provided by the is ignored in this package;
in other words, (the type form) is equivalent
to form. Future versions of the optimizing byte-compiler may
make use of this information.
For example, |
Each decl-spec in a proclaim
, declaim
, or
declare
should be a list beginning with a symbol that says
what kind of declaration it is. This package currently understands
special
, inline
, notinline
, optimize
,
and warn
declarations. (The warn
declaration is an
extension of standard Common Lisp.) Other Common Lisp declarations,
such as type
and ftype
, are silently ignored.
special
special
declarations are only advisory. They
simply tell the optimizing byte compiler that the specified
variables are intentionally being referred to without being
bound in the body of the function. The compiler normally emits
warnings for such references, since they could be typographical
errors for references to local variables.
The declaration (declare (special var1 var2))
is
equivalent to (defvar var1) (defvar var2)
in the
optimizing compiler, or to nothing at all in older compilers (which
do not warn for non-local references).
In top-level contexts, it is generally better to write
(defvar var)
than (declaim (special var))
,
since defvar
makes your intentions clearer. But the older
byte compilers can not handle defvar
s appearing inside of
functions, while (declare (special var))
takes care
to work correctly with all compilers.
inline
inline
decl-spec lists one or more functions
whose bodies should be expanded "in-line" into calling functions
whenever the compiler is able to arrange for it. For example,
the Common Lisp function cadr
is declared inline
by this package so that the form (cadr x)
will
expand directly into (car (cdr x))
when it is called
in user functions, for a savings of one (relatively expensive)
function call.
The following declarations are all equivalent. Note that the
defsubst
form is a convenient way to define a function
and declare it inline all at once, but it is available only in
Emacs 19.
(declaim (inline foo bar)) (eval-when (compile load eval) (proclaim '(inline foo bar))) (proclaim-inline foo bar) ; Lucid Emacs only (defsubst foo (...) ...) ; instead of defun; Emacs 19 only
Note: This declaration remains in effect after the containing source file is done. It is correct to use it to request that a function you have defined should be inlined, but it is impolite to use it to request inlining of an external function.
In Common Lisp, it is possible to use (declare (inline ...))
before a particular call to a function to cause just that call to
be inlined; the current byte compilers provide no way to implement
this, so (declare (inline ...))
is currently ignored by
this package.
notinline
notinline
declaration lists functions which should
not be inlined after all; it cancels a previous inline
declaration.
optimize
The word optimize
is followed by any number of lists like
(speed 3)
or (safety 2)
. Common Lisp defines several
optimization "qualities"; this package ignores all but speed
and safety
. The value of a quality should be an integer from
0 to 3, with 0 meaning "unimportant" and 3 meaning "very important."
The default level for both qualities is 1.
In this package, with the Emacs 19 optimizing compiler, the
speed
quality is tied to the byte-compile-optimize
flag, which is set to nil
for (speed 0)
and to
t
for higher settings; and the safety
quality is
tied to the byte-compile-delete-errors
flag, which is
set to t
for (safety 3)
and to nil
for all
lower settings. (The latter flag controls whether the compiler
is allowed to optimize out code whose only side-effect could
be to signal an error, e.g., rewriting (progn foo bar)
to
bar
when it is not known whether foo
will be bound
at run-time.)
Note that even compiling with (safety 0)
, the Emacs
byte-code system provides sufficient checking to prevent real
harm from being done. For example, barring serious bugs in
Emacs itself, Emacs will not crash with a segmentation fault
just because of an error in a fully-optimized Lisp program.
The optimize
declaration is normally used in a top-level
proclaim
or declaim
in a file; Common Lisp allows
it to be used with declare
to set the level of optimization
locally for a given form, but this will not work correctly with the
current version of the optimizing compiler. (The declare
will set the new optimization level, but that level will not
automatically be unset after the enclosing form is done.)
warn
warn
is followed by any
number of "warning qualities," similar in form to optimization
qualities. The currently supported warning types are
redefine
, callargs
, unresolved
, and
free-vars
; in the current system, a value of 0 will
disable these warnings and any higher value will enable them.
See the documentation for the optimizing byte compiler for details.
This package defines several symbol-related features that were missing from Emacs Lisp.
These functions augment the standard Emacs Lisp functions get
and put
for operating on properties attached to symbols.
There are also functions for working with property lists as
first-class data structures not attached to particular symbols.
get* symbol property &optional default | Function |
This function is like get , except that if the property is
not found, the default argument provides the return value.
(The Emacs Lisp get function always uses nil as
the default; this package's get* is equivalent to Common
Lisp's get .)
The |
remprop symbol property | Function |
This function removes the entry for property from the property
list of symbol. It returns a true value if the property was
indeed found and removed, or nil if there was no such property.
(This function was probably omitted from Emacs originally because,
since get did not allow a default, it was very difficult
to distinguish between a missing property and a property whose value
was nil ; thus, setting a property to nil was close
enough to remprop for most purposes.)
|
getf place property &optional default | Function |
This function scans the list place as if it were a property
list, i.e., a list of alternating property names and values. If
an even-numbered element of place is found which is eq
to property, the following odd-numbered element is returned.
Otherwise, default is returned (or nil if no default
is given).
In particular, (get sym prop) == (getf (symbol-plist sym) prop) It is legal to use (put sym prop val) == (setf (getf (symbol-plist sym) prop) val) The (incf (get* 'foo 'usage-count 0)) Here, symbol When not used as a |
remf place property | Special Form |
This macro removes the property-value pair for property from
the property list stored at place, which is any setf -able
place expression. It returns true if the property was found. Note
that if property happens to be first on the list, this will
effectively do a (setf place (cddr place)) ,
whereas if it occurs later, this simply uses setcdr to splice
out the property and value cells.
|
These functions create unique symbols, typically for use as temporary variables.
gensym &optional x | Function |
This function creates a new, uninterned symbol (using make-symbol )
with a unique name. (The name of an uninterned symbol is relevant
only if the symbol is printed.) By default, the name is generated
from an increasing sequence of numbers, G1000 , G1001 ,
G1002 , etc. If the optional argument x is a string, that
string is used as a prefix instead of G . Uninterned symbols
are used in macro expansions for temporary variables, to ensure that
their names will not conflict with "real" variables in the user's
code.
|
*gensym-counter* | Variable |
This variable holds the counter used to generate gensym names.
It is incremented after each use by gensym . In Common Lisp
this is initialized with 0, but this package initializes it with a
random (time-dependent) value to avoid trouble when two files that
each used gensym in their compilation are loaded together.
(Uninterned symbols become interned when the compiler writes them
out to a file and the Emacs loader loads them, so their names have to
be treated a bit more carefully than in Common Lisp where uninterned
symbols remain uninterned after loading.)
|
gentemp &optional x | Function |
This function is like gensym , except that it produces a new
interned symbol. If the symbol that is generated already
exists, the function keeps incrementing the counter and trying
again until a new symbol is generated.
|
The Quiroz cl.el
package also defined a defkeyword
form for creating self-quoting keyword symbols. This package
automatically creates all keywords that are called for by
&key
argument specifiers, and discourages the use of
keywords as data unrelated to keyword arguments, so the
defkeyword
form has been discontinued.
This section defines a few simple Common Lisp operations on numbers which were left out of Emacs Lisp.
These functions return t
if the specified condition is
true of the numerical argument, or nil
otherwise.
plusp number | Function |
This predicate tests whether number is positive. It is an error if the argument is not a number. |
minusp number | Function |
This predicate tests whether number is negative. It is an error if the argument is not a number. |
oddp integer | Function |
This predicate tests whether integer is odd. It is an error if the argument is not an integer. |
evenp integer | Function |
This predicate tests whether integer is even. It is an error if the argument is not an integer. |
floatp-safe object | Function |
This predicate tests whether object is a floating-point
number. On systems that support floating-point, this is equivalent
to floatp . On other systems, this always returns nil .
|
These functions perform various arithmetic operations on numbers.
abs number | Function |
This function returns the absolute value of number. (Newer
versions of Emacs provide this as a built-in function; this package
defines abs only for Emacs 18 versions which don't provide
it as a primitive.)
|
expt base power | Function |
This function returns base raised to the power of number.
(Newer versions of Emacs provide this as a built-in function; this
package defines expt only for Emacs 18 versions which don't
provide it as a primitive.)
|
gcd &rest integers | Function |
This function returns the Greatest Common Divisor of the arguments. For one argument, it returns the absolute value of that argument. For zero arguments, it returns zero. |
lcm &rest integers | Function |
This function returns the Least Common Multiple of the arguments. For one argument, it returns the absolute value of that argument. For zero arguments, it returns one. |
isqrt integer | Function |
This function computes the "integer square root" of its integer argument, i.e., the greatest integer less than or equal to the true square root of the argument. |
floor* number &optional divisor | Function |
This function implements the Common Lisp floor function.
It is called floor* to avoid name conflicts with the
simpler floor function built-in to Emacs 19.
With one argument, With two arguments, This function is entirely compatible with Common Lisp's |
ceiling* number &optional divisor | Function |
This function implements the Common Lisp ceiling function,
which is analogous to floor except that it rounds the
argument or quotient of the arguments up toward plus infinity.
The remainder will be between 0 and minus r.
|
truncate* number &optional divisor | Function |
This function implements the Common Lisp truncate function,
which is analogous to floor except that it rounds the
argument or quotient of the arguments toward zero. Thus it is
equivalent to floor* if the argument or quotient is
positive, or to ceiling* otherwise. The remainder has
the same sign as number.
|
round* number &optional divisor | Function |
This function implements the Common Lisp round function,
which is analogous to floor except that it rounds the
argument or quotient of the arguments to the nearest integer.
In the case of a tie (the argument or quotient is exactly
halfway between two integers), it rounds to the even integer.
|
mod* number divisor | Function |
This function returns the same value as the second return value
of floor .
|
rem* number divisor | Function |
This function returns the same value as the second return value
of truncate .
|
These definitions are compatible with those in the Quiroz
cl.el
package, except that this package appends *
to certain function names to avoid conflicts with existing
Emacs 19 functions, and that the mechanism for returning
multiple values is different.
This package also provides an implementation of the Common Lisp random number generator. It uses its own additive-congruential algorithm, which is much more likely to give statistically clean random numbers than the simple generators supplied by many operating systems.
random* number &optional state | Function |
This function returns a random nonnegative number less than
number, and of the same type (either integer or floating-point).
The state argument should be a random-state object
which holds the state of the random number generator. The
function modifies this state object as a side effect. If
state is omitted, it defaults to the variable
*random-state* , which contains a pre-initialized
random-state object.
|
*random-state* | Variable |
This variable contains the system "default" random-state
object, used for calls to random* that do not specify an
alternative state object. Since any number of programs in the
Emacs process may be accessing *random-state* in interleaved
fashion, the sequence generated from this variable will be
irreproducible for all intents and purposes.
|
make-random-state &optional state | Function |
This function creates or copies a random-state object.
If state is omitted or nil , it returns a new copy of
*random-state* . This is a copy in the sense that future
sequences of calls to (random* n) and
(random* n s) (where s is the new
random-state object) will return identical sequences of random
numbers.
If state is a It is legal to print a |
random-state-p object | Function |
This predicate returns t if object is a
random-state object, or nil otherwise.
|
This package defines several useful constants having to with numbers.
most-positive-fixnum | Variable |
This constant equals the largest value a Lisp integer can hold.
It is typically 2^23-1 or 2^25-1 .
|
most-negative-fixnum | Variable |
This constant equals the smallest (most negative) value a Lisp integer can hold. |
The following parameters have to do with floating-point numbers. This package determines their values by exercising the computer's floating-point arithmetic in various ways. Because this operation might be slow, the code for initializing them is kept in a separate function that must be called before the parameters can be used.
cl-float-limits | Function |
This function makes sure that the Common Lisp floating-point
parameters like most-positive-float have been initialized.
Until it is called, these parameters will be nil . If this
version of Emacs does not support floats (e.g., most versions of
Emacs 18), the parameters will remain nil . If the parameters
have already been initialized, the function returns immediately.
The algorithm makes assumptions that will be valid for most modern machines, but will fail if the machine's arithmetic is extremely unusual, e.g., decimal. |
Since true Common Lisp supports up to four different floating-point
precisions, it has families of constants like
most-positive-single-float
, most-positive-double-float
,
most-positive-long-float
, and so on. Emacs has only one
floating-point precision, so this package omits the precision word
from the constants' names.
most-positive-float | Variable |
This constant equals the largest value a Lisp float can hold.
For those systems whose arithmetic supports infinities, this is
the largest finite value. For IEEE machines, the value
is approximately 1.79e+308 .
|
most-negative-float | Variable |
This constant equals the most-negative value a Lisp float can hold.
(It is assumed to be equal to (- most-positive-float) .)
|
least-positive-float | Variable |
This constant equals the smallest Lisp float value greater than zero.
For IEEE machines, it is about 4.94e-324 if denormals are
supported or 2.22e-308 if not.
|
least-positive-normalized-float | Variable |
This constant equals the smallest normalized Lisp float greater
than zero, i.e., the smallest value for which IEEE denormalization
will not result in a loss of precision. For IEEE machines, this
value is about 2.22e-308 . For machines that do not support
the concept of denormalization and gradual underflow, this constant
will always equal least-positive-float .
|
least-negative-float | Variable |
This constant is the negative counterpart of least-positive-float .
|
least-negative-normalized-float | Variable |
This constant is the negative counterpart of
least-positive-normalized-float .
|
float-epsilon | Variable |
This constant is the smallest positive Lisp float that can be added
to 1.0 to produce a distinct value. Adding a smaller number to 1.0
will yield 1.0 again due to roundoff. For IEEE machines, epsilon
is about 2.22e-16 .
|
float-negative-epsilon | Variable |
This is the smallest positive value that can be subtracted from
1.0 to produce a distinct value. For IEEE machines, it is about
1.11e-16 .
|
Common Lisp defines a number of functions that operate on
sequences, which are either lists, strings, or vectors.
Emacs Lisp includes a few of these, notably elt
and
length
; this package defines most of the rest.
Many of the sequence functions take keyword arguments; see Argument Lists. All keyword arguments are optional and, if specified, may appear in any order.
The :key
argument should be passed either nil
, or a
function of one argument. This key function is used as a filter
through which the elements of the sequence are seen; for example,
(find x y :key 'car)
is similar to (assoc* x y)
:
It searches for an element of the list whose car
equals
x
, rather than for an element which equals x
itself.
If :key
is omitted or nil
, the filter is effectively
the identity function.
The :test
and :test-not
arguments should be either
nil
, or functions of two arguments. The test function is
used to compare two sequence elements, or to compare a search value
with sequence elements. (The two values are passed to the test
function in the same order as the original sequence function
arguments from which they are derived, or, if they both come from
the same sequence, in the same order as they appear in that sequence.)
The :test
argument specifies a function which must return
true (non-nil
) to indicate a match; instead, you may use
:test-not
to give a function which returns false to
indicate a match. The default test function is :test 'eql
.
Many functions which take item and :test
or :test-not
arguments also come in -if
and -if-not
varieties,
where a predicate function is passed instead of item,
and sequence elements match if the predicate returns true on them
(or false in the case of -if-not
). For example:
(remove* 0 seq :test '=) == (remove-if 'zerop seq)
to remove all zeros from sequence seq
.
Some operations can work on a subsequence of the argument sequence;
these function take :start
and :end
arguments which
default to zero and the length of the sequence, respectively.
Only elements between start (inclusive) and end
(exclusive) are affected by the operation. The end argument
may be passed nil
to signify the length of the sequence;
otherwise, both start and end must be integers, with
0 <= start <= end <= (length seq)
.
If the function takes two sequence arguments, the limits are
defined by keywords :start1
and :end1
for the first,
and :start2
and :end2
for the second.
A few functions accept a :from-end
argument, which, if
non-nil
, causes the operation to go from right-to-left
through the sequence instead of left-to-right, and a :count
argument, which specifies an integer maximum number of elements
to be removed or otherwise processed.
The sequence functions make no guarantees about the order in
which the :test
, :test-not
, and :key
functions
are called on various elements. Therefore, it is a bad idea to depend
on side effects of these functions. For example, :from-end
may cause the sequence to be scanned actually in reverse, or it may
be scanned forwards but computing a result "as if" it were scanned
backwards. (Some functions, like mapcar*
and every
,
do specify exactly the order in which the function is called
so side effects are perfectly acceptable in those cases.)
Strings in GNU Emacs 19 may contain "text properties" as well
as character data. Except as noted, it is undefined whether or
not text properties are preserved by sequence functions. For
example, (remove* ?A str)
may or may not preserve
the properties of the characters copied from str into the
result.
These functions "map" the function you specify over the elements
of lists or arrays. They are all variations on the theme of the
built-in function mapcar
.
mapcar* function seq &rest more-seqs | Function |
This function calls function on successive parallel sets of
elements from its argument sequences. Given a single seq
argument it is equivalent to mapcar ; given n sequences,
it calls the function with the first elements of each of the sequences
as the n arguments to yield the first element of the result
list, then with the second elements, and so on. The mapping stops as
soon as the shortest sequence runs out. The argument sequences may
be any mixture of lists, strings, and vectors; the return sequence
is always a list.
Common Lisp's |
map result-type function seq &rest more-seqs | Function |
This function maps function over the argument sequences,
just like mapcar* , but it returns a sequence of type
result-type rather than a list. result-type must
be one of the following symbols: vector , string ,
list (in which case the effect is the same as for
mapcar* ), or nil (in which case the results are
thrown away and map returns nil ).
|
maplist function list &rest more-lists | Function |
This function calls function on each of its argument lists,
then on the cdr s of those lists, and so on, until the
shortest list runs out. The results are returned in the form
of a list. Thus, maplist is like mapcar* except
that it passes in the list pointers themselves rather than the
car s of the advancing pointers.
|
mapc function seq &rest more-seqs | Function |
This function is like mapcar* , except that the values
returned by function are ignored and thrown away rather
than being collected into a list. The return value of mapc
is seq, the first sequence.
|
mapl function list &rest more-lists | Function |
This function is like maplist , except that it throws away
the values returned by function.
|
mapcan function seq &rest more-seqs | Function |
This function is like mapcar* , except that it concatenates
the return values (which must be lists) using nconc ,
rather than simply collecting them into a list.
|
mapcon function list &rest more-lists | Function |
This function is like maplist , except that it concatenates
the return values using nconc .
|
some predicate seq &rest more-seqs | Function |
This function calls predicate on each element of seq
in turn; if predicate returns a non-nil value,
some returns that value, otherwise it returns nil .
Given several sequence arguments, it steps through the sequences
in parallel until the shortest one runs out, just as in
mapcar* . You can rely on the left-to-right order in which
the elements are visited, and on the fact that mapping stops
immediately as soon as predicate returns non-nil .
|
every predicate seq &rest more-seqs | Function |
This function calls predicate on each element of the sequence(s)
in turn; it returns nil as soon as predicate returns
nil for any element, or t if the predicate was true
for all elements.
|
notany predicate seq &rest more-seqs | Function |
This function calls predicate on each element of the sequence(s)
in turn; it returns nil as soon as predicate returns
a non-nil value for any element, or t if the predicate
was nil for all elements.
|
notevery predicate seq &rest more-seqs | Function |
This function calls predicate on each element of the sequence(s)
in turn; it returns a non-nil value as soon as predicate
returns nil for any element, or t if the predicate was
true for all elements.
|
reduce function seq &key :from-end :start :end :initial-value :key | Function |
This function combines the elements of seq using an associative
binary operation. Suppose function is * and seq is
the list (2 3 4 5) . The first two elements of the list are
combined with (* 2 3) = 6 ; this is combined with the next
element, (* 6 4) = 24 , and that is combined with the final
element: (* 24 5) = 120 . Note that the * function happens
to be self-reducing, so that (* 2 3 4 5) has the same effect as
an explicit call to reduce .
If (reduce '- '(1 2 3 4)) == (- (- (- 1 2) 3) 4) => -8 (reduce '- '(1 2 3 4) :from-end t) == (- 1 (- 2 (- 3 4))) => -2 If If If the sequence, including the initial value, has exactly one element then that element is returned without ever calling function. If the sequence is empty (and there is no initial value), then function is called with no arguments to obtain the return value. |
All of these mapping operations can be expressed conveniently in
terms of the loop
macro. In compiled code, loop
will
be faster since it generates the loop as in-line code with no
function calls.
This section describes a number of Common Lisp functions for operating on sequences.
subseq sequence start &optional end | Function |
This function returns a given subsequence of the argument
sequence, which may be a list, string, or vector.
The indices start and end must be in range, and
start must be no greater than end. If end
is omitted, it defaults to the length of the sequence. The
return value is always a copy; it does not share structure
with sequence.
As an extension to Common Lisp, start and/or end
may be negative, in which case they represent a distance back
from the end of the sequence. This is for compatibility with
Emacs' You can use |
concatenate result-type &rest seqs | Function |
This function concatenates the argument sequences together to
form a result sequence of type result-type, one of the
symbols vector , string , or list . The
arguments are always copied, even in cases such as
(concatenate 'list '(1 2 3)) where the result is
identical to an argument.
|
fill seq item &key :start :end | Function |
This function fills the elements of the sequence (or the specified part of the sequence) with the value item. |
replace seq1 seq2 &key :start1 :end1 :start2 :end2 | Function |
This function copies part of seq2 into part of seq1.
The sequence seq1 is not stretched or resized; the amount
of data copied is simply the shorter of the source and destination
(sub)sequences. The function returns seq1.
If seq1 and seq2 are |
remove* item seq &key :test :test-not :key :count :start :end :from-end | Function |
This returns a copy of seq with all elements matching
item removed. The result may share storage with or be
eq to seq in some circumstances, but the original
seq will not be modified. The :test , :test-not ,
and :key arguments define the matching test that is used;
by default, elements eql to item are removed. The
:count argument specifies the maximum number of matching
elements that can be removed (only the leftmost count matches
are removed). The :start and :end arguments specify
a region in seq in which elements will be removed; elements
outside that region are not matched or removed. The :from-end
argument, if true, says that elements should be deleted from the
end of the sequence rather than the beginning (this matters only
if count was also specified).
|
delete* item seq &key :test :test-not :key :count :start :end :from-end | Function |
This deletes all elements of seq which match item.
It is a destructive operation. Since Emacs Lisp does not support
stretchable strings or vectors, this is the same as remove*
for those sequence types. On lists, remove* will copy the
list if necessary to preserve the original list, whereas
delete* will splice out parts of the argument list.
Compare append and nconc , which are analogous
non-destructive and destructive list operations in Emacs Lisp.
|
The predicate-oriented functions remove-if
, remove-if-not
,
delete-if
, and delete-if-not
are defined similarly.
delete item list | Function |
This MacLisp-compatible function deletes from list all elements
which are equal to item. The delete function is
built-in to Emacs 19; this package defines it equivalently in Emacs 18.
|
remove item list | Function |
This function removes from list all elements which are
equal to item. This package defines it for symmetry
with delete , even though remove is not built-in to
Emacs 19.
|
remq item list | Function |
This function removes from list all elements which are
eq to item. This package defines it for symmetry
with delq , even though remq is not built-in to
Emacs 19.
|
remove-duplicates seq &key :test :test-not :key :start :end :from-end | Function |
This function returns a copy of seq with duplicate elements
removed. Specifically, if two elements from the sequence match
according to the :test , :test-not , and :key
arguments, only the rightmost one is retained. If :from-end
is true, the leftmost one is retained instead. If :start or
:end is specified, only elements within that subsequence are
examined or removed.
|
delete-duplicates seq &key :test :test-not :key :start :end :from-end | Function |
This function deletes duplicate elements from seq. It is
a destructive version of remove-duplicates .
|
substitute new old seq &key :test :test-not :key :count :start :end :from-end | Function |
This function returns a copy of seq, with all elements
matching old replaced with new. The :count ,
:start , :end , and :from-end arguments may be
used to limit the number of substitutions made.
|
nsubstitute new old seq &key :test :test-not :key :count :start :end :from-end | Function |
This is a destructive version of substitute ; it performs
the substitution using setcar or aset rather than
by returning a changed copy of the sequence.
|
The substitute-if
, substitute-if-not
, nsubstitute-if
,
and nsubstitute-if-not
functions are defined similarly. For
these, a predicate is given in place of the old argument.
These functions search for elements or subsequences in a sequence.
(See also member*
and assoc*
; see Lists.)
find item seq &key :test :test-not :key :start :end :from-end | Function |
This function searches seq for an element matching item.
If it finds a match, it returns the matching element. Otherwise,
it returns nil . It returns the leftmost match, unless
:from-end is true, in which case it returns the rightmost
match. The :start and :end arguments may be used to
limit the range of elements that are searched.
|
position item seq &key :test :test-not :key :start :end :from-end | Function |
This function is like find , except that it returns the
integer position in the sequence of the matching item rather than
the item itself. The position is relative to the start of the
sequence as a whole, even if :start is non-zero. The function
returns nil if no matching element was found.
|
count item seq &key :test :test-not :key :start :end | Function |
This function returns the number of elements of seq which match item. The result is always a nonnegative integer. |
The find-if
, find-if-not
, position-if
,
position-if-not
, count-if
, and count-if-not
functions are defined similarly.
mismatch seq1 seq2 &key :test :test-not :key :start1 :end1 :start2 :end2 :from-end | Function |
This function compares the specified parts of seq1 and
seq2. If they are the same length and the corresponding
elements match (according to :test , :test-not ,
and :key ), the function returns nil . If there is
a mismatch, the function returns the index (relative to seq1)
of the first mismatching element. This will be the leftmost pair of
elements which do not match, or the position at which the shorter of
the two otherwise-matching sequences runs out.
If An interesting example is |
search seq1 seq2 &key :test :test-not :key :from-end :start1 :end1 :start2 :end2 | Function |
This function searches seq2 for a subsequence that matches
seq1 (or part of it specified by :start1 and
:end1 .) Only matches which fall entirely within the region
defined by :start2 and :end2 will be considered.
The return value is the index of the leftmost element of the
leftmost match, relative to the start of seq2, or nil
if no matches were found. If :from-end is true, the
function finds the rightmost matching subsequence.
|
sort* seq predicate &key :key | Function |
This function sorts seq into increasing order as determined
by using predicate to compare pairs of elements. predicate
should return true (non-nil ) if and only if its first argument
is less than (not equal to) its second argument. For example,
< and string-lessp are suitable predicate functions
for sorting numbers and strings, respectively; > would sort
numbers into decreasing rather than increasing order.
This function differs from Emacs' built-in (setq data (sort data 'string-lessp :key 'downcase)) sorts data, a sequence of strings, into increasing alphabetical
order without regard to case. A The |
stable-sort seq predicate &key :key | Function |
This function sorts seq stably, meaning two elements
which are equal in terms of predicate are guaranteed not to
be rearranged out of their original order by the sort.
In practice, |
merge type seq1 seq2 predicate &key :key | Function |
This function merges two sequences seq1 and seq2 by
interleaving their elements. The result sequence, of type type
(in the sense of concatenate ), has length equal to the sum
of the lengths of the two input sequences. The sequences may be
modified destructively. Order of elements within seq1 and
seq2 is preserved in the interleaving; elements of the two
sequences are compared by predicate (in the sense of
sort ) and the lesser element goes first in the result.
When elements are equal, those from seq1 precede those from
seq2 in the result. Thus, if seq1 and seq2 are
both sorted according to predicate, then the result will be
a merged sequence which is (stably) sorted according to
predicate.
|
The functions described here operate on lists.
This section describes a number of simple operations on lists, i.e., chains of cons cells.
caddr x | Function |
This function is equivalent to (car (cdr (cdr x))) .
Likewise, this package defines all 28 cxxxr functions
where xxx is up to four a s and/or d s.
All of these functions are setf -able, and calls to them
are expanded inline by the byte-compiler for maximum efficiency.
|
first x | Function |
This function is a synonym for (car x) . Likewise,
the functions second , third , ..., through
tenth return the given element of the list x.
|
rest x | Function |
This function is a synonym for (cdr x) .
|
endp x | Function |
Common Lisp defines this function to act like null , but
signaling an error if x is neither a nil nor a
cons cell. This package simply defines endp as a synonym
for null .
|
list-length x | Function |
This function returns the length of list x, exactly like
(length x) , except that if x is a circular
list (where the cdr-chain forms a loop rather than terminating
with nil ), this function returns nil . (The regular
length function would get stuck if given a circular list.)
|
last* x &optional n | Function |
This function returns the last cons, or the nth-to-last cons,
of the list x. If n is omitted it defaults to 1.
The "last cons" means the first cons cell of the list whose
cdr is not another cons cell. (For normal lists, the
cdr of the last cons will be nil .) This function
returns nil if x is nil or shorter than
n. Note that the last element of the list is
(car (last x)) .
The Emacs function |
butlast x &optional n | Function |
This function returns the list x with the last element,
or the last n elements, removed. If n is greater
than zero it makes a copy of the list so as not to damage the
original list. In general, (append (butlast x n)
(last x n)) will return a list equal to x.
|
nbutlast x &optional n | Function |
This is a version of butlast that works by destructively
modifying the cdr of the appropriate element, rather than
making a copy of the list.
|
list* arg &rest others | Function |
This function constructs a list of its arguments. The final
argument becomes the cdr of the last cell constructed.
Thus, (list* a b c) is equivalent to
(cons a (cons b c)) , and
(list* a b nil) is equivalent to
(list a b) .
(Note that this function really is called |
ldiff list sublist | Function |
If sublist is a sublist of list, i.e., is eq to
one of the cons cells of list, then this function returns
a copy of the part of list up to but not including
sublist. For example, (ldiff x (cddr x)) returns
the first two elements of the list x . The result is a
copy; the original list is not modified. If sublist
is not a sublist of list, a copy of the entire list
is returned.
|
copy-list list | Function |
This function returns a copy of the list list. It copies
dotted lists like (1 2 . 3) correctly.
|
copy-tree x &optional vecp | Function |
This function returns a copy of the tree of cons cells x.
Unlike copy-sequence (and its alias copy-list ),
which copies only along the cdr direction, this function
copies (recursively) along both the car and the cdr
directions. If x is not a cons cell, the function simply
returns x unchanged. If the optional vecp argument
is true, this function copies vectors (recursively) as well as
cons cells.
|
tree-equal x y &key :test :test-not :key | Function |
This function compares two trees of cons cells. If x and
y are both cons cells, their car s and cdr s are
compared recursively. If neither x nor y is a cons
cell, they are compared by eql , or according to the
specified test. The :key function, if specified, is
applied to the elements of both trees. See Sequences.
|
These functions substitute elements throughout a tree of cons
cells. (See Sequence Functions, for the substitute
function, which works on just the top-level elements of a list.)
subst new old tree &key :test :test-not :key | Function |
This function substitutes occurrences of old with new
in tree, a tree of cons cells. It returns a substituted
tree, which will be a copy except that it may share storage with
the argument tree in parts where no substitutions occurred.
The original tree is not modified. This function recurses
on, and compares against old, both car s and cdr s
of the component cons cells. If old is itself a cons cell,
then matching cells in the tree are substituted as usual without
recursively substituting in that cell. Comparisons with old
are done according to the specified test (eql by default).
The :key function is applied to the elements of the tree
but not to old.
|
nsubst new old tree &key :test :test-not :key | Function |
This function is like subst , except that it works by
destructive modification (by setcar or setcdr )
rather than copying.
|
The subst-if
, subst-if-not
, nsubst-if
, and
nsubst-if-not
functions are defined similarly.
sublis alist tree &key :test :test-not :key | Function |
This function is like subst , except that it takes an
association list alist of old-new pairs.
Each element of the tree (after applying the :key
function, if any), is compared with the car s of
alist; if it matches, it is replaced by the corresponding
cdr .
|
nsublis alist tree &key :test :test-not :key | Function |
This is a destructive version of sublis .
|
These functions perform operations on lists which represent sets of elements.
member item list | Function |
This MacLisp-compatible function searches list for an element
which is equal to item. The member function is
built-in to Emacs 19; this package defines it equivalently in Emacs 18.
See the following function for a Common-Lisp compatible version.
|
member* item list &key :test :test-not :key | Function |
This function searches list for an element matching item.
If a match is found, it returns the cons cell whose car was
the matching element. Otherwise, it returns nil . Elements
are compared by eql by default; you can use the :test ,
:test-not , and :key arguments to modify this behavior.
See Sequences.
Note that this function's name is suffixed by |
The member-if
and member-if-not
functions
analogously search for elements which satisfy a given predicate.
tailp sublist list | Function |
This function returns t if sublist is a sublist of
list, i.e., if sublist is eql to list or to
any of its cdr s.
|
adjoin item list &key :test :test-not :key | Function |
This function conses item onto the front of list,
like (cons item list) , but only if item
is not already present on the list (as determined by member* ).
If a :key argument is specified, it is applied to
item as well as to the elements of list during
the search, on the reasoning that item is "about" to
become part of the list.
|
union list1 list2 &key :test :test-not :key | Function |
This function combines two lists which represent sets of items, returning a list that represents the union of those two sets. The result list will contain all items which appear in list1 or list2, and no others. If an item appears in both list1 and list2 it will be copied only once. If an item is duplicated in list1 or list2, it is undefined whether or not that duplication will survive in the result list. The order of elements in the result list is also undefined. |
nunion list1 list2 &key :test :test-not :key | Function |
This is a destructive version of union ; rather than copying,
it tries to reuse the storage of the argument lists if possible.
|
intersection list1 list2 &key :test :test-not :key | Function |
This function computes the intersection of the sets represented by list1 and list2. It returns the list of items which appear in both list1 and list2. |
nintersection list1 list2 &key :test :test-not :key | Function |
This is a destructive version of intersection . It
tries to reuse storage of list1 rather than copying.
It does not reuse the storage of list2.
|
set-difference list1 list2 &key :test :test-not :key | Function |
This function computes the "set difference" of list1 and list2, i.e., the set of elements that appear in list1 but not in list2. |
nset-difference list1 list2 &key :test :test-not :key | Function |
This is a destructive set-difference , which will try
to reuse list1 if possible.
|
set-exclusive-or list1 list2 &key :test :test-not :key | Function |
This function computes the "set exclusive or" of list1 and list2, i.e., the set of elements that appear in exactly one of list1 and list2. |
nset-exclusive-or list1 list2 &key :test :test-not :key | Function |
This is a destructive set-exclusive-or , which will try
to reuse list1 and list2 if possible.
|
subsetp list1 list2 &key :test :test-not :key | Function |
This function checks whether list1 represents a subset of list2, i.e., whether every element of list1 also appears in list2. |
An association list is a list representing a mapping from one set of values to another; any list whose elements are cons cells is an association list.
assoc* item a-list &key :test :test-not :key | Function |
This function searches the association list a-list for an
element whose car matches (in the sense of :test ,
:test-not , and :key , or by comparison with eql )
a given item. It returns the matching element, if any,
otherwise nil . It ignores elements of a-list which
are not cons cells. (This corresponds to the behavior of
assq and assoc in Emacs Lisp; Common Lisp's
assoc ignores nil s but considers any other non-cons
elements of a-list to be an error.)
|
rassoc* item a-list &key :test :test-not :key | Function |
This function searches for an element whose cdr matches
item. If a-list represents a mapping, this applies
the inverse of the mapping to item.
|
rassoc item a-list | Function |
This function searches like rassoc* with a :test
argument of equal . It is analogous to Emacs Lisp's
standard assoc function, which derives from the MacLisp
rather than the Common Lisp tradition.
|
The assoc-if
, assoc-if-not
, rassoc-if
,
and rassoc-if-not
functions are defined similarly.
Two simple functions for constructing association lists are:
acons key value alist | Function |
This is equivalent to (cons (cons key value) alist) .
|
pairlis keys values &optional alist | Function |
This is equivalent to (nconc (mapcar* 'cons keys values)
alist) .
|
A hash table is a data structure that maps "keys" onto "values." Keys and values can be arbitrary Lisp data objects. Hash tables have the property that the time to search for a given key is roughly constant; simpler data structures like association lists take time proportional to the number of entries in the list.
make-hash-table &key :test :size | Function |
This function creates and returns a hash-table object whose
function for comparing elements is :test (eql
by default), and which is allocated to fit about :size
elements. The :size argument is purely advisory; the
table will stretch automatically if you store more elements in
it. If :size is omitted, a reasonable default is used.
Common Lisp allows only Some versions of Emacs (like Lucid Emacs 19) include a built-in
hash table type; in these versions, This function accepts the additional Common Lisp keywords
|
gethash key table &optional default | Function |
This function looks up key in table. If key
exists in the table, in the sense that it matches any of the existing
keys according to the table's test function, then the associated value
is returned. Otherwise, default (or nil ) is returned.
To store new data in the hash table, use |
remhash key table | Function |
This function removes the entry for key from table.
If an entry was removed, it returns t . If key does
not appear in the table, it does nothing and returns nil .
|
clrhash table | Function |
This function removes all the entries from table, leaving an empty hash table. |
maphash function table | Function |
This function calls function for each entry in table.
It passes two arguments to function, the key and the value
of the given entry. The return value of function is ignored;
maphash itself returns nil . See Loop Facility, for
an alternate way of iterating over hash tables.
|
hash-table-count table | Function |
This function returns the number of entries in table.
Warning: The current implementation of Lucid Emacs 19
hash-tables does not decrement the stored count when
remhash removes an entry. Therefore, the return value of
this function is not dependable if you have used remhash
on the table and the table's test is eq . A slower, but
reliable, way to count the entries is (loop for x being the
hash-keys of table count t) .
|
hash-table-p object | Function |
This function returns t if object is a hash table,
nil otherwise. It recognizes both types of hash tables
(both Lucid Emacs built-in tables and tables implemented with
special lists.)
|
Sometimes when dealing with hash tables it is useful to know the
exact "hash function" that is used. This package implements
hash tables using Emacs Lisp "obarrays," which are the same
data structure that Emacs Lisp uses to keep track of symbols.
Each hash table includes an embedded obarray. Key values given
to gethash
are converted by various means into strings,
which are then looked up in the obarray using intern
and
intern-soft
. The symbol, or "bucket," corresponding to
a given key string includes as its symbol-value
an association
list of all key-value pairs which hash to that string. Depending
on the test function, it is possible for many entries to hash to
the same bucket. For example, if the test is eql
, then the
symbol foo
and two separately built strings "foo"
will
create three entries in the same bucket. Search time is linear
within buckets, so hash tables will be most effective if you arrange
not to store too many things that hash the same.
The following algorithm is used to convert Lisp objects to hash strings:
equalp
, strings are downcase
d first.)
symbol-name
.
car
s; nonempty vectors
are hashed according to their first element.
"*"
.
Thus, for example, searching among many buffer objects in a hash table will devolve to a (still fairly fast) linear-time search through a single bucket, whereas searching for different symbols will be very fast since each symbol will, in general, hash into its own bucket.
The size of the obarray in a hash table is automatically adjusted as the number of elements increases.
As a special case, make-hash-table
with a :size
argument
of 0 or 1 will create a hash-table object that uses a single association
list rather than an obarray of many lists. For very small tables this
structure will be more efficient since lookup does not require
converting the key to a string or looking it up in an obarray.
However, such tables are guaranteed to take time proportional to
their size to do a search.
The Common Lisp structure mechanism provides a general way
to define data types similar to C's struct
types. A
structure is a Lisp object containing some number of slots,
each of which can hold any Lisp data object. Functions are
provided for accessing and setting the slots, creating or copying
structure objects, and recognizing objects of a particular structure
type.
In true Common Lisp, each structure type is a new type distinct from all existing Lisp types. Since the underlying Emacs Lisp system provides no way to create new distinct types, this package implements structures as vectors (or lists upon request) with a special "tag" symbol to identify them.
defstruct name slots... | Special Form |
The defstruct form defines a new structure type called
name, with the specified slots. (The slots
may begin with a string which documents the structure type.)
In the simplest case, name and each of the slots
are symbols. For example,
(defstruct person name age sex) defines a struct type called (incf (person-age birthday-boy)) You can create a new Given a Given any Lisp object x, Accessors like (setq dave (make-person :name "Dave" :sex 'male)) => [cl-struct-person "Dave" nil male] (setq other (copy-person dave)) => [cl-struct-person "Dave" nil male] (eq dave other) => nil (eq (person-name dave) (person-name other)) => t (person-p dave) => t (person-p [1 2 3 4]) => nil (person-p "Bogus") => nil (person-p '[cl-struct-person counterfeit person object]) => t In general, name is either a name symbol or a list of a name
symbol followed by any number of struct options; each slot
is either a slot symbol or a list of the form Common Lisp defines several slot options, but the only one
implemented in this package is (defstruct person (name nil :read-only t) age (sex 'unknown)) Any slot options other than For obscure historical reasons, structure options take a different form than slot options. A structure option is either a keyword symbol, or a list beginning with a keyword symbol possibly followed by arguments. (By contrast, slot options are key-value pairs not enclosed in lists.) (defstruct (person (:constructor create-person) (:type list) :named) name age sex) The following structure options are recognized.
|
Except as noted, the defstruct
facility of this package is
entirely compatible with that of Common Lisp.
This section describes two macros that test assertions, i.e., conditions which must be true if the program is operating correctly. Assertions never add to the behavior of a Lisp program; they simply make "sanity checks" to make sure everything is as it should be.
If the optimization property speed
has been set to 3, and
safety
is less than 3, then the byte-compiler will optimize
away the following assertions. Because assertions might be optimized
away, it is a bad idea for them to include side-effects.
assert test-form [show-args string args...] | Special Form |
This form verifies that test-form is true (i.e., evaluates to
a non-nil value). If so, it returns nil . If the test
is not satisfied, assert signals an error.
A default error message will be supplied which includes test-form.
You can specify a different error message by including a string
argument plus optional extra arguments. Those arguments are simply
passed to If the optional second argument show-args is (assert (> x 10) t "x is too small: %d") This usage of show-args is an extension to Common Lisp. In
true Common Lisp, the second argument gives a list of places
which can be |
check-type form type [string] | Special Form |
This form verifies that form evaluates to a value of type
type. If so, it returns nil . If not, check-type
signals a wrong-type-argument error. The default error message
lists the erroneous value along with type and form
themselves. If string is specified, it is included in the
error message in place of type. For example:
(check-type x (integer 1 *) "a positive integer") See Type Predicates, for a description of the type specifiers that may be used for type. Note that in Common Lisp, the first argument to |
The following error-related macro is also defined:
ignore-errors forms... | Special Form |
This executes forms exactly like a progn , except that
errors are ignored during the forms. More precisely, if
an error is signaled then ignore-errors immediately
aborts execution of the forms and returns nil .
If the forms complete successfully, ignore-errors
returns the result of the last form.
|
Many of the advanced features of this package, such as defun*
,
loop
, and setf
, are implemented as Lisp macros. In
byte-compiled code, these complex notations will be expanded into
equivalent Lisp code which is simple and efficient. For example,
the forms
(incf i n) (push x (car p))
are expanded at compile-time to the Lisp forms
(setq i (+ i n)) (setcar p (cons x (car p)))
which are the most efficient ways of doing these respective operations
in Lisp. Thus, there is no performance penalty for using the more
readable incf
and push
forms in your compiled code.
Interpreted code, on the other hand, must expand these macros
every time they are executed. For this reason it is strongly
recommended that code making heavy use of macros be compiled.
(The features labeled "Special Form" instead of "Function" in
this manual are macros.) A loop using incf
a hundred times
will execute considerably faster if compiled, and will also
garbage-collect less because the macro expansion will not have
to be generated, used, and thrown away a hundred times.
You can find out how a macro expands by using the
cl-prettyexpand
function.
cl-prettyexpand form &optional full | Function |
This function takes a single Lisp form as an argument and inserts
a nicely formatted copy of it in the current buffer (which must be
in Lisp mode so that indentation works properly). It also expands
all Lisp macros which appear in the form. The easiest way to use
this function is to go to the *scratch* buffer and type, say,
(cl-prettyexpand '(loop for x below 10 collect x)) and type C-x C-e immediately after the closing parenthesis; the expansion (block nil (let* ((x 0) (G1004 nil)) (while (< x 10) (setq G1004 (cons x G1004)) (setq x (+ x 1))) (nreverse G1004))) will be inserted into the buffer. (The If the optional argument full is true, then all
macros are expanded, including (cl-prettyexpand '(pushnew 'x list)) -| (setq list (adjoin 'x list)) (cl-prettyexpand '(pushnew 'x list) t) -| (setq list (if (memq 'x list) list (cons 'x list))) (cl-prettyexpand '(caddr (member* 'a list)) t) -| (car (cdr (cdr (memq 'a list)))) Note that |
Common Lisp compliance has in general not been sacrificed for the
sake of efficiency. A few exceptions have been made for cases
where substantial gains were possible at the expense of marginal
incompatibility. One example is the use of memq
(which is
treated very efficiently by the byte-compiler) to scan for keyword
arguments; this can become confused in rare cases when keyword
symbols are used as both keywords and data values at once. This
is extremely unlikely to occur in practical code, and the use of
memq
allows functions with keyword arguments to be nearly
as fast as functions that use &optional
arguments.
The Common Lisp standard (as embodied in Steele's book) uses the
phrase "it is an error if" to indicate a situation which is not
supposed to arise in complying programs; implementations are strongly
encouraged but not required to signal an error in these situations.
This package sometimes omits such error checking in the interest of
compactness and efficiency. For example, do
variable
specifiers are supposed to be lists of one, two, or three forms;
extra forms are ignored by this package rather than signaling a
syntax error. The endp
function is simply a synonym for
null
in this package. Functions taking keyword arguments
will accept an odd number of arguments, treating the trailing
keyword as if it were followed by the value nil
.
Argument lists (as processed by defun*
and friends)
are checked rigorously except for the minor point just
mentioned; in particular, keyword arguments are checked for
validity, and &allow-other-keys
and :allow-other-keys
are fully implemented. Keyword validity checking is slightly
time consuming (though not too bad in byte-compiled code);
you can use &allow-other-keys
to omit this check. Functions
defined in this package such as find
and member*
do check their keyword arguments for validity.
The byte-compiler that comes with Emacs 18 normally fails to expand
macros that appear in top-level positions in the file (i.e., outside
of defun
s or other enclosing forms). This would have
disastrous consequences to programs that used such top-level macros
as defun*
, eval-when
, and defstruct
. To
work around this problem, the CL package patches the Emacs
18 compiler to expand top-level macros. This patch will apply to
your own macros, too, if they are used in a top-level context.
The patch will not harm versions of the Emacs 18 compiler which
have already had a similar patch applied, nor will it affect the
optimizing Emacs 19 byte-compiler written by Jamie Zawinski and
Hallvard Furuseth. The patch is applied to the byte compiler's
code in Emacs' memory, not to the bytecomp.elc
file
stored on disk.
The Emacs 19 compiler (for Emacs 18) is available from various
Emacs Lisp archive sites such as archive.cis.ohio-state.edu
.
Its use is highly recommended; many of the Common Lisp macros emit
code which can be improved by optimization. In particular,
block
s (whether explicit or implicit in constructs like
defun*
and loop
) carry a fair run-time penalty; the
optimizing compiler removes block
s which are not actually
referenced by return
or return-from
inside the block.
Following is a list of all known incompatibilities between this package and Common Lisp as documented in Steele (2nd edition).
Certain function names, such as member
, assoc
, and
floor
, were already taken by (incompatible) Emacs Lisp
functions; this package appends *
to the names of its
Common Lisp versions of these functions.
The word defun*
is required instead of defun
in order
to use extended Common Lisp argument lists in a function. Likewise,
defmacro*
and function*
are versions of those forms
which understand full-featured argument lists. The &whole
keyword does not work in defmacro
argument lists (except
inside recursive argument lists).
In order to allow an efficient implementation, keyword arguments use
a slightly cheesy parser which may be confused if a keyword symbol
is passed as the value of another keyword argument.
(Specifically, (memq :keyword rest-of-arguments)
is used to scan for :keyword
among the supplied
keyword arguments.)
The eql
and equal
predicates do not distinguish
between IEEE floating-point plus and minus zero. The equalp
predicate has several differences with Common Lisp; see Predicates.
The setf
mechanism is entirely compatible, except that
setf-methods return a list of five values rather than five
values directly. Also, the new "setf
function" concept
(typified by (defun (setf foo) ...)
) is not implemented.
The do-all-symbols
form is the same as do-symbols
with no obarray argument. In Common Lisp, this form would
iterate over all symbols in all packages. Since Emacs obarrays
are not a first-class package mechanism, there is no way for
do-all-symbols
to locate any but the default obarray.
The loop
macro is complete except that loop-finish
and type specifiers are unimplemented.
The multiple-value return facility treats lists as multiple
values, since Emacs Lisp cannot support multiple return values
directly. The macros will be compatible with Common Lisp if
values
or values-list
is always used to return to
a multiple-value-bind
or other multiple-value receiver;
if values
is used without multiple-value-...
or vice-versa the effect will be different from Common Lisp.
Many Common Lisp declarations are ignored, and others match
the Common Lisp standard in concept but not in detail. For
example, local special
declarations, which are purely
advisory in Emacs Lisp, do not rigorously obey the scoping rules
set down in Steele's book.
The variable *gensym-counter*
starts out with a pseudo-random
value rather than with zero. This is to cope with the fact that
generated symbols become interned when they are written to and
loaded back from a file.
The defstruct
facility is compatible, except that structures
are of type :type vector :named
by default rather than some
special, distinct type. Also, the :type
slot option is ignored.
The second argument of check-type
is treated differently.
Following is a list of all known incompatibilities between this package
and the older Quiroz cl.el
package.
This package's emulation of multiple return values in functions is incompatible with that of the older package. That package attempted to come as close as possible to true Common Lisp multiple return values; unfortunately, it could not be 100% reliable and so was prone to occasional surprises if used freely. This package uses a simpler method, namely replacing multiple values with lists of values, which is more predictable though more noticeably different from Common Lisp.
The defkeyword
form and keywordp
function are not
implemented in this package.
The member
, floor
, ceiling
, truncate
,
round
, mod
, and rem
functions are suffixed
by *
in this package to avoid collision with existing
functions in Emacs 18 or Emacs 19. The older package simply
redefined these functions, overwriting the built-in meanings and
causing serious portability problems with Emacs 19. (Some more
recent versions of the Quiroz package changed the names to
cl-member
, etc.; this package defines the latter names as
aliases for member*
, etc.)
Certain functions in the old package which were buggy or inconsistent
with the Common Lisp standard are incompatible with the conforming
versions in this package. For example, eql
and member
were synonyms for eq
and memq
in that package, setf
failed to preserve correct order of evaluation of its arguments, etc.
Finally, unlike the older package, this package is careful to
prefix all of its internal names with cl-
. Except for a
few functions which are explicitly defined as additional features
(such as floatp-safe
and letf
), this package does not
export any non-cl-
symbols which are not also part of Common
Lisp.
cl-compat
packageThe CL package includes emulations of some features of the
old cl.el
, in the form of a compatibility package
cl-compat
. To use it, put (require 'cl-compat)
in
your program.
The old package defined a number of internal routines without
cl-
prefixes or other annotations. Call to these routines
may have crept into existing Lisp code. cl-compat
provides emulations of the following internal routines:
pair-with-newsyms
, zip-lists
, unzip-lists
,
reassemble-arglists
, duplicate-symbols-p
,
safe-idiv
.
Some setf
forms translated into calls to internal
functions that user code might call directly. The functions
setnth
, setnthcdr
, and setelt
fall in
this category; they are defined by cl-compat
, but the
best fix is to change to use setf
properly.
The cl-compat
file defines the keyword functions
keywordp
, keyword-of
, and defkeyword
,
which are not defined by the new CL package because the
use of keywords as data is discouraged.
The build-klist
mechanism for parsing keyword arguments
is emulated by cl-compat
; the with-keyword-args
macro is not, however, and in any case it's best to change to
use the more natural keyword argument processing offered by
defun*
.
Multiple return values are treated differently by the two
Common Lisp packages. The old package's method was more
compatible with true Common Lisp, though it used heuristics
that caused it to report spurious multiple return values in
certain cases. The cl-compat
package defines a set
of multiple-value macros that are compatible with the old
CL package; again, they are heuristic in nature, but they
are guaranteed to work in any case where the old package's
macros worked. To avoid name collision with the "official"
multiple-value facilities, the ones in cl-compat
have
capitalized names: Values
, Values-list
,
Multiple-value-bind
, etc.
The functions cl-floor
, cl-ceiling
, cl-truncate
,
and cl-round
are defined by cl-compat
to use the
old-style multiple-value mechanism, just as they did in the old
package. The newer floor*
and friends return their two
results in a list rather than as multiple values. Note that
older versions of the old package used the unadorned names
floor
, ceiling
, etc.; cl-compat
cannot use
these names because they conflict with Emacs 19 built-ins.
This package is meant to be used as an extension to Emacs Lisp, not as an Emacs implementation of true Common Lisp. Some of the remaining differences between Emacs Lisp and Common Lisp make it difficult to port large Common Lisp applications to Emacs. For one, some of the features in this package are not fully compliant with ANSI or Steele; see Common Lisp Compatibility. But there are also quite a few features that this package does not provide at all. Here are some major omissions that you will want watch out for when bringing Common Lisp code into Emacs.
foo
in one place and Foo
or FOO
in another.
Emacs Lisp will treat these as three distinct symbols.
Some Common Lisp code is written entirely in upper case. While Emacs
is happy to let the program's own functions and variables use
this convention, calls to Lisp builtins like if
and
defun
will have to be changed to lower case.
let
bindings apply only to references physically within their bodies
(or within macro expansions in their bodies). Emacs Lisp, by
contrast, uses dynamic scoping wherein a binding to a
variable is visible even inside functions called from the body.
Variables in Common Lisp can be made dynamically scoped by
declaring them special
or using defvar
. In Emacs
Lisp it is as if all variables were declared special
.
Often you can use code that was written for lexical scoping even in a dynamically scoped Lisp, but not always. Here is an example of a Common Lisp code fragment that would fail in Emacs Lisp:
(defun map-odd-elements (func list) (loop for x in list for flag = t then (not flag) collect (if flag x (funcall func x)))) (defun add-odd-elements (list x) (map-odd-elements (function (lambda (a) (+ a x))) list))
In Common Lisp, the two functions' usages of x
are completely
independent. In Emacs Lisp, the binding to x
made by
add-odd-elements
will have been hidden by the binding
in map-odd-elements
by the time the (+ a x)
function
is called.
(This package avoids such problems in its own mapping functions
by using names like cl-x
instead of x
internally;
as long as you don't use the cl-
prefix for your own
variables no collision can occur.)
See Lexical Bindings, for a description of the lexical-let
form which establishes a Common Lisp-style lexical binding, and some
examples of how it differs from Emacs' regular let
.
'
,
whereas Emacs Lisp's parser just treats quote as a special case.
Some Lisp packages use reader macros to create special syntaxes
for themselves, which the Emacs parser is incapable of reading.
The lack of reader macros, incidentally, is the reason behind
Emacs Lisp's unusual backquote syntax. Since backquotes are
implemented as a Lisp package and not built-in to the Emacs
parser, they are forced to use a regular macro named `
which is used with the standard function/macro call notation.
#
that the Emacs Lisp parser
won't understand. For example, #| ... |#
is an
alternate comment notation, and #+lucid (foo)
tells
the parser to ignore the (foo)
except in Lucid Common
Lisp.
package:symbol
or package::symbol
.
Emacs Lisp has a single namespace for all interned symbols, and
then uses a naming convention of putting a prefix like cl-
in front of the name. Some Emacs packages adopt the Common Lisp-like
convention of using cl:
or cl::
as the prefix.
However, the Emacs parser does not understand colons and just
treats them as part of the symbol name. Thus, while mapcar
and lisp:mapcar
may refer to the same symbol in Common
Lisp, they are totally distinct in Emacs Lisp. Common Lisp
programs which refer to a symbol by the full name sometimes
and the short name other times will not port cleanly to Emacs.
Emacs Lisp does have a concept of "obarrays," which are package-like collections of symbols, but this feature is not strong enough to be used as a true package mechanism.
format
function is quite different between Common
Lisp and Emacs Lisp. It takes an additional "destination"
argument before the format string. A destination of nil
means to format to a string as in Emacs Lisp; a destination
of t
means to write to the terminal (similar to
message
in Emacs). Also, format control strings are
utterly different; ~
is used instead of %
to
introduce format codes, and the set of available codes is
much richer. There are no notations like \n
for
string literals; instead, format
is used with the
"newline" format code, ~%
. More advanced formatting
codes provide such features as paragraph filling, case
conversion, and even loops and conditionals.
While it would have been possible to implement most of Common
Lisp format
in this package (under the name format*
,
of course), it was not deemed worthwhile. It would have required
a huge amount of code to implement even a decent subset of
format*
, yet the functionality it would provide over
Emacs Lisp's format
would rarely be useful.
#(a b c)
notation in Common Lisp. To further complicate
matters, Emacs 19 introduces its own #(
notation for
something entirely different--strings with properties.
#\A
instead of ?A
. Also, string=
and string-equal
are synonyms in Emacs Lisp whereas the latter is case-insensitive
in Common Lisp.
defconstant
where Emacs Lisp uses defconst
. Similarly, make-list
takes its arguments in different ways in the two Lisps but does
exactly the same thing, so this package has not bothered to
implement a Common Lisp-style make-list
.
compiler-let
, tagbody
, prog
,
ldb/dpb
, parse-integer
, cerror
.
(defun sum-list (list) (if list (+ (car list) (sum-list (cdr list))) 0))
where a more iteratively-minded programmer might write one of these forms:
(let ((total 0)) (dolist (x my-list) (incf total x)) total) (loop for x in my-list sum x)
While this would be mainly a stylistic choice in most Common Lisps, in Emacs Lisp you should be aware that the iterative forms are much faster than recursion. Also, Lisp programmers will want to note that the current Emacs Lisp compiler does not optimize tail recursion.
abs
: Numerical Functions
acons
: Association Lists
adjoin
: Lists as Sets
assert
: Assertions
assoc*
: Association Lists
assoc-if
: Association Lists
assoc-if-not
: Association Lists
block
: Blocks and Exits
butlast
: List Functions
caddr
: List Functions
callf
: Modify Macros
callf2
: Modify Macros
case
: Conditionals
ceiling*
: Numerical Functions
check-type
: Assertions
cl-float-limits
: Implementation Parameters
cl-prettyexpand
: Efficiency Concerns
clrhash
: Hash Tables
coerce
: Type Predicates
compiler-macroexpand
: Macros
concatenate
: Sequence Functions
copy-list
: List Functions
copy-tree
: List Functions
count
: Searching Sequences
count-if
: Searching Sequences
count-if-not
: Searching Sequences
decf
: Modify Macros
declaim
: Declarations
declare
: Declarations
defalias
: Function Aliases
define-compiler-macro
: Macros
define-modify-macro
: Customizing Setf
define-setf-method
: Customizing Setf
defmacro*
: Argument Lists
defsetf
: Customizing Setf
defstruct
: Structures
defsubst*
: Argument Lists
deftype
: Type Predicates
defun*
: Argument Lists
delete
: Sequence Functions
delete*
: Sequence Functions
delete-duplicates
: Sequence Functions
delete-if
: Sequence Functions
delete-if-not
: Sequence Functions
destructuring-bind
: Macros
do
: Iteration
do*
: Iteration
do-all-symbols
: Iteration
do-symbols
: Iteration
dolist
: Iteration
dotimes
: Iteration
ecase
: Conditionals
endp
: List Functions
eql
: Equality Predicates
equalp
: Equality Predicates
etypecase
: Conditionals
eval-when
: Time of Evaluation
eval-when-compile
: Time of Evaluation
evenp
: Predicates on Numbers
every
: Mapping over Sequences
expt
: Numerical Functions
fill
: Sequence Functions
find
: Searching Sequences
find-if
: Searching Sequences
find-if-not
: Searching Sequences
first
: List Functions
flet
: Function Bindings
floatp-safe
: Predicates on Numbers
floor*
: Numerical Functions
function*
: Argument Lists
gcd
: Numerical Functions
gensym
: Creating Symbols
gentemp
: Creating Symbols
get*
: Property Lists
get-setf-method
: Customizing Setf
getf
: Property Lists
gethash
: Hash Tables
hash-table-count
: Hash Tables
hash-table-p
: Hash Tables
ignore-errors
: Assertions
incf
: Modify Macros
intersection
: Lists as Sets
isqrt
: Numerical Functions
labels
: Function Bindings
last*
: List Functions
lcm
: Numerical Functions
ldiff
: List Functions
letf
: Modify Macros
letf*
: Modify Macros
lexical-let
: Lexical Bindings
lexical-let*
: Lexical Bindings
list*
: List Functions
list-length
: List Functions
load-time-value
: Time of Evaluation
locally
: Declarations
loop
: Loop Basics, Iteration
macrolet
: Macro Bindings
make-hash-table
: Hash Tables
make-random-state
: Random Numbers
map
: Mapping over Sequences
mapc
: Mapping over Sequences
mapcan
: Mapping over Sequences
mapcar*
: Mapping over Sequences
mapcon
: Mapping over Sequences
maphash
: Hash Tables
mapl
: Mapping over Sequences
maplist
: Mapping over Sequences
member
: Lists as Sets
member*
: Lists as Sets
member-if
: Lists as Sets
member-if-not
: Lists as Sets
merge
: Sorting Sequences
minusp
: Predicates on Numbers
mismatch
: Searching Sequences
mod*
: Numerical Functions
multiple-value-bind
: Multiple Values
multiple-value-setq
: Multiple Values
nbutlast
: List Functions
nintersection
: Lists as Sets
notany
: Mapping over Sequences
notevery
: Mapping over Sequences
nset-difference
: Lists as Sets
nset-exclusive-or
: Lists as Sets
nsublis
: Substitution of Expressions
nsubst
: Substitution of Expressions
nsubst-if
: Substitution of Expressions
nsubst-if-not
: Substitution of Expressions
nsubstitute
: Sequence Functions
nsubstitute-if
: Sequence Functions
nsubstitute-if-not
: Sequence Functions
nunion
: Lists as Sets
oddp
: Predicates on Numbers
pairlis
: Association Lists
plusp
: Predicates on Numbers
pop
: Modify Macros
position
: Searching Sequences
position-if
: Searching Sequences
position-if-not
: Searching Sequences
proclaim
: Declarations
progv
: Dynamic Bindings
psetf
: Modify Macros
psetq
: Assignment
push
: Modify Macros
pushnew
: Modify Macros
random*
: Random Numbers
random-state-p
: Random Numbers
rassoc
: Association Lists
rassoc*
: Association Lists
rassoc-if
: Association Lists
rassoc-if-not
: Association Lists
reduce
: Mapping over Sequences
rem*
: Numerical Functions
remf
: Property Lists
remhash
: Hash Tables
remove
: Sequence Functions
remove*
: Sequence Functions
remove-duplicates
: Sequence Functions
remove-if
: Sequence Functions
remove-if-not
: Sequence Functions
remprop
: Property Lists
remq
: Sequence Functions
replace
: Sequence Functions
rest
: List Functions
return
: Blocks and Exits
return-from
: Blocks and Exits
rotatef
: Modify Macros
round*
: Numerical Functions
search
: Searching Sequences
set-difference
: Lists as Sets
set-exclusive-or
: Lists as Sets
setf
: Basic Setf
shiftf
: Modify Macros
some
: Mapping over Sequences
sort*
: Sorting Sequences
stable-sort
: Sorting Sequences
sublis
: Substitution of Expressions
subseq
: Sequence Functions
subsetp
: Lists as Sets
subst
: Substitution of Expressions
subst-if
: Substitution of Expressions
subst-if-not
: Substitution of Expressions
substitute
: Sequence Functions
substitute-if
: Sequence Functions
substitute-if-not
: Sequence Functions
symbol-macrolet
: Macro Bindings
tailp
: Lists as Sets
the
: Declarations
tree-equal
: List Functions
truncate*
: Numerical Functions
typecase
: Conditionals
typep
: Type Predicates
union
: Lists as Sets
unless
: Conditionals
when
: Conditionals
*gensym-counter*
: Creating Symbols
*random-state*
: Random Numbers
float-epsilon
: Implementation Parameters
float-negative-epsilon
: Implementation Parameters
least-negative-float
: Implementation Parameters
least-negative-normalized-float
: Implementation Parameters
least-positive-float
: Implementation Parameters
least-positive-normalized-float
: Implementation Parameters
most-negative-fixnum
: Implementation Parameters
most-negative-float
: Implementation Parameters
most-positive-fixnum
: Implementation Parameters
most-positive-float
: Implementation Parameters