Common Lisp Extensions

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:

このマクロは、name という新しい型を定義します。これは多くの点で defmacro と似ています; name が型名として現われたとき、本体 forms が評価され、型に等価な型指定子を返さなければなりません。引数リストは、defmacro* で許容される種類の Common Lisp の引数リストです。型指定子 `(name args...)' はそれらの引数と共にエキスパンダが呼ばれることによって展開されます; 型シンボル `name' は、引数なしでエキスパンダが呼ばれることによって展開されます。引数リストは、オプショナル引数がデフォルトで nil が “default&rdquo である代わりに、明白に * がデフォルトとして使われることを除いて defmacro* と同じように処理されます。例を幾つか示します;

          (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 unsigned-byte type specifier could be implemented if desired; this package does not implement unsigned-byte by default.

最後の例は、もし望むなら Common Lisp の型指定子 unsigned-byte をどう実装すれば良いかを示しています; このパッケージでは、デフォルトでは unsigned-byte を実装していません。

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. 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.0s 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.

この関数は、eq とほとんど同じですが、a と b が同じ型の数値の場合、数値等価性を比較します(eq の代りにequalが使われる)。これは、浮動小数点数サポートでコンパイルされたバージョンの Emacs でのみ効果があります。Emacs の浮動小数点数は、ちょうどコンスセルのようにアロケートされたオブジェクトです。このことは、(eq 3.0 3.0) が必ずしも真になる必要がないことを意味します—もし2つの 3.0 が別々にアロケートされていれば、数は同じでもポインタは異るでしょう。しかし、(eql 3.0 3.0) は常に真です。

The types of the arguments must match, so (eql 3 3.0) is still false.

引数の型は一致しなければならないので、(eql 3 3.0) はまだ偽を返します。

Note that Emacs integers are “direct” rather than allocated, which basically means (eq 3 3) will always be true. Thus eq and eql behave differently only if floating-point numbers are involved, and are indistinguishable on Emacs versions that don't support floats.

Emacs の整数は、アロケートよりも“直接的”であることに注意してください。このことは基本的に (eq 3 3) が常に真になることを意味します。したがって、eq と eql は浮動小数点数が混じっているときのみ異なったふるまいをします。そして、それらは浮動小数点数をサポートしていないバージョンの Emacs では区別できません。

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 +0 and -0 as distinct values. Normally this doesn't matter because the standard specifies that (= 0.0 -0.0) should always be true, and this is indeed what Emacs Lisp and Common Lisp do. But the Common Lisp standard states that (eql 0.0 -0.0) and (equal 0.0 -0.0) should be false on IEEE-like machines; Emacs Lisp does not do this, and in fact the only known way to distinguish between the two zeros in Emacs Lisp is to format them and check for a minus sign.

ポジティブゼロとネガティブゼロの取り扱いにおいて、Common Lisp と僅かな違いがあります。いくらかの、特にIEEE標準演算を行うマシンにおいて、+0 と -0 は、別個の値として表現されます。標準では (= 0.0 -0.0) は常に真になるべきと規定しますが、実際 Emacs Lisp も Common Lisp もこれを行なうので、通常は問題になりません。しかし、Common Lisp の規格はIEEEライクなマシン上では (eql 0.0 -0.0) と (equal 0.0 -0.0) は偽であるべきと述べています; Emacs Lisp はこれを行いません。事実、Emacs Lisp で2つのゼロを区別するには、format してマイナスサインをチェックする方法が知られているのみです。

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.

この関数は、equal のより柔軟なバージョンです。特に、文字列の比較ではケースセンシティブで、数値の比較では型を考慮しません(そのため (equalp 3 3.0) は真です)。ベクタとコンスは再帰的に比較されます。他の全てのオブジェクトは equal で比較されます。

This function differs from Common Lisp equalp in several respects. First, Common Lisp's equalp also compares 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 vector-like in Emacs Lisp, this package's equalp also will not compare strings against vectors of integers.

この関数は、いくつかの点において Common Lisp の equalp と異なっています。第一に、Common Lisp の equalp は文字もケースセンシティブに比較します。しかし Emacs Lisp は整数と文字を区別しないので、このパッケージにおいては実益がないでしょう。この考えに沿って、Emacs Lisp においては文字列はベクタライクであるにすぎないので、やはりこのパッケージの equalp は整数のベクタに対して文字列を比較しません。

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                     ; y was computed after x was set.
               => 15
          (setq x 2 y 3)
          (psetq x (+ x y)  y (* x y))
          x
               => 5
          y                     ; y was computed before x was set.
               => 6
     

The simplest use of psetq is (psetq x y y x), which exchanges the values of two variables. (The rotatef form provides an even more convenient way to swap two variables; see Modify Macros.)

psetq always returns nil.

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 appear in the place argument of setf:

• A symbol naming a variable. In other words, (setf x y) is exactly equivalent to (setq x y), and setq itself is strictly speaking redundant now that setf exists. Many programmers continue to prefer setq for setting simple variables, though, purely for stylistic or historical reasons. The macro (setf x y) actually expands to (setq x y), so there is no performance penalty for using it in compiled code.
• A call to any of the following Lisp functions:

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

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

• The following Emacs-specific functions are also setf-able.

                 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
                 global-key-binding                x-get-cut-buffer
                 keymap-parent                     x-get-cutbuffer
                 local-key-binding                 x-get-secondary-selection
                 mark                              x-get-selection
                 mark-marker
            

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

• A call of the form (substring subplace n [m]), where 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:

                 (setq a (list "hello" "world"))
                      => ("hello" "world")
                 (cadr a)
                      => "world"
                 (substring (cadr a) 2 4)
                      => "rl"
                 (setf (substring (cadr a) 2 4) "o")
                      => "o"
                 (cadr a)
                      => "wood"
                 a
                      => ("hello" "wood")
            

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

• A call of the form (apply 'func ...) or (apply (function func) ...), where func is a 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 define-setf-method or the long form of defsetf.
• A macro call, in which case the macro is expanded and setf is applied to the resulting form.
• Any form for which a defsetf or define-setf-method has been made.

Using any forms other than these in the place argument to setf will signal an error.

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

          (setf (aref vec (incf i)) i)
     

looks like it will evaluate (incf i) exactly once, before the following access to i; the 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 aref. (In this case, aset would be used and no such steps would be necessary since aset takes its arguments in a convenient order.)

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 (setf (wrong-order a b) 17) will evaluate b first, then a, just as in an actual call to wrong-order.

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).

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 i once, then increment the element of vec addressed by i; this is indeed exactly what it does, which means the above form is not equivalent to the “obvious” expansion,

          (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 incf and the other generalized-variable macros.

As a more Emacs-specific example of incf, the expression (incf (point) n) is essentially equivalent to (forward-char n).

This macro decrements the number stored in place by one, or by x if specified.

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.

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.

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.

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.

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. rotatef always returns nil. Note that (rotatef a b) conveniently exchanges a and b.

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 a to 17 (as if by a normal let, since a is just a regular variable). After the body exits, a is set back to its original value and point is moved back to its original position.

Note that letf on (point) is not quite like a save-excursion, as the latter effectively saves a marker which tracks insertions and deletions in the buffer. Actually, a letf of (point-marker) is much closer to this behavior. (point and point-marker are equivalent as setf places; each will accept either an integer or a marker as the stored value.)

Since generalized variables look like lists, let's shorthand of using `foo' for `(foo nil)' as a binding would be ambiguous in letf and is not allowed.

However, a binding specifier may be a one-element list `(place)', which is similar to `(place place)'. In other words, the place is not disturbed on entry to the body, and the only effect of the letf is to restore the original value of place afterwards. (The redundant access-and-store suggested by the (place place) example does not actually occur.)

In most cases, the place must have a well-defined value on entry to the letf form. The only exceptions are plain variables and calls to symbol-value and symbol-function. If the symbol is not bound on entry, it is simply made unbound by makunbound or fmakunbound on exit.

This macro is to letf what let* is to let: It does the bindings in sequential rather than parallel order.

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 define-modify-macro, a way to create even more concise notations for modify macros. Note again that callf is an extension to standard Common Lisp.

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).

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 &key is not allowed in arglist, but &rest is sufficient to pass keywords on to the function.

Most of the modify macros defined by Common Lisp do not exactly follow the pattern of define-modify-macro. For example, push takes its arguments in the wrong order, and pop is completely irregular. You can define these macros “by hand” using get-setf-method, or consult the source file cl-macs.el to see how to use the internal setf building blocks.

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 setf is supposed to behave.

As a special (non-Common-Lisp) extension, a third argument of t to defsetf says that the update-fn's return value is not suitable, so that the above setf should be expanded to something more like

          (let ((temp value))
            (update-fn arg1 arg2 arg3 temp)
            temp)
     

Some examples of the use of defsetf, drawn from the standard suite of setf methods, are:

          (defsetf car setcar)
          (defsetf symbol-value set)
          (defsetf buffer-name rename-buffer t)
     

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 is shorthand for

          (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 setf and incf which invoke this setf-method will insert temporary variables as needed to make sure the apparent order of evaluation is preserved.

Another example drawn from the standard package:

          (defsetf nth (n x) (store)
            (list 'setcar (list 'nthcdr n x) store))
     

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:

1. A list of temporary variables.
2. A list of value forms corresponding to the temporary variables above. The temporary variables will be bound to these value forms as the first step of any operation on the generalized variable.
3. A list of exactly one store variable (generally obtained from a call to gensym).
4. A Lisp form which stores the contents of the store variable into the generalized variable, assuming the temporaries have been bound as described above.
5. A Lisp form which accesses the contents of the generalized variable, assuming the temporaries have been bound.

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 defsetf, the second return value is simply the list of arguments in the place form, and the first return value is a list of a corresponding number of temporary variables generated by gensym. Macros like setf and incf which use this setf-method will optimize away most temporaries that turn out to be unnecessary, so there is little reason for the setf-method itself to optimize.

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 macroexpand if get-setf-method should need to expand a macro in place. It should come from an &environment argument to the macro or setf-method that called get-setf-method.

See also the source code for the setf-methods for apply and substring, each of which works by calling get-setf-method on a simpler case, then massaging the result in various ways.

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.

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 let binding of a actually makes a temporary change to the global variable a, so foo is able to see the binding of a to 2. But lexical-let actually creates a distinct local variable a for use within its body, without any effect on the global variable of the same name.

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 (make-adder 17) returns a function object which adds 17 to its argument. If let had been used instead of lexical-let, the function object would have referred to the global n, which would have been bound to 17 only during the call to make-adder itself.

          (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 make-counter creates a distinct local variable n, which serves as a private counter for the function object that is returned.

Closed-over lexical variables persist until the last reference to them goes away, just like all other Lisp objects. For example, count-2 refers to a function object which refers to an instance of the variable n; this is the only reference to that variable, so after (setq count-2 nil) the garbage collector would be able to delete this instance of n. Of course, if a lexical-let does not actually create any closures, then the lexical variables are free as soon as the lexical-let returns.

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 lexical-let closures:

          (defun add-to-list (x list)
            (mapcar (lambda (y) (+ x y))) list)
          (add-to-list 7 '(1 2 5))
               => (8 9 12)
     

Since this lambda is only used while x is still bound, it is not necessary to make a true closure out of it.

You can use defun or flet inside a lexical-let to create a named closure. If several closures are created in the body of a single lexical-let, they all close over the same instance of the lexical variable.

The lexical-let form is an extension to Common Lisp. In true Common Lisp, all bindings are lexical unless declared otherwise.

This form is just like lexical-let, except that the bindings are made sequentially in the manner of let*.

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 flet in Common Lisp establishes a lexical binding of name, Emacs Lisp flet makes a dynamic binding. The result is that flet affects indirect calls to a function as well as calls directly inside the flet form itself.

You can use flet to disable or modify the behavior of a function in a temporary fashion. This will even work on Emacs primitives, although note that some calls to primitive functions internal to Emacs are made without going through the symbol's function cell, and so will not be affected by flet. For example,

          (flet ((message (&rest args) (push args saved-msgs)))
            (do-something))
     

This code attempts to replace the built-in function message with a function that simply saves the messages in a list rather than displaying them. The original definition of message will be restored after do-something exits. This code will work fine on messages generated by other Lisp code, but messages generated directly inside Emacs will not be caught since they make direct C-language calls to the message routines rather than going through the Lisp message function.

Functions defined by flet may use the full Common Lisp argument notation supported by defun*; also, the function body is enclosed in an implicit block as if by defun*. See Program Structure.

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 labels form. References may appear both in the body forms of labels itself, and in the bodies of the functions themselves. Thus, labels can define local recursive functions, or mutually-recursive sets of functions.

A “reference” to a function name is either a call to that function, or a use of its name quoted by quote or function to be passed on to, say, mapcar.

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, macrolet is lexically scoped even in Emacs Lisp: The macrolet binding will affect only calls that appear physically within the body forms, possibly after expansion of other macros in the body.

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 setq of a symbol macro is treated the same as a setf. I.e., (setq foo 4) in the above would be equivalent to (setf foo 4), which in turn expands to (setf (car bar) 4).

Likewise, a let or let* binding a symbol macro is treated like a letf or letf*. This differs from true Common Lisp, where the rules of lexical scoping cause a let binding to shadow a symbol-macrolet binding. In this package, only lexical-let and lexical-let* will shadow a symbol macro.

There is no analogue of defmacro for symbol macros; all symbol macros are local. A typical use of symbol-macrolet is in the expansion of another macro:

          (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 my-dolist macro is similar to dolist (see Iteration) except that the variable x becomes a true reference onto the elements of the list. The my-dolist call shown here expands to

          (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 loop macro. This package defines a nonstandard in-ref loop clause that works much like my-dolist.

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 nil or t, then it can be used by itself as a keylist without being enclosed in a list. All key values in the case form must be distinct. The final clauses may use t in place of a keylist to indicate a default clause that should be taken if none of the other clauses match. (The symbol otherwise is also recognized in place of t. To make a clause that matches the actual symbol t, nil, or otherwise, enclose the symbol in a list.)

For example, this expression reads a keystroke, then does one of four things depending on whether it is an `a', a `b', a <RET> or C-j, or anything else.

          (case (read-char)
            (?a (do-a-thing))
            (?b (do-b-thing))
            ((?\r ?\n) (do-ret-thing))
            (t (do-other-thing)))
     

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.

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 t matches any type of object; the word otherwise is also allowed. To make one clause match any of several types, use an (or ...) type specifier.

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.

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 block/return-from mechanism is quite similar to the catch/throw mechanism. The main differences are that block names are unevaluated symbols, rather than forms (such as quoted symbols) which evaluate to a tag at run-time; and also that blocks are lexically scoped whereas catch/throw are dynamically scoped. This means that functions called from the body of a catch can also throw to the catch, but the return-from referring to a block name must appear physically within the forms that make up the body of the block. They may not appear within other called functions, although they may appear within macro expansions or lambdas in the body. Block names and catch names form independent name-spaces.

In true Common Lisp, defun and defmacro surround the function or expander bodies with implicit blocks with the same name as the function or macro. This does not occur in Emacs Lisp, but this package provides defun* and defmacro* forms which do create the implicit block.

The Common Lisp looping constructs defined by this package, such as loop and dolist, also create implicit blocks just as in Common Lisp.

Because they are implemented in terms of Emacs Lisp catch and throw, blocks have the same overhead as actual catch constructs (roughly two function calls). However, the optimizing byte compiler will optimize away the catch if the block does not in fact contain any return or return-from calls that jump to it. This means that do loops and defun* functions which don't use return don't pay the overhead to support it.

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.

This macro is exactly like (return-from nil result). Common Lisp loops like do and dolist implicitly enclose themselves in nil blocks.

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 is followed by zero or more Lisp expressions, then (loop exprs...) simply creates an infinite loop executing the expressions over and over. The loop is enclosed in an implicit nil block. Thus,

          (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.)

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 let form. Then, in each iteration of the loop, the end-test is evaluated; if true, the loop is finished. Otherwise, the body forms are evaluated, then each var is set to the associated step expression (as if by a psetq form) and the next iteration begins. Once the end-test becomes true, the result forms are evaluated (with the vars still bound to their values) to produce the result returned by do.

The entire do loop is enclosed in an implicit nil block, so that you can use (return) to break out of the loop at any time.

If there are no result forms, the loop returns nil. If a given var has no step form, it is bound to its init value but not otherwise modified during the do loop (unless the code explicitly modifies it); this case is just a shorthand for putting a (let ((var init)) ...) around the loop. If init is also omitted it defaults to nil, and in this case a plain `var' can be used in place of `(var)', again following the analogy with let.

This example (from Steele) illustrates a loop which applies the function f to successive pairs of values from the lists foo and bar; it is equivalent to the call (mapcar* 'f foo bar). Note that this loop has no body forms at all, performing all its work as side effects of the rest of the loop.

          (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)))
     

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))
     

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. Unlike with Emacs's built in dolist, the loop is surrounded by an implicit nil block.

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. Unlike with Emacs's built in dolist, the loop is surrounded by an implicit nil block.

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.

This is identical to do-symbols except that the obarray argument is omitted; it always iterates over the default obarray.

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 nil. The var-clauses specify what variables should be bound during the loop, and how they should be modified or iterated throughout the course of the loop. The action-clauses are things to be done during the loop, such as computing, collecting, and returning values.

The Emacs version of the loop macro is less restrictive about the order of clauses, but things will behave most predictably if you put the variable-binding clauses with, for, and repeat before the action clauses. As in Common Lisp, initially and finally clauses can go anywhere.

Loops generally return nil by default, but you can cause them to return a value by using an accumulation clause like collect, an end-test clause like always, or an explicit return clause to jump out of the implicit block. (Because the loop body is enclosed in an implicit block, you can also use regular Lisp return or return-from to break out of the loop.)

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.

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.

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 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 &whole keyword and a variable. This variable is bound to the macro-call form itself, i.e., to a list of the form `(name args...)'. If the macro expander returns this form unchanged, then the compiler treats it as a normal function call. This allows compiler macros to work as optimizers for special cases of a function, leaving complicated cases alone.

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 (member* a list) to change to a call to the faster memq in the common case where a is a non-floating-point constant; if a is anything else, or if there are any keyword arguments in the call, then the original member* call is left intact. (The actual compiler macro for member* optimizes a number of other cases, including common :test predicates.)

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.

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.

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.)

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 progns” throughout Lisp syntax, such as function bodies, let bodies, etc. Currently the only declaration understood by declare is special.

In this package, locally is no different from progn.

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, mapcar can map over both lists and arrays. It is hard for the compiler to expand mapcar into an in-line loop unless it knows whether the sequence will be a list or an array ahead of time. With (mapcar 'car (the vector foo)), a future compiler would have enough information to expand the loop in-line. For now, Emacs Lisp will treat the above code as exactly equivalent to (mapcar 'car foo).

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 get* function is setf-able; when used in this fashion, the default argument is allowed but ignored.

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.)

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 valid to use getf as a setf place, in which case its place argument must itself be a valid setf place. The default argument, if any, is ignored in this context. The effect is to change (via setcar) the value cell in the list that corresponds to property, or to cons a new property-value pair onto the list if the property is not yet present.

          (put sym prop val)  ==  (setf (getf (symbol-plist sym) prop) val)
     

The get and get* functions are also setf-able. The fact that default is ignored can sometimes be useful:

          (incf (get* 'foo 'usage-count 0))
     

Here, symbol foo's usage-count property is incremented if it exists, or set to 1 (an incremented 0) otherwise.

When not used as a setf form, getf is just a regular function and its place argument can actually be any Lisp expression.

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.

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.

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.)

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.

This predicate tests whether number is positive. It is an error if the argument is not a number.

This predicate tests whether number is negative. It is an error if the argument is not a number.

This predicate tests whether integer is odd. It is an error if the argument is not an integer.

This predicate tests whether integer is even. It is an error if the argument is not an integer.

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.

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.

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.

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.

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.

With one argument, floor* returns a list of two numbers: The argument rounded down (toward minus infinity) to an integer, and the “remainder” which would have to be added back to the first return value to yield the argument again. If the argument is an integer x, the result is always the list (x 0). If the argument is a floating-point number, the first result is a Lisp integer and the second is a Lisp float between 0 (inclusive) and 1 (exclusive).

With two arguments, floor* divides number by divisor, and returns the floor of the quotient and the corresponding remainder as a list of two numbers. If (floor* x y) returns (q r), then q*y + r = x, with r between 0 (inclusive) and r (exclusive). Also, note that (floor* x) is exactly equivalent to (floor* x 1).

This function is entirely compatible with Common Lisp's floor function, except that it returns the two results in a list since Emacs Lisp does not support multiple-valued functions.

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.

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.

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.

This function returns the same value as the second return value of floor.

This function returns the same value as the second return value of truncate.

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.

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.

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 random-state object, this function returns a copy of that object. If state is t, this function returns a new random-state object seeded from the date and time. As an extension to Common Lisp, state may also be an integer in which case the new object is seeded from that integer; each different integer seed will result in a completely different sequence of random numbers.

It is valid to print a random-state object to a buffer or file and later read it back with read. If a program wishes to use a sequence of pseudo-random numbers which can be reproduced later for debugging, it can call (make-random-state t) to get a new sequence, then print this sequence to a file. When the program is later rerun, it can read the original run's random-state from the file.

This predicate returns t if object is a random-state object, or nil otherwise.

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, 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.

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.

This constant equals the most-negative value a Lisp float can hold. (It is assumed to be equal to (- most-positive-float).)

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.

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.

This constant is the negative counterpart of least-positive-float.

This constant is the negative counterpart of least-positive-normalized-float.

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.

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.

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 mapcar accepts multiple arguments but works only on lists; Emacs Lisp's mapcar accepts a single sequence argument. This package's mapcar* works as a compatible superset of both.

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).

This function calls function on each of its argument lists, then on the cdrs 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 cars of the advancing pointers.

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. This function is more general than the Emacs primitive mapc.

This function is like maplist, except that it throws away the values returned by 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.

This function is like maplist, except that it concatenates the return values using nconc.

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.

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.

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.

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.

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 :from-end is true, the reduction is right-associative instead of left-associative:

          (reduce '- '(1 2 3 4))
               == (- (- (- 1 2) 3) 4) => -8
          (reduce '- '(1 2 3 4) :from-end t)
               == (- 1 (- 2 (- 3 4))) => -2
     

If :key is specified, it is a function of one argument which is called on each of the sequence elements in turn.

If :initial-value is specified, it is effectively added to the front (or rear in the case of :from-end) of the sequence. The :key function is not applied to the initial value.

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.

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' substring function. Note that subseq is the only sequence function that allows negative start and end.

You can use setf on a subseq form to replace a specified range of elements with elements from another sequence. The replacement is done as if by replace, described below.

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.

This function fills the elements of the sequence (or the specified part of the sequence) with the value item.

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 eq, then the replacement will work correctly even if the regions indicated by the start and end arguments overlap. However, if seq1 and seq2 are lists which share storage but are not eq, and the start and end arguments specify overlapping regions, the effect is undefined.

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).

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.

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.

This function deletes duplicate elements from seq. It is a destructive version of remove-duplicates.

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.

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.

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.

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.

This function returns the number of elements of seq which match item. The result is always a nonnegative integer.

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 :from-end is true, then the elements are compared from right to left starting at (1- end1) and (1- end2). If the sequences differ, then one plus the index of the rightmost difference (relative to seq1) is returned.

An interesting example is (mismatch str1 str2 :key 'upcase), which compares two strings case-insensitively.

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.

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 sort in that it can operate on any type of sequence, not just lists. Also, it accepts a :key argument which is used to preprocess data fed to the predicate function. For example,

          (setq data (sort* data 'string-lessp :key 'downcase))
     

sorts data, a sequence of strings, into increasing alphabetical order without regard to case. A :key function of car would be useful for sorting association lists. It should only be a simple accessor though, it's used heavily in the current implementation.

The sort* function is destructive; it sorts lists by actually rearranging the cdr pointers in suitable fashion.

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, sort* and stable-sort are equivalent in Emacs Lisp because the underlying sort function is stable by default. However, this package reserves the right to use non-stable methods for sort* in the future.

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.

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.

This function is a synonym for (car x). Likewise, the functions second, third, ..., through tenth return the given element of the list x.

This function is a synonym for (cdr x).

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.

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.)

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 list* in Common Lisp; it is not a name invented for this package like member* or defun*.)

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.

This function returns a copy of the list list. It copies dotted lists like (1 2 . 3) correctly.

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.

This function compares two trees of cons cells. If x and y are both cons cells, their cars and cdrs 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.

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 cars and cdrs 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.

This function is like subst, except that it works by destructive modification (by setcar or setcdr) rather than copying.

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 cars of alist; if it matches, it is replaced by the corresponding cdr.

This is a destructive version of sublis.

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 `*' to avoid the incompatible member function defined in Emacs. (That function uses equal for comparisons; it is equivalent to (member* item list :test 'equal).)

This function returns t if sublist is a sublist of list, i.e., if sublist is eql to list or to any of its cdrs.

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.

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.

This is a destructive version of union; rather than copying, it tries to reuse the storage of the argument lists if possible.

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.

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.

This function computes the “set difference” of list1 and list2, i.e., the set of elements that appear in list1 but not in list2.

This is a destructive set-difference, which will try to reuse list1 if possible.

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.

This is a destructive set-exclusive-or, which will try to reuse list1 and list2 if possible.

This function checks whether list1 represents a subset of list2, i.e., whether every element of list1 also appears in list2.

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 nils but considers any other non-cons elements of a-list to be an error.)

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.

This is equivalent to (cons (cons key value) alist).

This is equivalent to (nconc (mapcar* 'cons keys values) alist).

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 person which contains three slots. Given a person object p, you can access those slots by calling (person-name p), (person-age p), and (person-sex p). You can also change these slots by using setf on any of these place forms:

          (incf (person-age birthday-boy))
     

You can create a new person by calling make-person, which takes keyword arguments :name, :age, and :sex to specify the initial values of these slots in the new object. (Omitting any of these arguments leaves the corresponding slot “undefined,” according to the Common Lisp standard; in Emacs Lisp, such uninitialized slots are filled with nil.)

Given a person, (copy-person p) makes a new object of the same type whose slots are eq to those of p.

Given any Lisp object x, (person-p x) returns true if x looks like a person, false otherwise. (Again, in Common Lisp this predicate would be exact; in Emacs Lisp the best it can do is verify that x is a vector of the correct length which starts with the correct tag symbol.)

Accessors like person-name normally check their arguments (effectively using person-p) and signal an error if the argument is the wrong type. This check is affected by (optimize (safety ...)) declarations. Safety level 1, the default, uses a somewhat optimized check that will detect all incorrect arguments, but may use an uninformative error message (e.g., “expected a vector” instead of “expected a person”). Safety level 0 omits all checks except as provided by the underlying aref call; safety levels 2 and 3 do rigorous checking that will always print a descriptive error message for incorrect inputs. See Declarations.

          (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 `(slot-name default-value slot-options...)'. The default-value is a Lisp form which is evaluated any time an instance of the structure type is created without specifying that slot's value.

Common Lisp defines several slot options, but the only one implemented in this package is :read-only. A non-nil value for this option means the slot should not be setf-able; the slot's value is determined when the object is created and does not change afterward.

          (defstruct person
            (name nil :read-only t)
            age
            (sex 'unknown))
     

Any slot options other than :read-only are ignored.

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.

:conc-name

The argument is a symbol whose print name is used as the prefix for the names of slot accessor functions. The default is the name of the struct type followed by a hyphen. The option (:conc-name p-) would change this prefix to p-. Specifying nil as an argument means no prefix, so that the slot names themselves are used to name the accessor functions.

:constructor

In the simple case, this option takes one argument which is an alternate name to use for the constructor function. The default is make-name, e.g., make-person. The above example changes this to create-person. Specifying nil as an argument means that no standard constructor should be generated at all.

In the full form of this option, the constructor name is followed by an arbitrary argument list. See Program Structure, for a description of the format of Common Lisp argument lists. All options, such as &rest and &key, are supported. The argument names should match the slot names; each slot is initialized from the corresponding argument. Slots whose names do not appear in the argument list are initialized based on the default-value in their slot descriptor. Also, &optional and &key arguments which don't specify defaults take their defaults from the slot descriptor. It is valid to include arguments which don't correspond to slot names; these are useful if they are referred to in the defaults for optional, keyword, or &aux arguments which do correspond to slots.

You can specify any number of full-format :constructor options on a structure. The default constructor is still generated as well unless you disable it with a simple-format :constructor option.

               (defstruct
                (person
                 (:constructor nil)   ; no default constructor
                 (:constructor new-person (name sex &optional (age 0)))
                 (:constructor new-hound (&key (name "Rover")
                                               (dog-years 0)
                                          &aux (age (* 7 dog-years))
                                               (sex 'canine))))
                name age sex)
          

The first constructor here takes its arguments positionally rather than by keyword. (In official Common Lisp terminology, constructors that work By Order of Arguments instead of by keyword are called “BOA constructors.” No, I'm not making this up.) For example, (new-person "Jane" 'female) generates a person whose slots are "Jane", 0, and female, respectively.

The second constructor takes two keyword arguments, :name, which initializes the name slot and defaults to "Rover", and :dog-years, which does not itself correspond to a slot but which is used to initialize the age slot. The sex slot is forced to the symbol canine with no syntax for overriding it.

:copier

The argument is an alternate name for the copier function for this type. The default is copy-name. nil means not to generate a copier function. (In this implementation, all copier functions are simply synonyms for copy-sequence.)

:predicate

The argument is an alternate name for the predicate which recognizes objects of this type. The default is name-p. nil means not to generate a predicate function. (If the :type option is used without the :named option, no predicate is ever generated.)

In true Common Lisp, typep is always able to recognize a structure object even if :predicate was used. In this package, typep simply looks for a function called typename-p, so it will work for structure types only if they used the default predicate name.

:include

This option implements a very limited form of C++-style inheritance. The argument is the name of another structure type previously created with defstruct. The effect is to cause the new structure type to inherit all of the included structure's slots (plus, of course, any new slots described by this struct's slot descriptors). The new structure is considered a “specialization” of the included one. In fact, the predicate and slot accessors for the included type will also accept objects of the new type.

If there are extra arguments to the :include option after the included-structure name, these options are treated as replacement slot descriptors for slots in the included structure, possibly with modified default values. Borrowing an example from Steele:

               (defstruct person name (age 0) sex)
                    => person
               (defstruct (astronaut (:include person (age 45)))
                 helmet-size
                 (favorite-beverage 'tang))
                    => astronaut
               
               (setq joe (make-person :name "Joe"))
                    => [cl-struct-person "Joe" 0 nil]
               (setq buzz (make-astronaut :name "Buzz"))
                    => [cl-struct-astronaut "Buzz" 45 nil nil tang]
               
               (list (person-p joe) (person-p buzz))
                    => (t t)
               (list (astronaut-p joe) (astronaut-p buzz))
                    => (nil t)
               
               (person-name buzz)
                    => "Buzz"
               (astronaut-name joe)
                    => error: "astronaut-name accessing a non-astronaut"
          

Thus, if astronaut is a specialization of person, then every astronaut is also a person (but not the other way around). Every astronaut includes all the slots of a person, plus extra slots that are specific to astronauts. Operations that work on people (like person-name) work on astronauts just like other people.

:print-function

In full Common Lisp, this option allows you to specify a function which is called to print an instance of the structure type. The Emacs Lisp system offers no hooks into the Lisp printer which would allow for such a feature, so this package simply ignores :print-function.

:type

The argument should be one of the symbols vector or list. This tells which underlying Lisp data type should be used to implement the new structure type. Vectors are used by default, but (:type list) will cause structure objects to be stored as lists instead.

The vector representation for structure objects has the advantage that all structure slots can be accessed quickly, although creating vectors is a bit slower in Emacs Lisp. Lists are easier to create, but take a relatively long time accessing the later slots.

:named

This option, which takes no arguments, causes a characteristic “tag” symbol to be stored at the front of the structure object. Using :type without also using :named will result in a structure type stored as plain vectors or lists with no identifying features.

The default, if you don't specify :type explicitly, is to use named vectors. Therefore, :named is only useful in conjunction with :type.

               (defstruct (person1) name age sex)
               (defstruct (person2 (:type list) :named) name age sex)
               (defstruct (person3 (:type list)) name age sex)
               
               (setq p1 (make-person1))
                    => [cl-struct-person1 nil nil nil]
               (setq p2 (make-person2))
                    => (person2 nil nil nil)
               (setq p3 (make-person3))
                    => (nil nil nil)
               
               (person1-p p1)
                    => t
               (person2-p p2)
                    => t
               (person3-p p3)
                    => error: function person3-p undefined
          

Since unnamed structures don't have tags, defstruct is not able to make a useful predicate for recognizing them. Also, accessors like person3-name will be generated but they will not be able to do any type checking. The person3-name function, for example, will simply be a synonym for car in this case. By contrast, person2-name is able to verify that its argument is indeed a person2 object before proceeding.

:initial-offset

The argument must be a nonnegative integer. It specifies a number of slots to be left “empty” at the front of the structure. If the structure is named, the tag appears at the specified position in the list or vector; otherwise, the first slot appears at that position. Earlier positions are filled with nil by the constructors and ignored otherwise. If the type :includes another type, then :initial-offset specifies a number of slots to be skipped between the last slot of the included type and the first new slot.

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 error to signal the error.

If the optional second argument show-args is t instead of nil, then the error message (with or without string) will also include all non-constant arguments of the top-level form. For example:

          (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 setf'd by the user before continuing from the error. Since Emacs Lisp does not support continuable errors, it makes no sense to specify places.

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 check-type must be a place suitable for use by setf, because check-type signals a continuable error that allows the user to modify place.

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.

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 block macro is expanded differently in the interpreter and compiler, so cl-prettyexpand just leaves it alone. The temporary variable G1004 was created by gensym.)

If the optional argument full is true, then all macros are expanded, including block, eval-when, and compiler macros. Expansion is done as if form were a top-level form in a file being compiled. For example,

          (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 adjoin, caddr, and member* all have built-in compiler macros to optimize them in common cases.