cl.texi 206 KB
Newer Older
Glenn Morris's avatar
Glenn Morris committed
1
\input texinfo    @c -*-texinfo-*-
2
@setfilename ../../info/cl
Glenn Morris's avatar
Glenn Morris committed
3
@settitle Common Lisp Extensions
4
@include emacsver.texi
Glenn Morris's avatar
Glenn Morris committed
5 6 7 8

@copying
This file documents the GNU Emacs Common Lisp emulation package.

9
Copyright @copyright{} 1993, 2001-2012 Free Software Foundation, Inc.
Glenn Morris's avatar
Glenn Morris committed
10 11 12

@quotation
Permission is granted to copy, distribute and/or modify this document
13
under the terms of the GNU Free Documentation License, Version 1.3 or
Glenn Morris's avatar
Glenn Morris committed
14
any later version published by the Free Software Foundation; with no
15 16 17
Invariant Sections, with the Front-Cover texts being ``A GNU Manual'',
and with the Back-Cover Texts as in (a) below.  A copy of the license
is included in the section entitled ``GNU Free Documentation License''.
Glenn Morris's avatar
Glenn Morris committed
18

19 20 21
(a) The FSF's Back-Cover Text is: ``You have the freedom to copy and
modify this GNU manual.  Buying copies from the FSF supports it in
developing GNU and promoting software freedom.''
Glenn Morris's avatar
Glenn Morris committed
22 23 24
@end quotation
@end copying

25
@dircategory Emacs lisp libraries
Glenn Morris's avatar
Glenn Morris committed
26
@direntry
Glenn Morris's avatar
Glenn Morris committed
27
* CL: (cl).                     Partial Common Lisp support for Emacs Lisp.
Glenn Morris's avatar
Glenn Morris committed
28 29 30 31 32 33 34 35 36 37
@end direntry

@finalout

@titlepage
@sp 6
@center @titlefont{Common Lisp Extensions}
@sp 4
@center For GNU Emacs Lisp
@sp 1
38
@center as distributed with Emacs @value{EMACSVER}
Glenn Morris's avatar
Glenn Morris committed
39 40 41 42 43 44 45 46
@sp 5
@center Dave Gillespie
@center daveg@@synaptics.com
@page
@vskip 0pt plus 1filll
@insertcopying
@end titlepage

47 48 49
@contents

@ifnottex
50 51 52
@node Top
@top GNU Emacs Common Lisp Emulation

53 54 55
@insertcopying
@end ifnottex

Glenn Morris's avatar
Glenn Morris committed
56
@menu
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
* Overview::             Basics, usage, etc.
* Program Structure::    Arglists, @code{cl-eval-when}, @code{defalias}.
* Predicates::           @code{cl-typep} and @code{cl-equalp}.
* Control Structure::    @code{setf}, @code{cl-do}, @code{cl-loop}, etc.
* Macros::               Destructuring, @code{cl-define-compiler-macro}.
* Declarations::         @code{cl-proclaim}, @code{cl-declare}, etc.
* Symbols::              Property lists, @code{cl-gensym}.
* Numbers::              Predicates, functions, random numbers.
* Sequences::            Mapping, functions, searching, sorting.
* Lists::                @code{cl-caddr}, @code{cl-sublis}, @code{cl-member}, @code{cl-assoc}, etc.
* Structures::           @code{cl-defstruct}.
* Assertions::           @code{cl-check-type}, @code{cl-assert}, @code{ignore-errors}.

* Efficiency Concerns::         Hints and techniques.
* Common Lisp Compatibility::   All known differences with Steele.
* Old CL Compatibility::        All known differences with old cl.el.
* Porting Common Lisp::         Hints for porting Common Lisp code.
Glenn Morris's avatar
Glenn Morris committed
74 75 76 77 78 79

* GNU Free Documentation License:: The license for this documentation.
* Function Index::
* Variable Index::
@end menu

80
@node Overview
Glenn Morris's avatar
Glenn Morris committed
81 82 83
@chapter Overview

@noindent
84 85 86 87 88
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.

Glenn Morris's avatar
Glenn Morris committed
89 90 91 92 93 94 95
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.

96
The @code{CL} package adds a number of Common Lisp functions and
Glenn Morris's avatar
Glenn Morris committed
97
control structures to Emacs Lisp.  While not a 100% complete
98
implementation of Common Lisp, @code{CL} adds enough functionality
Glenn Morris's avatar
Glenn Morris committed
99 100 101 102 103 104 105 106 107 108 109 110 111 112
to make Emacs Lisp programming significantly more convenient.

Some Common Lisp features have been omitted from this package
for various reasons:

@itemize @bullet
@item
Some features are too complex or bulky relative to their benefit
to Emacs Lisp programmers.  CLOS and Common Lisp streams are fine
examples of this group.

@item
Other features cannot be implemented without modification to the
Emacs Lisp interpreter itself, such as multiple return values,
113 114
case-insensitive symbols, and complex numbers.
The @code{CL} package generally makes no attempt to emulate these
Glenn Morris's avatar
Glenn Morris committed
115 116 117 118
features.

@end itemize

119 120
The package described here was originally written by Dave Gillespie,
@file{daveg@@synaptics.com}, as a total rewrite of an earlier
Glenn Morris's avatar
Glenn Morris committed
121
1986 @file{cl.el} package by Cesar Quiroz.  Most features of the
122
Quiroz package were retained; any incompatibilities are
Glenn Morris's avatar
Glenn Morris committed
123 124 125
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
126 127
environment.  Stefan Monnier added the file @file{cl-lib.el} and
rationalized the namespace for Emacs 24.3.
Glenn Morris's avatar
Glenn Morris committed
128 129

@menu
130 131 132
* Usage::                How to use the CL package.
* Organization::         The package's five component files.
* Naming Conventions::   Notes on CL function names.
Glenn Morris's avatar
Glenn Morris committed
133 134
@end menu

135
@node Usage
Glenn Morris's avatar
Glenn Morris committed
136 137 138
@section Usage

@noindent
139 140 141 142
The @code{CL} package is distributed with Emacs, so there is no need
to install any additional files in order to start using it.  Lisp code
that uses features from the @code{CL} package should simply include at
the beginning:
Glenn Morris's avatar
Glenn Morris committed
143 144

@example
145
(require 'cl-lib)
Glenn Morris's avatar
Glenn Morris committed
146 147 148
@end example

@noindent
149 150
You may wish to add such a statement to your init file, if you
make frequent use of CL features.
Glenn Morris's avatar
Glenn Morris committed
151

152
@node Organization
Glenn Morris's avatar
Glenn Morris committed
153 154 155
@section Organization

@noindent
156
The Common Lisp package is organized into four main files:
Glenn Morris's avatar
Glenn Morris committed
157 158

@table @file
159 160 161
@item cl-lib.el
This is the main file, which contains basic functions
and information about the package.  This file is relatively compact.
Glenn Morris's avatar
Glenn Morris committed
162 163 164 165

@item cl-extra.el
This file contains the larger, more complex or unusual functions.
It is kept separate so that packages which only want to use Common
166
Lisp fundamentals like the @code{cl-incf} function won't need to pay
Glenn Morris's avatar
Glenn Morris committed
167 168 169 170
the overhead of loading the more advanced functions.

@item cl-seq.el
This file contains most of the advanced functions for operating
171
on sequences or lists, such as @code{cl-delete-if} and @code{cl-assoc}.
Glenn Morris's avatar
Glenn Morris committed
172 173

@item cl-macs.el
174 175 176 177 178 179
This file contains the features that are macros instead of functions.
Macros expand when the caller is compiled, not when it is run, so the
macros generally only need to be present when the byte-compiler is
running (or when the macros are used in uncompiled code).  Most of the
macros of this package are isolated in @file{cl-macs.el} so that they
won't take up memory unless you are compiling.
Glenn Morris's avatar
Glenn Morris committed
180 181
@end table

182
The file @file{cl-lib.el} includes all necessary @code{autoload}
Glenn Morris's avatar
Glenn Morris committed
183
commands for the functions and macros in the other three files.
184
All you have to do is @code{(require 'cl-lib)}, and @file{cl-lib.el}
Glenn Morris's avatar
Glenn Morris committed
185 186 187
will take care of pulling in the other files when they are
needed.

188 189 190 191 192 193 194 195 196 197 198 199 200 201
There is another file, @file{cl.el}, which was the main entry point
to the CL package prior to Emacs 24.3.  Nowadays, it is replaced
by @file{cl-lib.el}.  The two provide the same features, but use
different function names (in fact, @file{cl.el} just defines aliases
to the @file{cl-lib.el} definitions).  In particular, the old @file{cl.el}
does not use a clean namespace.  For this reason, Emacs has a policy
that packages distributed with Emacs must not load @code{cl} at run time.
(It is ok for them to load @code{cl} at @emph{compile} time, with
@code{eval-when-compile}, and use the macros it provides.)  There is
no such restriction on the use of @code{cl-lib}.  New code should use
@code{cl-lib} rather than @code{cl}.  @xref{Naming Conventions}.

There is one more file, @file{cl-compat.el}, which defines some
routines from the older CL package that are not otherwise
Glenn Morris's avatar
Glenn Morris committed
202 203 204
present in the new package.  This includes internal routines
like @code{setelt} and @code{zip-lists}, deprecated features
like @code{defkeyword}, and an emulation of the old-style
Glenn Morris's avatar
Glenn Morris committed
205 206
multiple-values feature.  This file is obsolete and should not be used
in new code.  @xref{Old CL Compatibility}.
Glenn Morris's avatar
Glenn Morris committed
207

208
@node Naming Conventions
Glenn Morris's avatar
Glenn Morris committed
209 210 211 212
@section Naming Conventions

@noindent
Except where noted, all functions defined by this package have the
213 214
same calling conventions as their Common Lisp counterparts, and
names that are those of Common Lisp plus a @samp{cl-} prefix.
Glenn Morris's avatar
Glenn Morris committed
215 216

Internal function and variable names in the package are prefixed
217 218
by @code{cl--}.  Here is a complete list of functions prefixed by
@code{cl-} that were not taken from Common Lisp:
Glenn Morris's avatar
Glenn Morris committed
219

220
@c FIXME lexical-let lexical-let*
Glenn Morris's avatar
Glenn Morris committed
221
@example
222 223
cl-callf         cl-callf2        cl-defsubst
cl-floatp-safe   cl-letf          cl-letf*
Glenn Morris's avatar
Glenn Morris committed
224 225
@end example

226
The following simple functions and macros are defined in @file{cl-lib.el};
Glenn Morris's avatar
Glenn Morris committed
227 228 229
they do not cause other components like @file{cl-extra} to be loaded.

@example
230 231 232 233 234 235 236 237
cl-floatp-safe   cl-endp
cl-evenp         cl-oddp          cl-plusp         cl-minusp
cl-caaar .. cl-cddddr
cl-list*         cl-ldiff         cl-rest          cl-first .. cl-tenth
cl-copy-list     cl-subst         cl-mapcar [2]
cl-adjoin [3]    cl-acons         cl-pairlis
cl-pushnew [3,4] cl-incf [4]      cl-decf [4]
cl-proclaim      cl-declaim
Glenn Morris's avatar
Glenn Morris committed
238 239 240 241 242 243 244 245 246 247 248 249
@end example

@noindent
[2] Only for one sequence argument or two list arguments.

@noindent
[3] Only if @code{:test} is @code{eq}, @code{equal}, or unspecified,
and @code{:key} is not used.

@noindent
[4] Only when @var{place} is a plain variable name.

250
@node Program Structure
Glenn Morris's avatar
Glenn Morris committed
251 252 253
@chapter Program Structure

@noindent
254
This section describes features of the @code{CL} package that have to
Glenn Morris's avatar
Glenn Morris committed
255
do with programs as a whole: advanced argument lists for functions,
256
and the @code{cl-eval-when} construct.
Glenn Morris's avatar
Glenn Morris committed
257 258

@menu
259 260
* Argument Lists::       @code{&key}, @code{&aux}, @code{cl-defun}, @code{cl-defmacro}.
* Time of Evaluation::   The @code{cl-eval-when} construct.
Glenn Morris's avatar
Glenn Morris committed
261 262 263 264 265 266
@end menu

@iftex
@secno=1
@end iftex

267
@node Argument Lists
Glenn Morris's avatar
Glenn Morris committed
268 269 270 271 272 273 274 275 276 277 278 279 280 281
@section Argument Lists

@noindent
Emacs Lisp's notation for argument lists of functions is a subset of
the Common Lisp notation.  As well as the familiar @code{&optional}
and @code{&rest} markers, Common Lisp allows you to specify default
values for optional arguments, and it provides the additional markers
@code{&key} and @code{&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.

282
@defspec cl-defun name arglist body...
Glenn Morris's avatar
Glenn Morris committed
283 284 285 286 287 288
This form is identical to the regular @code{defun} form, except
that @var{arglist} is allowed to be a full Common Lisp argument
list.  Also, the function body is enclosed in an implicit block
called @var{name}; @pxref{Blocks and Exits}.
@end defspec

289 290
@defspec cl-defsubst name arglist body...
This is just like @code{cl-defun}, except that the function that
Glenn Morris's avatar
Glenn Morris committed
291 292 293
is defined is automatically proclaimed @code{inline}, i.e.,
calls to it may be expanded into in-line code by the byte compiler.
This is analogous to the @code{defsubst} form;
294
@code{cl-defsubst} uses a different method (compiler macros) which
295
works in all versions of Emacs, and also generates somewhat more
296
efficient inline expansions.  In particular, @code{cl-defsubst}
Glenn Morris's avatar
Glenn Morris committed
297 298 299 300
arranges for the processing of keyword arguments, default values,
etc., to be done at compile-time whenever possible.
@end defspec

301
@defspec cl-defmacro name arglist body...
Glenn Morris's avatar
Glenn Morris committed
302 303 304 305 306 307 308 309 310 311
This is identical to the regular @code{defmacro} form,
except that @var{arglist} is allowed to be a full Common Lisp
argument list.  The @code{&environment} keyword is supported as
described in Steele.  The @code{&whole} keyword is supported only
within destructured lists (see below); top-level @code{&whole}
cannot be implemented with the current Emacs Lisp interpreter.
The macro expander body is enclosed in an implicit block called
@var{name}.
@end defspec

312
@defspec cl-function symbol-or-lambda
Glenn Morris's avatar
Glenn Morris committed
313 314 315 316 317
This is identical to the regular @code{function} form,
except that if the argument is a @code{lambda} form then that
form may use a full Common Lisp argument list.
@end defspec

318
Also, all forms (such as @code{cl-flet} and @code{cl-labels}) defined
Glenn Morris's avatar
Glenn Morris committed
319 320 321
in this package that include @var{arglist}s in their syntax allow
full Common Lisp argument lists.

322 323 324
Note that it is @emph{not} necessary to use @code{cl-defun} in
order to have access to most @code{CL} features in your function.
These features are always present; @code{cl-defun}'s only
Glenn Morris's avatar
Glenn Morris committed
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
difference from @code{defun} is its more flexible argument
lists and its implicit block.

The full form of a Common Lisp argument list is

@example
(@var{var}...
 &optional (@var{var} @var{initform} @var{svar})...
 &rest @var{var}
 &key ((@var{keyword} @var{var}) @var{initform} @var{svar})...
 &aux (@var{var} @var{initform})...)
@end example

Each of the five argument list sections is optional.  The @var{svar},
@var{initform}, and @var{keyword} parts are optional; if they are
omitted, then @samp{(@var{var})} may be written simply @samp{@var{var}}.

The first section consists of zero or more @dfn{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 @dfn{optional} arguments.  These
arguments may be specified in the function call; if they are not,
@var{initform} specifies the default value used for the argument.
(No @var{initform} means to use @code{nil} as the default.)  The
@var{initform} is evaluated with the bindings for the preceding
arguments already established; @code{(a &optional (b (1+ a)))}
matches one or two arguments, with the second argument defaulting
to one plus the first argument.  If the @var{svar} is specified,
it is an auxiliary variable which is bound to @code{t} if the optional
argument was specified, or to @code{nil} if the argument was omitted.
If you don't use an @var{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 @dfn{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 @code{&rest} is equivalent to that of Emacs Lisp.
Common Lisp accepts @code{&body} as a synonym for @code{&rest} in
macro contexts; this package accepts it all the time.

The fourth section consists of @dfn{keyword} arguments.  These
are optional arguments which are specified by name rather than
positionally in the argument list.  For example,

@example
374
(cl-defun foo (a &optional b &key c d (e 17)))
Glenn Morris's avatar
Glenn Morris committed
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395
@end example

@noindent
defines a function which may be called with one, two, or more
arguments.  The first two arguments are bound to @code{a} and
@code{b} in the usual way.  The remaining arguments must be
pairs of the form @code{:c}, @code{:d}, or @code{:e} followed
by the value to be bound to the corresponding argument variable.
(Symbols whose names begin with a colon are called @dfn{keywords},
and they are self-quoting in the same way as @code{nil} and
@code{t}.)

For example, the call @code{(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 @code{b} as well, since @code{(foo 1 :c 2)} would bind
@code{b} to the keyword @code{:c}, then signal an error because
@code{2} is not a valid keyword.

396 397 398 399
You can also explicitly specify the keyword argument; it need not be
simply the variable name prefixed with a colon.  For example,

@example
400
(cl-defun bar (&key (a 1) ((baz b) 4)))
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
@end example

@noindent

specifies a keyword @code{:a} that sets the variable @code{a} with
default value 1, as well as a keyword @code{baz} that sets the
variable @code{b} with default value 4.  In this case, because
@code{baz} is not self-quoting, you must quote it explicitly in the
function call, like this:

@example
(bar :a 10 'baz 42)
@end example

Ordinarily, it is an error to pass an unrecognized keyword to
Glenn Morris's avatar
Glenn Morris committed
416 417 418 419 420 421 422 423 424 425
a function, e.g., @code{(foo 1 2 :c 3 :goober 4)}.  You can ask
Lisp to ignore unrecognized keywords, either by adding the
marker @code{&allow-other-keys} after the keyword section
of the argument list, or by specifying an @code{:allow-other-keys}
argument in the call whose value is non-@code{nil}.  If the
function uses both @code{&rest} and @code{&key} at the same time,
the ``rest'' argument is bound to the keyword list as it appears
in the call.  For example:

@smallexample
426 427
(cl-defun find-thing (thing &rest rest &key need &allow-other-keys)
  (or (apply 'cl-member thing thing-list :allow-other-keys t rest)
Glenn Morris's avatar
Glenn Morris committed
428 429 430 431 432 433
      (if need (error "Thing not found"))))
@end smallexample

@noindent
This function takes a @code{:need} keyword argument, but also
accepts other keyword arguments which are passed on to the
434 435
@code{cl-member} function.  @code{allow-other-keys} is used to
keep both @code{find-thing} and @code{cl-member} from complaining
Glenn Morris's avatar
Glenn Morris committed
436 437 438 439 440 441 442 443 444 445
about each others' keywords in the arguments.

The fifth section of the argument list consists of @dfn{auxiliary
variables}.  These are not really arguments at all, but simply
variables which are bound to @code{nil} or to the specified
@var{initforms} during execution of the function.  There is no
difference between the following two functions, except for a
matter of stylistic taste:

@example
446
(cl-defun foo (a b &aux (c (+ a b)) d)
Glenn Morris's avatar
Glenn Morris committed
447 448
  @var{body})

449
(cl-defun foo (a b)
Glenn Morris's avatar
Glenn Morris committed
450 451 452 453 454 455
  (let ((c (+ a b)) d)
    @var{body}))
@end example

Argument lists support @dfn{destructuring}.  In Common Lisp,
destructuring is only allowed with @code{defmacro}; this package
456
allows it with @code{cl-defun} and other argument lists as well.
Glenn Morris's avatar
Glenn Morris committed
457 458 459 460 461 462 463
In destructuring, any argument variable (@var{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:

@example
464
(cl-defmacro dolist ((var listform &optional resultform)
Glenn Morris's avatar
Glenn Morris committed
465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
                   &rest body)
  ...)
@end example

This says that the first argument of @code{dolist} must be a list
of two or three items; if there are other arguments as well as this
list, they are stored in @code{body}.  All features allowed in
regular argument lists are allowed in these recursive argument lists.
In addition, the clause @samp{&whole @var{var}} is allowed at the
front of a recursive argument list.  It binds @var{var} to the
whole list being matched; thus @code{(&whole all a b)} matches
a list of two things, with @code{a} bound to the first thing,
@code{b} bound to the second thing, and @code{all} bound to the
list itself.  (Common Lisp allows @code{&whole} in top-level
@code{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 @code{(a b . c)} is functionally
equivalent to @code{(a b &rest c)}.

If the optimization quality @code{safety} is set to 0
(@pxref{Declarations}), error checking for wrong number of
arguments and invalid keyword arguments is disabled.  By default,
argument lists are rigorously checked.

491
@node Time of Evaluation
Glenn Morris's avatar
Glenn Morris committed
492 493 494 495 496 497 498 499 500 501 502 503 504
@section Time of Evaluation

@noindent
Normally, the byte-compiler does not actually execute the forms in
a file it compiles.  For example, if a file contains @code{(setq foo t)},
the act of compiling it will not actually set @code{foo} to @code{t}.
This is true even if the @code{setq} was a top-level form (i.e., not
enclosed in a @code{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 @code{defmacro} forms
at compile-time so that later parts of the file can refer to the
macros that are defined.

505
@defspec cl-eval-when (situations...) forms...
Glenn Morris's avatar
Glenn Morris committed
506 507 508 509 510 511
This form controls when the body @var{forms} are evaluated.
The @var{situations} list may contain any set of the symbols
@code{compile}, @code{load}, and @code{eval} (or their long-winded
ANSI equivalents, @code{:compile-toplevel}, @code{:load-toplevel},
and @code{:execute}).

512
The @code{cl-eval-when} form is handled differently depending on
Glenn Morris's avatar
Glenn Morris committed
513 514 515 516 517 518
whether or not it is being compiled as a top-level form.
Specifically, it gets special treatment if it is being compiled
by a command such as @code{byte-compile-file} which compiles files
or buffers of code, and it appears either literally at the
top level of the file or inside a top-level @code{progn}.

519
For compiled top-level @code{cl-eval-when}s, the body @var{forms} are
Glenn Morris's avatar
Glenn Morris committed
520 521 522 523 524 525 526
executed at compile-time if @code{compile} is in the @var{situations}
list, and the @var{forms} are written out to the file (to be executed
at load-time) if @code{load} is in the @var{situations} list.

For non-compiled-top-level forms, only the @code{eval} situation is
relevant.  (This includes forms executed by the interpreter, forms
compiled with @code{byte-compile} rather than @code{byte-compile-file},
527
and non-top-level forms.)  The @code{cl-eval-when} acts like a
Glenn Morris's avatar
Glenn Morris committed
528 529 530
@code{progn} if @code{eval} is specified, and like @code{nil}
(ignoring the body @var{forms}) if not.

531
The rules become more subtle when @code{cl-eval-when}s are nested;
Glenn Morris's avatar
Glenn Morris committed
532 533 534 535 536 537 538
consult Steele (second edition) for the gruesome details (and
some gruesome examples).

Some simple examples:

@example
;; Top-level forms in foo.el:
539 540 541 542 543 544 545
(cl-eval-when (compile)           (setq foo1 'bar))
(cl-eval-when (load)              (setq foo2 'bar))
(cl-eval-when (compile load)      (setq foo3 'bar))
(cl-eval-when (eval)              (setq foo4 'bar))
(cl-eval-when (eval compile)      (setq foo5 'bar))
(cl-eval-when (eval load)         (setq foo6 'bar))
(cl-eval-when (eval compile load) (setq foo7 'bar))
Glenn Morris's avatar
Glenn Morris committed
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567
@end example

When @file{foo.el} is compiled, these variables will be set during
the compilation itself:

@example
foo1  foo3  foo5  foo7      ; `compile'
@end example

When @file{foo.elc} is loaded, these variables will be set:

@example
foo2  foo3  foo6  foo7      ; `load'
@end example

And if @file{foo.el} is loaded uncompiled, these variables will
be set:

@example
foo4  foo5  foo6  foo7      ; `eval'
@end example

568
If these seven @code{cl-eval-when}s had been, say, inside a @code{defun},
Glenn Morris's avatar
Glenn Morris committed
569 570 571
then the first three would have been equivalent to @code{nil} and the
last four would have been equivalent to the corresponding @code{setq}s.

572
Note that @code{(cl-eval-when (load eval) @dots{})} is equivalent
Glenn Morris's avatar
Glenn Morris committed
573 574 575 576 577 578
to @code{(progn @dots{})} in all contexts.  The compiler treats
certain top-level forms, like @code{defmacro} (sort-of) and
@code{require}, as if they were wrapped in @code{(eval-when
(compile load eval) @dots{})}.
@end defspec

579
Emacs includes two special forms related to @code{cl-eval-when}.
Glenn Morris's avatar
Glenn Morris committed
580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
One of these, @code{eval-when-compile}, is not quite equivalent to
any @code{eval-when} construct and is described below.

The other form, @code{(eval-and-compile @dots{})}, is exactly
equivalent to @samp{(eval-when (compile load eval) @dots{})} and
so is not itself defined by this package.

@defspec eval-when-compile forms...
The @var{forms} are evaluated at compile-time; at execution time,
this form acts like a quoted constant of the resulting value.  Used
at top-level, @code{eval-when-compile} is just like @samp{eval-when
(compile eval)}.  In other contexts, @code{eval-when-compile}
allows code to be evaluated once at compile-time for efficiency
or other reasons.

This form is similar to the @samp{#.} syntax of true Common Lisp.
@end defspec

598
@defspec cl-load-time-value form
Glenn Morris's avatar
Glenn Morris committed
599 600 601 602 603 604 605
The @var{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 @samp{#,} syntax that was similar to
this, but ANSI Common Lisp replaced it with @code{load-time-value}
and gave it more well-defined semantics.

606
In a compiled file, @code{cl-load-time-value} arranges for @var{form}
Glenn Morris's avatar
Glenn Morris committed
607 608 609 610
to be evaluated when the @file{.elc} file is loaded and then used
as if it were a quoted constant.  In code compiled by
@code{byte-compile} rather than @code{byte-compile-file}, the
effect is identical to @code{eval-when-compile}.  In uncompiled
611
code, both @code{eval-when-compile} and @code{cl-load-time-value}
Glenn Morris's avatar
Glenn Morris committed
612 613 614 615 616 617 618 619 620 621
act exactly like @code{progn}.

@example
(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: "
622
          (cl-load-time-value (current-time-string))))
Glenn Morris's avatar
Glenn Morris committed
623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640
@end example

@noindent
Byte-compiled, the above defun will result in the following code
(or its compiled equivalent, of course) in the @file{.elc} file:

@example
(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--))
@end example
@end defspec

641
@node Predicates
Glenn Morris's avatar
Glenn Morris committed
642 643 644 645 646 647 648
@chapter Predicates

@noindent
This section describes functions for testing whether various
facts are true or false.

@menu
649 650
* Type Predicates::      @code{cl-typep}, @code{cl-deftype}, and @code{cl-coerce}.
* Equality Predicates::  @code{cl-equalp}.
Glenn Morris's avatar
Glenn Morris committed
651 652
@end menu

653
@node Type Predicates
Glenn Morris's avatar
Glenn Morris committed
654 655 656
@section Type Predicates

@noindent
657
The @code{CL} package defines a version of the Common Lisp @code{typep}
Glenn Morris's avatar
Glenn Morris committed
658 659
predicate.

660
@defun cl-typep object type
Glenn Morris's avatar
Glenn Morris committed
661 662
Check if @var{object} is of type @var{type}, where @var{type} is a
(quoted) type name of the sort used by Common Lisp.  For example,
663
@code{(cl-typep foo 'integer)} is equivalent to @code{(integerp foo)}.
Glenn Morris's avatar
Glenn Morris committed
664 665 666 667 668 669 670 671 672 673 674 675 676 677
@end defun

The @var{type} argument to the above function is either a symbol
or a list beginning with a symbol.

@itemize @bullet
@item
If the type name is a symbol, Emacs appends @samp{-p} to the
symbol name to form the name of a predicate function for testing
the type.  (Built-in predicates whose names end in @samp{p} rather
than @samp{-p} are used when appropriate.)

@item
The type symbol @code{t} stands for the union of all types.
678
@code{(cl-typep @var{object} t)} is always true.  Likewise, the
Glenn Morris's avatar
Glenn Morris committed
679
type symbol @code{nil} stands for nothing at all, and
680
@code{(cl-typep @var{object} nil)} is always false.
Glenn Morris's avatar
Glenn Morris committed
681 682 683

@item
The type symbol @code{null} represents the symbol @code{nil}.
684
Thus @code{(cl-typep @var{object} 'null)} is equivalent to
Glenn Morris's avatar
Glenn Morris committed
685 686 687 688
@code{(null @var{object})}.

@item
The type symbol @code{atom} represents all objects that are not cons
689
cells. Thus @code{(cl-typep @var{object} 'atom)} is equivalent to
Glenn Morris's avatar
Glenn Morris committed
690 691 692 693 694 695 696 697 698 699 700
@code{(atom @var{object})}.

@item
The type symbol @code{real} is a synonym for @code{number}, and
@code{fixnum} is a synonym for @code{integer}.

@item
The type symbols @code{character} and @code{string-char} match
integers in the range from 0 to 255.

@item
701
The type symbol @code{float} uses the @code{cl-floatp-safe} predicate
Glenn Morris's avatar
Glenn Morris committed
702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722
defined by this package rather than @code{floatp}, so it will work
correctly even in Emacs versions without floating-point support.

@item
The type list @code{(integer @var{low} @var{high})} represents all
integers between @var{low} and @var{high}, inclusive.  Either bound
may be a list of a single integer to specify an exclusive limit,
or a @code{*} to specify no limit.  The type @code{(integer * *)}
is thus equivalent to @code{integer}.

@item
Likewise, lists beginning with @code{float}, @code{real}, or
@code{number} represent numbers of that type falling in a particular
range.

@item
Lists beginning with @code{and}, @code{or}, and @code{not} form
combinations of types.  For example, @code{(or integer (float 0 *))}
represents all objects that are integers or non-negative floats.

@item
723
Lists beginning with @code{member} or @code{cl-member} represent
Glenn Morris's avatar
Glenn Morris committed
724 725 726 727 728 729 730 731 732 733 734
objects @code{eql} to any of the following values.  For example,
@code{(member 1 2 3 4)} is equivalent to @code{(integer 1 4)},
and @code{(member nil)} is equivalent to @code{null}.

@item
Lists of the form @code{(satisfies @var{predicate})} represent
all objects for which @var{predicate} returns true when called
with that object as an argument.
@end itemize

The following function and macro (not technically predicates) are
735
related to @code{cl-typep}.
Glenn Morris's avatar
Glenn Morris committed
736

737
@defun cl-coerce object type
Glenn Morris's avatar
Glenn Morris committed
738 739 740 741 742 743 744 745 746
This function attempts to convert @var{object} to the specified
@var{type}.  If @var{object} is already of that type as determined by
@code{typep}, it is simply returned.  Otherwise, certain types of
conversions will be made:  If @var{type} is any sequence type
(@code{string}, @code{list}, etc.) then @var{object} will be
converted to that type if possible.  If @var{type} is
@code{character}, then strings of length one and symbols with
one-character names can be coerced.  If @var{type} is @code{float},
then integers can be coerced in versions of Emacs that support
747
floats.  In all other circumstances, @code{cl-coerce} signals an
Glenn Morris's avatar
Glenn Morris committed
748 749 750
error.
@end defun

751
@defspec cl-deftype name arglist forms...
Glenn Morris's avatar
Glenn Morris committed
752 753 754 755 756
This macro defines a new type called @var{name}.  It is similar
to @code{defmacro} in many ways; when @var{name} is encountered
as a type name, the body @var{forms} are evaluated and should
return a type specifier that is equivalent to the type.  The
@var{arglist} is a Common Lisp argument list of the sort accepted
757
by @code{cl-defmacro}.  The type specifier @samp{(@var{name} @var{args}...)}
Glenn Morris's avatar
Glenn Morris committed
758 759 760
is expanded by calling the expander with those arguments; the type
symbol @samp{@var{name}} is expanded by calling the expander with
no arguments.  The @var{arglist} is processed the same as for
761
@code{cl-defmacro} except that optional arguments without explicit
Glenn Morris's avatar
Glenn Morris committed
762 763 764 765
defaults use @code{*} instead of @code{nil} as the ``default''
default.  Some examples:

@example
766 767 768
(cl-deftype null () '(satisfies null))    ; predefined
(cl-deftype list () '(or null cons))      ; predefined
(cl-deftype unsigned-byte (&optional bits)
Glenn Morris's avatar
Glenn Morris committed
769 770 771 772 773 774 775 776 777 778 779 780
  (list 'integer 0 (if (eq bits '*) bits (1- (lsh 1 bits)))))
(unsigned-byte 8)  @equiv{}  (integer 0 255)
(unsigned-byte)  @equiv{}  (integer 0 *)
unsigned-byte  @equiv{}  (integer 0 *)
@end example

@noindent
The last example shows how the Common Lisp @code{unsigned-byte}
type specifier could be implemented if desired; this package does
not implement @code{unsigned-byte} by default.
@end defspec

781 782 783
The @code{cl-typecase} and @code{cl-check-type} macros also use type
names.  @xref{Conditionals}.  @xref{Assertions}.  The @code{cl-map},
@code{cl-concatenate}, and @code{cl-merge} functions take type-name
Glenn Morris's avatar
Glenn Morris committed
784 785
arguments to specify the type of sequence to return.  @xref{Sequences}.

786
@node Equality Predicates
Glenn Morris's avatar
Glenn Morris committed
787 788 789
@section Equality Predicates

@noindent
790
This package defines the Common Lisp predicate @code{cl-equalp}.
Glenn Morris's avatar
Glenn Morris committed
791

792
@defun cl-equalp a b
Glenn Morris's avatar
Glenn Morris committed
793 794
This function is a more flexible version of @code{equal}.  In
particular, it compares strings case-insensitively, and it compares
795
numbers without regard to type (so that @code{(cl-equalp 3 3.0)} is
Glenn Morris's avatar
Glenn Morris committed
796 797 798 799 800 801 802 803
true).  Vectors and conses are compared recursively.  All other
objects are compared as if by @code{equal}.

This function differs from Common Lisp @code{equalp} in several
respects.  First, Common Lisp's @code{equalp} also compares
@emph{characters} case-insensitively, which would be impractical
in this package since Emacs does not distinguish between integers
and characters.  In keeping with the idea that strings are less
804
vector-like in Emacs Lisp, this package's @code{cl-equalp} also will
Glenn Morris's avatar
Glenn Morris committed
805 806 807 808 809 810
not compare strings against vectors of integers.
@end defun

Also note that the Common Lisp functions @code{member} and @code{assoc}
use @code{eql} to compare elements, whereas Emacs Lisp follows the
MacLisp tradition and uses @code{equal} for these two functions.
811 812
In Emacs, use @code{memq} (or @code{cl-member}) and @code{assq} (or
@code{cl-assoc}) to get functions which use @code{eql} for comparisons.
Glenn Morris's avatar
Glenn Morris committed
813

814
@node Control Structure
Glenn Morris's avatar
Glenn Morris committed
815 816 817 818 819
@chapter Control Structure

@noindent
The features described in the following sections implement
various advanced control structures, including the powerful
820
@c FIXME setf is now in gv.el, not cl.
Glenn Morris's avatar
Glenn Morris committed
821 822 823
@code{setf} facility and a number of looping and conditional
constructs.

824 825 826
@c FIXME setf, push are standard now.
@c lexical-let is obsolete; flet is not cl-flet.
@c values is not cl-values.
Glenn Morris's avatar
Glenn Morris committed
827
@menu
828 829 830 831 832 833 834 835
* Assignment::             The @code{cl-psetq} form.
* Generalized Variables::  @code{setf}, @code{cl-incf}, @code{push}, etc.
* Variable Bindings::      @code{cl-progv}, @code{lexical-let}, @code{flet}, @code{cl-macrolet}.
* Conditionals::           @code{cl-case}, @code{cl-typecase}.
* Blocks and Exits::       @code{cl-block}, @code{cl-return}, @code{cl-return-from}.
* Iteration::              @code{cl-do}, @code{cl-dotimes}, @code{cl-dolist}, @code{cl-do-symbols}.
* Loop Facility::          The Common Lisp @code{cl-loop} macro.
* Multiple Values::        @code{values}, @code{cl-multiple-value-bind}, etc.
Glenn Morris's avatar
Glenn Morris committed
836 837
@end menu

838
@node Assignment
Glenn Morris's avatar
Glenn Morris committed
839 840 841
@section Assignment

@noindent
842
The @code{cl-psetq} form is just like @code{setq}, except that multiple
Glenn Morris's avatar
Glenn Morris committed
843 844
assignments are done in parallel rather than sequentially.

845
@defspec cl-psetq [symbol form]@dots{}
Glenn Morris's avatar
Glenn Morris committed
846 847 848 849 850 851 852 853 854 855 856 857 858 859
This special form (actually a macro) is used to assign to several
variables simultaneously.  Given only one @var{symbol} and @var{form},
it has the same effect as @code{setq}.  Given several @var{symbol}
and @var{form} pairs, it evaluates all the @var{form}s in advance
and then stores the corresponding variables afterwards.

@example
(setq x 2 y 3)
(setq x (+ x y)  y (* x y))
x
     @result{} 5
y                     ; @r{@code{y} was computed after @code{x} was set.}
     @result{} 15
(setq x 2 y 3)
860
(cl-psetq x (+ x y)  y (* x y))
Glenn Morris's avatar
Glenn Morris committed
861 862 863 864 865 866
x
     @result{} 5
y                     ; @r{@code{y} was computed before @code{x} was set.}
     @result{} 6
@end example

867 868
The simplest use of @code{cl-psetq} is @code{(cl-psetq x y y x)}, which
exchanges the values of two variables.  (The @code{cl-rotatef} form
Glenn Morris's avatar
Glenn Morris committed
869 870 871
provides an even more convenient way to swap two variables;
@pxref{Modify Macros}.)

872
@code{cl-psetq} always returns @code{nil}.
Glenn Morris's avatar
Glenn Morris committed
873 874
@end defspec

875
@c FIXME now in gv.el.
876
@node Generalized Variables
Glenn Morris's avatar
Glenn Morris committed
877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899
@section Generalized Variables

@noindent
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 @code{setf} form is like @code{setq}, except that it accepts
arbitrary place forms on the left side rather than just
symbols.  For example, @code{(setf (car a) b)} sets the car of
@code{a} to @code{b}, doing the same operation as @code{(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 @samp{x = a[i]} gets an element from an array
and @samp{a[i] = x} stores an element using the same notation.
Just as certain forms like @code{a[i]} can be lvalues in C, there
is a set of forms that can be generalized variables in Lisp.

@menu
900 901 902
* Basic Setf::         @code{setf} and place forms.
* Modify Macros::      @code{cl-incf}, @code{push}, @code{cl-rotatef}, @code{letf}, @code{cl-callf}, etc.
* Customizing Setf::   @code{define-modify-macro}, @code{defsetf}, @code{define-setf-method}.
Glenn Morris's avatar
Glenn Morris committed
903 904
@end menu

905
@node Basic Setf
Glenn Morris's avatar
Glenn Morris committed
906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986
@subsection Basic Setf

@noindent
The @code{setf} macro is the most basic way to operate on generalized
variables.

@defspec setf [place form]@dots{}
This macro evaluates @var{form} and stores it in @var{place}, which
must be a valid generalized variable form.  If there are several
@var{place} and @var{form} pairs, the assignments are done sequentially
just as with @code{setq}.  @code{setf} returns the value of the last
@var{form}.

The following Lisp forms will work as generalized variables, and
so may appear in the @var{place} argument of @code{setf}:

@itemize @bullet
@item
A symbol naming a variable.  In other words, @code{(setf x y)} is
exactly equivalent to @code{(setq x y)}, and @code{setq} itself is
strictly speaking redundant now that @code{setf} exists.  Many
programmers continue to prefer @code{setq} for setting simple
variables, though, purely for stylistic or historical reasons.
The macro @code{(setf x y)} actually expands to @code{(setq x y)},
so there is no performance penalty for using it in compiled code.

@item
A call to any of the following Lisp functions:

@smallexample
car                 cdr                 caar .. cddddr
nth                 rest                first .. tenth
aref                elt                 nthcdr
symbol-function     symbol-value        symbol-plist
get                 get*                getf
gethash             subseq
@end smallexample

@noindent
Note that for @code{nthcdr} and @code{getf}, the list argument
of the function must itself be a valid @var{place} form.  For
example, @code{(setf (nthcdr 0 foo) 7)} will set @code{foo} itself
to 7.  Note that @code{push} and @code{pop} on an @code{nthcdr}
place can be used to insert or delete at any position in a list.
The use of @code{nthcdr} as a @var{place} form is an extension
to standard Common Lisp.

@item
The following Emacs-specific functions are also @code{setf}-able.

@smallexample
buffer-file-name                  marker-position
buffer-modified-p                 match-data
buffer-name                       mouse-position
buffer-string                     overlay-end
buffer-substring                  overlay-get
current-buffer                    overlay-start
current-case-table                point
current-column                    point-marker
current-global-map                point-max
current-input-mode                point-min
current-local-map                 process-buffer
current-window-configuration      process-filter
default-file-modes                process-sentinel
default-value                     read-mouse-position
documentation-property            screen-height
extent-data                       screen-menubar
extent-end-position               screen-width
extent-start-position             selected-window
face-background                   selected-screen
face-background-pixmap            selected-frame
face-font                         standard-case-table
face-foreground                   syntax-table
face-underline-p                  window-buffer
file-modes                        window-dedicated-p
frame-height                      window-display-table
frame-parameters                  window-height
frame-visible-p                   window-hscroll
frame-width                       window-point
get-register                      window-start
getenv                            window-width
987 988 989 990
global-key-binding                x-get-secondary-selection
keymap-parent                     x-get-selection
local-key-binding                 
mark                              
Glenn Morris's avatar
Glenn Morris committed
991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
mark-marker
@end smallexample

Most of these have directly corresponding ``set'' functions, like
@code{use-local-map} for @code{current-local-map}, or @code{goto-char}
for @code{point}.  A few, like @code{point-min}, expand to longer
sequences of code when they are @code{setf}'d (@code{(narrow-to-region
x (point-max))} in this case).

@item
A call of the form @code{(substring @var{subplace} @var{n} [@var{m}])},
where @var{subplace} is itself a valid generalized variable whose
current value is a string, and where the value stored is also a
string.  The new string is spliced into the specified part of the
destination string.  For example:

@example
(setq a (list "hello" "world"))
     @result{} ("hello" "world")
(cadr a)
     @result{} "world"
(substring (cadr a) 2 4)
     @result{} "rl"
(setf (substring (cadr a) 2 4) "o")
     @result{} "o"
(cadr a)
     @result{} "wood"
a
     @result{} ("hello" "wood")
@end example

The generalized variable @code{buffer-substring}, listed above,
also works in this way by replacing a portion of the current buffer.

@item
A call of the form @code{(apply '@var{func} @dots{})} or
@code{(apply (function @var{func}) @dots{})}, where @var{func}
is a @code{setf}-able function whose store function is ``suitable''
in the sense described in Steele's book; since none of the standard
Emacs place functions are suitable in this sense, this feature is
only interesting when used with places you define yourself with
@code{define-setf-method} or the long form of @code{defsetf}.

@item
A macro call, in which case the macro is expanded and @code{setf}
is applied to the resulting form.

@item
Any form for which a @code{defsetf} or @code{define-setf-method}
has been made.
@end itemize

Using any forms other than these in the @var{place} argument to
@code{setf} will signal an error.

The @code{setf} macro takes care to evaluate all subforms in
the proper left-to-right order; for example,

@example
1050
(setf (aref vec (cl-incf i)) i)
Glenn Morris's avatar
Glenn Morris committed
1051 1052 1053
@end example

@noindent
1054
looks like it will evaluate @code{(cl-incf i)} exactly once, before the
Glenn Morris's avatar
Glenn Morris committed
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
following access to @code{i}; the @code{setf} expander will insert
temporary variables as necessary to ensure that it does in fact work
this way no matter what setf-method is defined for @code{aref}.
(In this case, @code{aset} would be used and no such steps would
be necessary since @code{aset} takes its arguments in a convenient
order.)

However, if the @var{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

@example
(defmacro wrong-order (x y) (list 'aref y x))
@end example

@noindent
the form @code{(setf (wrong-order @var{a} @var{b}) 17)} will
evaluate @var{b} first, then @var{a}, just as in an actual call
to @code{wrong-order}.
@end defspec

1076
@node Modify Macros
Glenn Morris's avatar
Glenn Morris committed
1077 1078 1079 1080 1081 1082 1083
@subsection Modify Macros

@noindent
This package defines a number of other macros besides @code{setf}
that operate on generalized variables.  Many are interesting and
useful even when the @var{place} is just a variable name.

1084
@defspec cl-psetf [place form]@dots{}
1085
This macro is to @code{setf} what @code{cl-psetq} is to @code{setq}:
Glenn Morris's avatar
Glenn Morris committed
1086 1087 1088 1089 1090 1091
When several @var{place}s and @var{form}s 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).
@end defspec

1092
@defspec cl-incf place &optional x
Glenn Morris's avatar
Glenn Morris committed
1093 1094
This macro increments the number stored in @var{place} by one, or
by @var{x} if specified.  The incremented value is returned.  For
1095 1096
example, @code{(cl-incf i)} is equivalent to @code{(setq i (1+ i))}, and
@code{(cl-incf (car x) 2)} is equivalent to @code{(setcar x (+ (car x) 2))}.
Glenn Morris's avatar
Glenn Morris committed
1097 1098 1099 1100 1101

Once again, care is taken to preserve the ``apparent'' order of
evaluation.  For example,

@example
1102
(cl-incf (aref vec (cl-incf i)))
Glenn Morris's avatar
Glenn Morris committed
1103 1104 1105 1106 1107 1108 1109 1110 1111
@end example

@noindent
appears to increment @code{i} once, then increment the element of
@code{vec} addressed by @code{i}; this is indeed exactly what it
does, which means the above form is @emph{not} equivalent to the
``obvious'' expansion,

@example
1112
(setf (aref vec (cl-incf i)) (1+ (aref vec (cl-incf i))))   ; Wrong!
Glenn Morris's avatar
Glenn Morris committed
1113 1114 1115 1116 1117 1118
@end example

@noindent
but rather to something more like

@example
1119
(let ((temp (cl-incf i)))
Glenn Morris's avatar
Glenn Morris committed
1120 1121 1122 1123
  (setf (aref vec temp) (1+ (aref vec temp))))
@end example

@noindent
1124
Again, all of this is taken care of automatically by @code{cl-incf} and
Glenn Morris's avatar
Glenn Morris committed
1125 1126
the other generalized-variable macros.

1127 1128
As a more Emacs-specific example of @code{cl-incf}, the expression
@code{(cl-incf (point) @var{n})} is essentially equivalent to
Glenn Morris's avatar
Glenn Morris committed
1129 1130 1131
@code{(forward-char @var{n})}.
@end defspec

1132
@defspec cl-decf place &optional x
Glenn Morris's avatar
Glenn Morris committed
1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245