aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorStefan Monnier2012-06-04 10:00:32 -0400
committerStefan Monnier2012-06-04 10:00:32 -0400
commit093c025774f7bfecdfef9390face7093a2679746 (patch)
treec13e6dcd27cd93726a4e60c06366dd0926c5d12e
parent47b36b94ca954c6c0f5f6196c513916ddd46253f (diff)
downloademacs-093c025774f7bfecdfef9390face7093a2679746.tar.gz
emacs-093c025774f7bfecdfef9390face7093a2679746.zip
Update autogenerated bootstrap file.
Diffstat
-rw-r--r--lisp/emacs-lisp/cl-loaddefs.el533
1 files changed, 269 insertions, 264 deletions
diff --git a/lisp/emacs-lisp/cl-loaddefs.el b/lisp/emacs-lisp/cl-loaddefs.el
index ab5258b23b0..6d4f60b1029 100644
--- a/lisp/emacs-lisp/cl-loaddefs.el
+++ b/lisp/emacs-lisp/cl-loaddefs.el
@@ -4,22 +4,24 @@
4 4
5 5
6;;;### (autoloads (cl-prettyexpand cl-macroexpand-all cl-remprop 6;;;### (autoloads (cl-prettyexpand cl-macroexpand-all cl-remprop
7;;;;;; cl-do-remf cl-set-getf getf get* tailp list-length nreconc 7;;;;;; cl-do-remf cl-set-getf cl-getf cl-get cl-tailp cl-list-length
8;;;;;; revappend concatenate subseq cl-float-limits random-state-p 8;;;;;; cl-nreconc cl-revappend cl-concatenate cl-subseq cl-float-limits
9;;;;;; make-random-state random* signum rem* mod* round* truncate* 9;;;;;; cl-random-state-p cl-make-random-state cl-random cl-signum
10;;;;;; ceiling* floor* isqrt lcm gcd cl-progv-before cl-set-frame-visible-p 10;;;;;; cl-rem cl-mod cl-round cl-truncate cl-ceiling cl-floor cl-isqrt
11;;;;;; cl-map-overlays cl-map-intervals cl-map-keymap-recursively 11;;;;;; cl-lcm cl-gcd cl-progv-before cl-set-frame-visible-p cl-map-overlays
12;;;;;; notevery notany every some mapcon mapcan mapl maplist map 12;;;;;; cl-map-intervals cl-map-keymap-recursively cl-notevery cl-notany
13;;;;;; cl-mapcar-many equalp coerce) "cl-extra" "cl-extra.el" "1a3a04c6a0286373093bea4b9bcf2e91") 13;;;;;; cl-every cl-some cl-mapcon cl-mapcan cl-mapl cl-maplist cl-map
14;;;;;; cl-mapcar-many cl-equalp cl-coerce) "cl-extra" "cl-extra.el"
15;;;;;; "acc0000b09b27fb51f5ba23a4b9254e2")
14;;; Generated autoloads from cl-extra.el 16;;; Generated autoloads from cl-extra.el
15 17
16(autoload 'coerce "cl-extra" "\ 18(autoload 'cl-coerce "cl-extra" "\
17Coerce OBJECT to type TYPE. 19Coerce OBJECT to type TYPE.
18TYPE is a Common Lisp type specifier. 20TYPE is a Common Lisp type specifier.
19 21
20\(fn OBJECT TYPE)" nil nil) 22\(fn OBJECT TYPE)" nil nil)
21 23
22(autoload 'equalp "cl-extra" "\ 24(autoload 'cl-equalp "cl-extra" "\
23Return t if two Lisp objects have similar structures and contents. 25Return t if two Lisp objects have similar structures and contents.
24This is like `equal', except that it accepts numerically equal 26This is like `equal', except that it accepts numerically equal
25numbers of different types (float vs. integer), and also compares 27numbers of different types (float vs. integer), and also compares
@@ -32,51 +34,51 @@ strings case-insensitively.
32 34
33\(fn CL-FUNC CL-SEQS)" nil nil) 35\(fn CL-FUNC CL-SEQS)" nil nil)
34 36
35(autoload 'map "cl-extra" "\ 37(autoload 'cl-map "cl-extra" "\
36Map a FUNCTION across one or more SEQUENCEs, returning a sequence. 38Map a FUNCTION across one or more SEQUENCEs, returning a sequence.
37TYPE is the sequence type to return. 39TYPE is the sequence type to return.
38 40
39\(fn TYPE FUNCTION SEQUENCE...)" nil nil) 41\(fn TYPE FUNCTION SEQUENCE...)" nil nil)
40 42
41(autoload 'maplist "cl-extra" "\ 43(autoload 'cl-maplist "cl-extra" "\
42Map FUNCTION to each sublist of LIST or LISTs. 44Map FUNCTION to each sublist of LIST or LISTs.
43Like `mapcar', except applies to lists and their cdr's rather than to 45Like `mapcar', except applies to lists and their cdr's rather than to
44the elements themselves. 46the elements themselves.
45 47
46\(fn FUNCTION LIST...)" nil nil) 48\(fn FUNCTION LIST...)" nil nil)
47 49
48(autoload 'mapl "cl-extra" "\ 50(autoload 'cl-mapl "cl-extra" "\
49Like `maplist', but does not accumulate values returned by the function. 51Like `cl-maplist', but does not accumulate values returned by the function.
50 52
51\(fn FUNCTION LIST...)" nil nil) 53\(fn FUNCTION LIST...)" nil nil)
52 54
53(autoload 'mapcan "cl-extra" "\ 55(autoload 'cl-mapcan "cl-extra" "\
54Like `mapcar', but nconc's together the values returned by the function. 56Like `mapcar', but nconc's together the values returned by the function.
55 57
56\(fn FUNCTION SEQUENCE...)" nil nil) 58\(fn FUNCTION SEQUENCE...)" nil nil)
57 59
58(autoload 'mapcon "cl-extra" "\ 60(autoload 'cl-mapcon "cl-extra" "\
59Like `maplist', but nconc's together the values returned by the function. 61Like `cl-maplist', but nconc's together the values returned by the function.
60 62
61\(fn FUNCTION LIST...)" nil nil) 63\(fn FUNCTION LIST...)" nil nil)
62 64
63(autoload 'some "cl-extra" "\ 65(autoload 'cl-some "cl-extra" "\
64Return true if PREDICATE is true of any element of SEQ or SEQs. 66Return true if PREDICATE is true of any element of SEQ or SEQs.
65If so, return the true (non-nil) value returned by PREDICATE. 67If so, return the true (non-nil) value returned by PREDICATE.
66 68
67\(fn PREDICATE SEQ...)" nil nil) 69\(fn PREDICATE SEQ...)" nil nil)
68 70
69(autoload 'every "cl-extra" "\ 71(autoload 'cl-every "cl-extra" "\
70Return true if PREDICATE is true of every element of SEQ or SEQs. 72Return true if PREDICATE is true of every element of SEQ or SEQs.
71 73
72\(fn PREDICATE SEQ...)" nil nil) 74\(fn PREDICATE SEQ...)" nil nil)
73 75
74(autoload 'notany "cl-extra" "\ 76(autoload 'cl-notany "cl-extra" "\
75Return true if PREDICATE is false of every element of SEQ or SEQs. 77Return true if PREDICATE is false of every element of SEQ or SEQs.
76 78
77\(fn PREDICATE SEQ...)" nil nil) 79\(fn PREDICATE SEQ...)" nil nil)
78 80
79(autoload 'notevery "cl-extra" "\ 81(autoload 'cl-notevery "cl-extra" "\
80Return true if PREDICATE is false of some element of SEQ or SEQs. 82Return true if PREDICATE is false of some element of SEQ or SEQs.
81 83
82\(fn PREDICATE SEQ...)" nil nil) 84\(fn PREDICATE SEQ...)" nil nil)
@@ -108,124 +110,124 @@ Return true if PREDICATE is false of some element of SEQ or SEQs.
108 110
109\(fn SYMS VALUES)" nil nil) 111\(fn SYMS VALUES)" nil nil)
110 112
111(autoload 'gcd "cl-extra" "\ 113(autoload 'cl-gcd "cl-extra" "\
112Return the greatest common divisor of the arguments. 114Return the greatest common divisor of the arguments.
113 115
114\(fn &rest ARGS)" nil nil) 116\(fn &rest ARGS)" nil nil)
115 117
116(autoload 'lcm "cl-extra" "\ 118(autoload 'cl-lcm "cl-extra" "\
117Return the least common multiple of the arguments. 119Return the least common multiple of the arguments.
118 120
119\(fn &rest ARGS)" nil nil) 121\(fn &rest ARGS)" nil nil)
120 122
121(autoload 'isqrt "cl-extra" "\ 123(autoload 'cl-isqrt "cl-extra" "\
122Return the integer square root of the argument. 124Return the integer square root of the argument.
123 125
124\(fn X)" nil nil) 126\(fn X)" nil nil)
125 127
126(autoload 'floor* "cl-extra" "\ 128(autoload 'cl-floor "cl-extra" "\
127Return a list of the floor of X and the fractional part of X. 129Return a list of the floor of X and the fractional part of X.
128With two arguments, return floor and remainder of their quotient. 130With two arguments, return floor and remainder of their quotient.
129 131
130\(fn X &optional Y)" nil nil) 132\(fn X &optional Y)" nil nil)
131 133
132(autoload 'ceiling* "cl-extra" "\ 134(autoload 'cl-ceiling "cl-extra" "\
133Return a list of the ceiling of X and the fractional part of X. 135Return a list of the ceiling of X and the fractional part of X.
134With two arguments, return ceiling and remainder of their quotient. 136With two arguments, return ceiling and remainder of their quotient.
135 137
136\(fn X &optional Y)" nil nil) 138\(fn X &optional Y)" nil nil)
137 139
138(autoload 'truncate* "cl-extra" "\ 140(autoload 'cl-truncate "cl-extra" "\
139Return a list of the integer part of X and the fractional part of X. 141Return a list of the integer part of X and the fractional part of X.
140With two arguments, return truncation and remainder of their quotient. 142With two arguments, return truncation and remainder of their quotient.
141 143
142\(fn X &optional Y)" nil nil) 144\(fn X &optional Y)" nil nil)
143 145
144(autoload 'round* "cl-extra" "\ 146(autoload 'cl-round "cl-extra" "\
145Return a list of X rounded to the nearest integer and the remainder. 147Return a list of X rounded to the nearest integer and the remainder.
146With two arguments, return rounding and remainder of their quotient. 148With two arguments, return rounding and remainder of their quotient.
147 149
148\(fn X &optional Y)" nil nil) 150\(fn X &optional Y)" nil nil)
149 151
150(autoload 'mod* "cl-extra" "\ 152(autoload 'cl-mod "cl-extra" "\
151The remainder of X divided by Y, with the same sign as Y. 153The remainder of X divided by Y, with the same sign as Y.
152 154
153\(fn X Y)" nil nil) 155\(fn X Y)" nil nil)
154 156
155(autoload 'rem* "cl-extra" "\ 157(autoload 'cl-rem "cl-extra" "\
156The remainder of X divided by Y, with the same sign as X. 158The remainder of X divided by Y, with the same sign as X.
157 159
158\(fn X Y)" nil nil) 160\(fn X Y)" nil nil)
159 161
160(autoload 'signum "cl-extra" "\ 162(autoload 'cl-signum "cl-extra" "\
161Return 1 if X is positive, -1 if negative, 0 if zero. 163Return 1 if X is positive, -1 if negative, 0 if zero.
162 164
163\(fn X)" nil nil) 165\(fn X)" nil nil)
164 166
165(autoload 'random* "cl-extra" "\ 167(autoload 'cl-random "cl-extra" "\
166Return a random nonnegative number less than LIM, an integer or float. 168Return a random nonnegative number less than LIM, an integer or float.
167Optional second arg STATE is a random-state object. 169Optional second arg STATE is a random-state object.
168 170
169\(fn LIM &optional STATE)" nil nil) 171\(fn LIM &optional STATE)" nil nil)
170 172
171(autoload 'make-random-state "cl-extra" "\ 173(autoload 'cl-make-random-state "cl-extra" "\
172Return a copy of random-state STATE, or of the internal state if omitted. 174Return a copy of random-state STATE, or of the internal state if omitted.
173If STATE is t, return a new state object seeded from the time of day. 175If STATE is t, return a new state object seeded from the time of day.
174 176
175\(fn &optional STATE)" nil nil) 177\(fn &optional STATE)" nil nil)
176 178
177(autoload 'random-state-p "cl-extra" "\ 179(autoload 'cl-random-state-p "cl-extra" "\
178Return t if OBJECT is a random-state object. 180Return t if OBJECT is a random-state object.
179 181
180\(fn OBJECT)" nil nil) 182\(fn OBJECT)" nil nil)
181 183
182(autoload 'cl-float-limits "cl-extra" "\ 184(autoload 'cl-float-limits "cl-extra" "\
183Initialize the Common Lisp floating-point parameters. 185Initialize the Common Lisp floating-point parameters.
184This sets the values of: `most-positive-float', `most-negative-float', 186This sets the values of: `cl-most-positive-float', `cl-most-negative-float',
185`least-positive-float', `least-negative-float', `float-epsilon', 187`cl-least-positive-float', `cl-least-negative-float', `cl-float-epsilon',
186`float-negative-epsilon', `least-positive-normalized-float', and 188`cl-float-negative-epsilon', `cl-least-positive-normalized-float', and
187`least-negative-normalized-float'. 189`cl-least-negative-normalized-float'.
188 190
189\(fn)" nil nil) 191\(fn)" nil nil)
190 192
191(autoload 'subseq "cl-extra" "\ 193(autoload 'cl-subseq "cl-extra" "\
192Return the subsequence of SEQ from START to END. 194Return the subsequence of SEQ from START to END.
193If END is omitted, it defaults to the length of the sequence. 195If END is omitted, it defaults to the length of the sequence.
194If START or END is negative, it counts from the end. 196If START or END is negative, it counts from the end.
195 197
196\(fn SEQ START &optional END)" nil nil) 198\(fn SEQ START &optional END)" nil nil)
197 199
198(autoload 'concatenate "cl-extra" "\ 200(autoload 'cl-concatenate "cl-extra" "\
199Concatenate, into a sequence of type TYPE, the argument SEQUENCEs. 201Concatenate, into a sequence of type TYPE, the argument SEQUENCEs.
200 202
201\(fn TYPE SEQUENCE...)" nil nil) 203\(fn TYPE SEQUENCE...)" nil nil)
202 204
203(autoload 'revappend "cl-extra" "\ 205(autoload 'cl-revappend "cl-extra" "\
204Equivalent to (append (reverse X) Y). 206Equivalent to (append (reverse X) Y).
205 207
206\(fn X Y)" nil nil) 208\(fn X Y)" nil nil)
207 209
208(autoload 'nreconc "cl-extra" "\ 210(autoload 'cl-nreconc "cl-extra" "\
209Equivalent to (nconc (nreverse X) Y). 211Equivalent to (nconc (nreverse X) Y).
210 212
211\(fn X Y)" nil nil) 213\(fn X Y)" nil nil)
212 214
213(autoload 'list-length "cl-extra" "\ 215(autoload 'cl-list-length "cl-extra" "\
214Return the length of list X. Return nil if list is circular. 216Return the length of list X. Return nil if list is circular.
215 217
216\(fn X)" nil nil) 218\(fn X)" nil nil)
217 219
218(autoload 'tailp "cl-extra" "\ 220(autoload 'cl-tailp "cl-extra" "\
219Return true if SUBLIST is a tail of LIST. 221Return true if SUBLIST is a tail of LIST.
220 222
221\(fn SUBLIST LIST)" nil nil) 223\(fn SUBLIST LIST)" nil nil)
222 224
223(autoload 'get* "cl-extra" "\ 225(autoload 'cl-get "cl-extra" "\
224Return the value of SYMBOL's PROPNAME property, or DEFAULT if none. 226Return the value of SYMBOL's PROPNAME property, or DEFAULT if none.
225 227
226\(fn SYMBOL PROPNAME &optional DEFAULT)" nil nil) 228\(fn SYMBOL PROPNAME &optional DEFAULT)" nil nil)
227 229
228(autoload 'getf "cl-extra" "\ 230(autoload 'cl-getf "cl-extra" "\
229Search PROPLIST for property PROPNAME; return its value or DEFAULT. 231Search PROPLIST for property PROPNAME; return its value or DEFAULT.
230PROPLIST is a list of the sort returned by `symbol-plist'. 232PROPLIST is a list of the sort returned by `symbol-plist'.
231 233
@@ -246,8 +248,6 @@ Remove from SYMBOL's plist the property PROPNAME and its value.
246 248
247\(fn SYMBOL PROPNAME)" nil nil) 249\(fn SYMBOL PROPNAME)" nil nil)
248 250
249(defalias 'remprop 'cl-remprop)
250
251(defalias 'cl-gethash 'gethash) 251(defalias 'cl-gethash 'gethash)
252 252
253(defalias 'cl-puthash 'puthash) 253(defalias 'cl-puthash 'puthash)
@@ -277,67 +277,70 @@ This also does some trivial optimizations to make the form prettier.
277 277
278;;;*** 278;;;***
279 279
280;;;### (autoloads (defsubst* compiler-macroexpand define-compiler-macro 280;;;### (autoloads (cl-defsubst cl-compiler-macroexpand cl-define-compiler-macro
281;;;;;; assert check-type typep deftype cl-struct-setf-expander defstruct 281;;;;;; cl-assert cl-check-type cl-typep cl-deftype cl-struct-setf-expander
282;;;;;; define-modify-macro callf2 callf letf* letf rotatef shiftf 282;;;;;; cl-defstruct cl-define-modify-macro cl-callf2 cl-callf cl-letf*
283;;;;;; remf cl-do-pop psetf setf get-setf-method defsetf define-setf-method 283;;;;;; cl-letf cl-rotatef cl-shiftf cl-remf cl-do-pop cl-psetf cl-setf
284;;;;;; declare the locally multiple-value-setq multiple-value-bind 284;;;;;; cl-get-setf-method cl-defsetf cl-define-setf-method cl-declare
285;;;;;; lexical-let* lexical-let symbol-macrolet macrolet labels 285;;;;;; cl-the cl-locally cl-multiple-value-setq cl-multiple-value-bind
286;;;;;; flet progv psetq do-all-symbols do-symbols dotimes dolist 286;;;;;; cl-lexical-let* cl-lexical-let cl-symbol-macrolet cl-macrolet
287;;;;;; do* do loop return-from return block etypecase typecase ecase 287;;;;;; cl-labels cl-flet cl-progv cl-psetq cl-do-all-symbols cl-do-symbols
288;;;;;; case load-time-value eval-when destructuring-bind function* 288;;;;;; cl-dotimes cl-dolist cl-do* cl-do cl-loop cl-return-from
289;;;;;; defmacro* defun* gentemp gensym) "cl-macs" "cl-macs.el" "609f133b406e41ac5609fcd85e3f23de") 289;;;;;; cl-return cl-block cl-etypecase cl-typecase cl-ecase cl-case
290;;;;;; cl-load-time-value cl-eval-when cl-destructuring-bind cl-function
291;;;;;; cl-defmacro cl-defun cl-gentemp cl-gensym) "cl-macs" "cl-macs.el"
292;;;;;; "35e128b3ab7780c4f9c25da5a0adea7a")
290;;; Generated autoloads from cl-macs.el 293;;; Generated autoloads from cl-macs.el
291 294
292(autoload 'gensym "cl-macs" "\ 295(autoload 'cl-gensym "cl-macs" "\
293Generate a new uninterned symbol. 296Generate a new uninterned symbol.
294The name is made by appending a number to PREFIX, default \"G\". 297The name is made by appending a number to PREFIX, default \"G\".
295 298
296\(fn &optional PREFIX)" nil nil) 299\(fn &optional PREFIX)" nil nil)
297 300
298(autoload 'gentemp "cl-macs" "\ 301(autoload 'cl-gentemp "cl-macs" "\
299Generate a new interned symbol with a unique name. 302Generate a new interned symbol with a unique name.
300The name is made by appending a number to PREFIX, default \"G\". 303The name is made by appending a number to PREFIX, default \"G\".
301 304
302\(fn &optional PREFIX)" nil nil) 305\(fn &optional PREFIX)" nil nil)
303 306
304(autoload 'defun* "cl-macs" "\ 307(autoload 'cl-defun "cl-macs" "\
305Define NAME as a function. 308Define NAME as a function.
306Like normal `defun', except ARGLIST allows full Common Lisp conventions, 309Like normal `defun', except ARGLIST allows full Common Lisp conventions,
307and BODY is implicitly surrounded by (block NAME ...). 310and BODY is implicitly surrounded by (cl-block NAME ...).
308 311
309\(fn NAME ARGLIST [DOCSTRING] BODY...)" nil t) 312\(fn NAME ARGLIST [DOCSTRING] BODY...)" nil t)
310 313
311(put 'defun* 'doc-string-elt '3) 314(put 'cl-defun 'doc-string-elt '3)
312 315
313(put 'defun* 'lisp-indent-function '2) 316(put 'cl-defun 'lisp-indent-function '2)
314 317
315(autoload 'defmacro* "cl-macs" "\ 318(autoload 'cl-defmacro "cl-macs" "\
316Define NAME as a macro. 319Define NAME as a macro.
317Like normal `defmacro', except ARGLIST allows full Common Lisp conventions, 320Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
318and BODY is implicitly surrounded by (block NAME ...). 321and BODY is implicitly surrounded by (cl-block NAME ...).
319 322
320\(fn NAME ARGLIST [DOCSTRING] BODY...)" nil t) 323\(fn NAME ARGLIST [DOCSTRING] BODY...)" nil t)
321 324
322(put 'defmacro* 'doc-string-elt '3) 325(put 'cl-defmacro 'doc-string-elt '3)
323 326
324(put 'defmacro* 'lisp-indent-function '2) 327(put 'cl-defmacro 'lisp-indent-function '2)
325 328
326(autoload 'function* "cl-macs" "\ 329(autoload 'cl-function "cl-macs" "\
327Introduce a function. 330Introduce a function.
328Like normal `function', except that if argument is a lambda form, 331Like normal `function', except that if argument is a lambda form,
329its argument list allows full Common Lisp conventions. 332its argument list allows full Common Lisp conventions.
330 333
331\(fn FUNC)" nil t) 334\(fn FUNC)" nil t)
332 335
333(autoload 'destructuring-bind "cl-macs" "\ 336(autoload 'cl-destructuring-bind "cl-macs" "\
334 337
335 338
336\(fn ARGS EXPR &rest BODY)" nil t) 339\(fn ARGS EXPR &rest BODY)" nil t)
337 340
338(put 'destructuring-bind 'lisp-indent-function '2) 341(put 'cl-destructuring-bind 'lisp-indent-function '2)
339 342
340(autoload 'eval-when "cl-macs" "\ 343(autoload 'cl-eval-when "cl-macs" "\
341Control when BODY is evaluated. 344Control when BODY is evaluated.
342If `compile' is in WHEN, BODY is evaluated when compiled at top-level. 345If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
343If `load' is in WHEN, BODY is evaluated when loaded after top-level compile. 346If `load' is in WHEN, BODY is evaluated when loaded after top-level compile.
@@ -345,57 +348,57 @@ If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level.
345 348
346\(fn (WHEN...) BODY...)" nil t) 349\(fn (WHEN...) BODY...)" nil t)
347 350
348(put 'eval-when 'lisp-indent-function '1) 351(put 'cl-eval-when 'lisp-indent-function '1)
349 352
350(autoload 'load-time-value "cl-macs" "\ 353(autoload 'cl-load-time-value "cl-macs" "\
351Like `progn', but evaluates the body at load time. 354Like `progn', but evaluates the body at load time.
352The result of the body appears to the compiler as a quoted constant. 355The result of the body appears to the compiler as a quoted constant.
353 356
354\(fn FORM &optional READ-ONLY)" nil t) 357\(fn FORM &optional READ-ONLY)" nil t)
355 358
356(autoload 'case "cl-macs" "\ 359(autoload 'cl-case "cl-macs" "\
357Eval EXPR and choose among clauses on that value. 360Eval EXPR and choose among clauses on that value.
358Each clause looks like (KEYLIST BODY...). EXPR is evaluated and compared 361Each clause looks like (KEYLIST BODY...). EXPR is evaluated and compared
359against each key in each KEYLIST; the corresponding BODY is evaluated. 362against each key in each KEYLIST; the corresponding BODY is evaluated.
360If no clause succeeds, case returns nil. A single atom may be used in 363If no clause succeeds, cl-case returns nil. A single atom may be used in
361place of a KEYLIST of one atom. A KEYLIST of t or `otherwise' is 364place of a KEYLIST of one atom. A KEYLIST of t or `otherwise' is
362allowed only in the final clause, and matches if no other keys match. 365allowed only in the final clause, and matches if no other keys match.
363Key values are compared by `eql'. 366Key values are compared by `eql'.
364 367
365\(fn EXPR (KEYLIST BODY...)...)" nil t) 368\(fn EXPR (KEYLIST BODY...)...)" nil t)
366 369
367(put 'case 'lisp-indent-function '1) 370(put 'cl-case 'lisp-indent-function '1)
368 371
369(autoload 'ecase "cl-macs" "\ 372(autoload 'cl-ecase "cl-macs" "\
370Like `case', but error if no case fits. 373Like `cl-case', but error if no cl-case fits.
371`otherwise'-clauses are not allowed. 374`otherwise'-clauses are not allowed.
372 375
373\(fn EXPR (KEYLIST BODY...)...)" nil t) 376\(fn EXPR (KEYLIST BODY...)...)" nil t)
374 377
375(put 'ecase 'lisp-indent-function '1) 378(put 'cl-ecase 'lisp-indent-function '1)
376 379
377(autoload 'typecase "cl-macs" "\ 380(autoload 'cl-typecase "cl-macs" "\
378Evals EXPR, chooses among clauses on that value. 381Evals EXPR, chooses among clauses on that value.
379Each clause looks like (TYPE BODY...). EXPR is evaluated and, if it 382Each clause looks like (TYPE BODY...). EXPR is evaluated and, if it
380satisfies TYPE, the corresponding BODY is evaluated. If no clause succeeds, 383satisfies TYPE, the corresponding BODY is evaluated. If no clause succeeds,
381typecase returns nil. A TYPE of t or `otherwise' is allowed only in the 384cl-typecase returns nil. A TYPE of t or `otherwise' is allowed only in the
382final clause, and matches if no other keys match. 385final clause, and matches if no other keys match.
383 386
384\(fn EXPR (TYPE BODY...)...)" nil t) 387\(fn EXPR (TYPE BODY...)...)" nil t)
385 388
386(put 'typecase 'lisp-indent-function '1) 389(put 'cl-typecase 'lisp-indent-function '1)
387 390
388(autoload 'etypecase "cl-macs" "\ 391(autoload 'cl-etypecase "cl-macs" "\
389Like `typecase', but error if no case fits. 392Like `cl-typecase', but error if no case fits.
390`otherwise'-clauses are not allowed. 393`otherwise'-clauses are not allowed.
391 394
392\(fn EXPR (TYPE BODY...)...)" nil t) 395\(fn EXPR (TYPE BODY...)...)" nil t)
393 396
394(put 'etypecase 'lisp-indent-function '1) 397(put 'cl-etypecase 'lisp-indent-function '1)
395 398
396(autoload 'block "cl-macs" "\ 399(autoload 'cl-block "cl-macs" "\
397Define a lexically-scoped block named NAME. 400Define a lexically-scoped block named NAME.
398NAME may be any symbol. Code inside the BODY forms can call `return-from' 401NAME may be any symbol. Code inside the BODY forms can call `cl-return-from'
399to jump prematurely out of the block. This differs from `catch' and `throw' 402to jump prematurely out of the block. This differs from `catch' and `throw'
400in two respects: First, the NAME is an unevaluated symbol rather than a 403in two respects: First, the NAME is an unevaluated symbol rather than a
401quoted symbol or other form; and second, NAME is lexically rather than 404quoted symbol or other form; and second, NAME is lexically rather than
@@ -405,27 +408,27 @@ called from BODY.
405 408
406\(fn NAME &rest BODY)" nil t) 409\(fn NAME &rest BODY)" nil t)
407 410
408(put 'block 'lisp-indent-function '1) 411(put 'cl-block 'lisp-indent-function '1)
409 412
410(autoload 'return "cl-macs" "\ 413(autoload 'cl-return "cl-macs" "\
411Return from the block named nil. 414Return from the block named nil.
412This is equivalent to `(return-from nil RESULT)'. 415This is equivalent to `(cl-return-from nil RESULT)'.
413 416
414\(fn &optional RESULT)" nil t) 417\(fn &optional RESULT)" nil t)
415 418
416(autoload 'return-from "cl-macs" "\ 419(autoload 'cl-return-from "cl-macs" "\
417Return from the block named NAME. 420Return from the block named NAME.
418This jumps out to the innermost enclosing `(block NAME ...)' form, 421This jumps out to the innermost enclosing `(cl-block NAME ...)' form,
419returning RESULT from that form (or nil if RESULT is omitted). 422returning RESULT from that form (or nil if RESULT is omitted).
420This is compatible with Common Lisp, but note that `defun' and 423This is compatible with Common Lisp, but note that `defun' and
421`defmacro' do not create implicit blocks as they do in Common Lisp. 424`defmacro' do not create implicit blocks as they do in Common Lisp.
422 425
423\(fn NAME &optional RESULT)" nil t) 426\(fn NAME &optional RESULT)" nil t)
424 427
425(put 'return-from 'lisp-indent-function '1) 428(put 'cl-return-from 'lisp-indent-function '1)
426 429
427(autoload 'loop "cl-macs" "\ 430(autoload 'cl-loop "cl-macs" "\
428The Common Lisp `loop' macro. 431The Common Lisp `cl-loop' macro.
429Valid clauses are: 432Valid clauses are:
430 for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM, 433 for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM,
431 for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR, 434 for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR,
@@ -440,21 +443,21 @@ Valid clauses are:
440 443
441\(fn CLAUSE...)" nil t) 444\(fn CLAUSE...)" nil t)
442 445
443(autoload 'do "cl-macs" "\ 446(autoload 'cl-do "cl-macs" "\
444The Common Lisp `do' loop. 447The Common Lisp `cl-do' loop.
445 448
446\(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil t) 449\(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil t)
447 450
448(put 'do 'lisp-indent-function '2) 451(put 'cl-do 'lisp-indent-function '2)
449 452
450(autoload 'do* "cl-macs" "\ 453(autoload 'cl-do* "cl-macs" "\
451The Common Lisp `do*' loop. 454The Common Lisp `cl-do*' loop.
452 455
453\(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil t) 456\(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil t)
454 457
455(put 'do* 'lisp-indent-function '2) 458(put 'cl-do* 'lisp-indent-function '2)
456 459
457(autoload 'dolist "cl-macs" "\ 460(autoload 'cl-dolist "cl-macs" "\
458Loop over a list. 461Loop over a list.
459Evaluate BODY with VAR bound to each `car' from LIST, in turn. 462Evaluate BODY with VAR bound to each `car' from LIST, in turn.
460Then evaluate RESULT to get return value, default nil. 463Then evaluate RESULT to get return value, default nil.
@@ -462,7 +465,7 @@ An implicit nil block is established around the loop.
462 465
463\(fn (VAR LIST [RESULT]) BODY...)" nil t) 466\(fn (VAR LIST [RESULT]) BODY...)" nil t)
464 467
465(autoload 'dotimes "cl-macs" "\ 468(autoload 'cl-dotimes "cl-macs" "\
466Loop a certain number of times. 469Loop a certain number of times.
467Evaluate BODY with VAR bound to successive integers from 0, inclusive, 470Evaluate BODY with VAR bound to successive integers from 0, inclusive,
468to COUNT, exclusive. Then evaluate RESULT to get return value, default 471to COUNT, exclusive. Then evaluate RESULT to get return value, default
@@ -470,30 +473,30 @@ nil.
470 473
471\(fn (VAR COUNT [RESULT]) BODY...)" nil t) 474\(fn (VAR COUNT [RESULT]) BODY...)" nil t)
472 475
473(autoload 'do-symbols "cl-macs" "\ 476(autoload 'cl-do-symbols "cl-macs" "\
474Loop over all symbols. 477Loop over all symbols.
475Evaluate BODY with VAR bound to each interned symbol, or to each symbol 478Evaluate BODY with VAR bound to each interned symbol, or to each symbol
476from OBARRAY. 479from OBARRAY.
477 480
478\(fn (VAR [OBARRAY [RESULT]]) BODY...)" nil t) 481\(fn (VAR [OBARRAY [RESULT]]) BODY...)" nil t)
479 482
480(put 'do-symbols 'lisp-indent-function '1) 483(put 'cl-do-symbols 'lisp-indent-function '1)
481 484
482(autoload 'do-all-symbols "cl-macs" "\ 485(autoload 'cl-do-all-symbols "cl-macs" "\
483 486
484 487
485\(fn SPEC &rest BODY)" nil t) 488\(fn SPEC &rest BODY)" nil t)
486 489
487(put 'do-all-symbols 'lisp-indent-function '1) 490(put 'cl-do-all-symbols 'lisp-indent-function '1)
488 491
489(autoload 'psetq "cl-macs" "\ 492(autoload 'cl-psetq "cl-macs" "\
490Set SYMs to the values VALs in parallel. 493Set SYMs to the values VALs in parallel.
491This is like `setq', except that all VAL forms are evaluated (in order) 494This is like `setq', except that all VAL forms are evaluated (in order)
492before assigning any symbols SYM to the corresponding values. 495before assigning any symbols SYM to the corresponding values.
493 496
494\(fn SYM VAL SYM VAL ...)" nil t) 497\(fn SYM VAL SYM VAL ...)" nil t)
495 498
496(autoload 'progv "cl-macs" "\ 499(autoload 'cl-progv "cl-macs" "\
497Bind SYMBOLS to VALUES dynamically in BODY. 500Bind SYMBOLS to VALUES dynamically in BODY.
498The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists. 501The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
499Each symbol in the first list is bound to the corresponding value in the 502Each symbol in the first list is bound to the corresponding value in the
@@ -503,9 +506,9 @@ a `let' form, except that the list of symbols can be computed at run-time.
503 506
504\(fn SYMBOLS VALUES &rest BODY)" nil t) 507\(fn SYMBOLS VALUES &rest BODY)" nil t)
505 508
506(put 'progv 'lisp-indent-function '2) 509(put 'cl-progv 'lisp-indent-function '2)
507 510
508(autoload 'flet "cl-macs" "\ 511(autoload 'cl-flet "cl-macs" "\
509Make temporary function definitions. 512Make temporary function definitions.
510This is an analogue of `let' that operates on the function cell of FUNC 513This is an analogue of `let' that operates on the function cell of FUNC
511rather than its value cell. The FORMs are evaluated with the specified 514rather than its value cell. The FORMs are evaluated with the specified
@@ -514,44 +517,44 @@ go back to their previous definitions, or lack thereof).
514 517
515\(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil t) 518\(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil t)
516 519
517(put 'flet 'lisp-indent-function '1) 520(put 'cl-flet 'lisp-indent-function '1)
518 521
519(autoload 'labels "cl-macs" "\ 522(autoload 'cl-labels "cl-macs" "\
520Make temporary function bindings. 523Make temporary function bindings.
521This is like `flet', except the bindings are lexical instead of dynamic. 524This is like `cl-flet', except the bindings are lexical instead of dynamic.
522Unlike `flet', this macro is fully compliant with the Common Lisp standard. 525Unlike `cl-flet', this macro is fully compliant with the Common Lisp standard.
523 526
524\(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil t) 527\(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil t)
525 528
526(put 'labels 'lisp-indent-function '1) 529(put 'cl-labels 'lisp-indent-function '1)
527 530
528(autoload 'macrolet "cl-macs" "\ 531(autoload 'cl-macrolet "cl-macs" "\
529Make temporary macro definitions. 532Make temporary macro definitions.
530This is like `flet', but for macros instead of functions. 533This is like `cl-flet', but for macros instead of functions.
531 534
532\(fn ((NAME ARGLIST BODY...) ...) FORM...)" nil t) 535\(fn ((NAME ARGLIST BODY...) ...) FORM...)" nil t)
533 536
534(put 'macrolet 'lisp-indent-function '1) 537(put 'cl-macrolet 'lisp-indent-function '1)
535 538
536(autoload 'symbol-macrolet "cl-macs" "\ 539(autoload 'cl-symbol-macrolet "cl-macs" "\
537Make symbol macro definitions. 540Make symbol macro definitions.
538Within the body FORMs, references to the variable NAME will be replaced 541Within the body FORMs, references to the variable NAME will be replaced
539by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...). 542by EXPANSION, and (setq NAME ...) will act like (cl-setf EXPANSION ...).
540 543
541\(fn ((NAME EXPANSION) ...) FORM...)" nil t) 544\(fn ((NAME EXPANSION) ...) FORM...)" nil t)
542 545
543(put 'symbol-macrolet 'lisp-indent-function '1) 546(put 'cl-symbol-macrolet 'lisp-indent-function '1)
544 547
545(autoload 'lexical-let "cl-macs" "\ 548(autoload 'cl-lexical-let "cl-macs" "\
546Like `let', but lexically scoped. 549Like `let', but lexically scoped.
547The main visible difference is that lambdas inside BODY will create 550The main visible difference is that lambdas inside BODY will create
548lexical closures as in Common Lisp. 551lexical closures as in Common Lisp.
549 552
550\(fn BINDINGS BODY)" nil t) 553\(fn BINDINGS BODY)" nil t)
551 554
552(put 'lexical-let 'lisp-indent-function '1) 555(put 'cl-lexical-let 'lisp-indent-function '1)
553 556
554(autoload 'lexical-let* "cl-macs" "\ 557(autoload 'cl-lexical-let* "cl-macs" "\
555Like `let*', but lexically scoped. 558Like `let*', but lexically scoped.
556The main visible difference is that lambdas inside BODY, and in 559The main visible difference is that lambdas inside BODY, and in
557successive bindings within BINDINGS, will create lexical closures 560successive bindings within BINDINGS, will create lexical closures
@@ -560,105 +563,105 @@ Common Lisp.
560 563
561\(fn BINDINGS BODY)" nil t) 564\(fn BINDINGS BODY)" nil t)
562 565
563(put 'lexical-let* 'lisp-indent-function '1) 566(put 'cl-lexical-let* 'lisp-indent-function '1)
564 567
565(autoload 'multiple-value-bind "cl-macs" "\ 568(autoload 'cl-multiple-value-bind "cl-macs" "\
566Collect multiple return values. 569Collect multiple return values.
567FORM must return a list; the BODY is then executed with the first N elements 570FORM must return a list; the BODY is then executed with the first N elements
568of this list bound (`let'-style) to each of the symbols SYM in turn. This 571of this list bound (`let'-style) to each of the symbols SYM in turn. This
569is analogous to the Common Lisp `multiple-value-bind' macro, using lists to 572is analogous to the Common Lisp `cl-multiple-value-bind' macro, using lists to
570simulate true multiple return values. For compatibility, (values A B C) is 573simulate true multiple return values. For compatibility, (cl-values A B C) is
571a synonym for (list A B C). 574a synonym for (list A B C).
572 575
573\(fn (SYM...) FORM BODY)" nil t) 576\(fn (SYM...) FORM BODY)" nil t)
574 577
575(put 'multiple-value-bind 'lisp-indent-function '2) 578(put 'cl-multiple-value-bind 'lisp-indent-function '2)
576 579
577(autoload 'multiple-value-setq "cl-macs" "\ 580(autoload 'cl-multiple-value-setq "cl-macs" "\
578Collect multiple return values. 581Collect multiple return values.
579FORM must return a list; the first N elements of this list are stored in 582FORM must return a list; the first N elements of this list are stored in
580each of the symbols SYM in turn. This is analogous to the Common Lisp 583each of the symbols SYM in turn. This is analogous to the Common Lisp
581`multiple-value-setq' macro, using lists to simulate true multiple return 584`cl-multiple-value-setq' macro, using lists to simulate true multiple return
582values. For compatibility, (values A B C) is a synonym for (list A B C). 585values. For compatibility, (cl-values A B C) is a synonym for (list A B C).
583 586
584\(fn (SYM...) FORM)" nil t) 587\(fn (SYM...) FORM)" nil t)
585 588
586(put 'multiple-value-setq 'lisp-indent-function '1) 589(put 'cl-multiple-value-setq 'lisp-indent-function '1)
587 590
588(autoload 'locally "cl-macs" "\ 591(autoload 'cl-locally "cl-macs" "\
589 592
590 593
591\(fn &rest BODY)" nil t) 594\(fn &rest BODY)" nil t)
592 595
593(autoload 'the "cl-macs" "\ 596(autoload 'cl-the "cl-macs" "\
594 597
595 598
596\(fn TYPE FORM)" nil t) 599\(fn TYPE FORM)" nil t)
597 600
598(put 'the 'lisp-indent-function '1) 601(put 'cl-the 'lisp-indent-function '1)
599 602
600(autoload 'declare "cl-macs" "\ 603(autoload 'cl-declare "cl-macs" "\
601Declare SPECS about the current function while compiling. 604Declare SPECS about the current function while compiling.
602For instance 605For instance
603 606
604 (declare (warn 0)) 607 (cl-declare (warn 0))
605 608
606will turn off byte-compile warnings in the function. 609will turn off byte-compile warnings in the function.
607See Info node `(cl)Declarations' for details. 610See Info node `(cl)Declarations' for details.
608 611
609\(fn &rest SPECS)" nil t) 612\(fn &rest SPECS)" nil t)
610 613
611(autoload 'define-setf-method "cl-macs" "\ 614(autoload 'cl-define-setf-method "cl-macs" "\
612Define a `setf' method. 615Define a `cl-setf' method.
613This method shows how to handle `setf's to places of the form (NAME ARGS...). 616This method shows how to handle `cl-setf's to places of the form (NAME ARGS...).
614The argument forms ARGS are bound according to ARGLIST, as if NAME were 617The argument forms ARGS are bound according to ARGLIST, as if NAME were
615going to be expanded as a macro, then the BODY forms are executed and must 618going to be expanded as a macro, then the BODY forms are executed and must
616return a list of five elements: a temporary-variables list, a value-forms 619return a list of five elements: a temporary-variables list, a value-forms
617list, a store-variables list (of length one), a store-form, and an access- 620list, a store-variables list (of length one), a store-form, and an access-
618form. See `defsetf' for a simpler way to define most setf-methods. 621form. See `cl-defsetf' for a simpler way to define most setf-methods.
619 622
620\(fn NAME ARGLIST BODY...)" nil t) 623\(fn NAME ARGLIST BODY...)" nil t)
621 624
622(autoload 'defsetf "cl-macs" "\ 625(autoload 'cl-defsetf "cl-macs" "\
623Define a `setf' method. 626Define a `cl-setf' method.
624This macro is an easy-to-use substitute for `define-setf-method' that works 627This macro is an easy-to-use substitute for `cl-define-setf-method' that works
625well for simple place forms. In the simple `defsetf' form, `setf's of 628well for simple place forms. In the simple `cl-defsetf' form, `cl-setf's of
626the form (setf (NAME ARGS...) VAL) are transformed to function or macro 629the form (cl-setf (NAME ARGS...) VAL) are transformed to function or macro
627calls of the form (FUNC ARGS... VAL). Example: 630calls of the form (FUNC ARGS... VAL). Example:
628 631
629 (defsetf aref aset) 632 (cl-defsetf aref aset)
630 633
631Alternate form: (defsetf NAME ARGLIST (STORE) BODY...). 634Alternate form: (cl-defsetf NAME ARGLIST (STORE) BODY...).
632Here, the above `setf' call is expanded by binding the argument forms ARGS 635Here, the above `cl-setf' call is expanded by binding the argument forms ARGS
633according to ARGLIST, binding the value form VAL to STORE, then executing 636according to ARGLIST, binding the value form VAL to STORE, then executing
634BODY, which must return a Lisp form that does the necessary `setf' operation. 637BODY, which must return a Lisp form that does the necessary `cl-setf' operation.
635Actually, ARGLIST and STORE may be bound to temporary variables which are 638Actually, ARGLIST and STORE may be bound to temporary variables which are
636introduced automatically to preserve proper execution order of the arguments. 639introduced automatically to preserve proper execution order of the arguments.
637Example: 640Example:
638 641
639 (defsetf nth (n x) (v) `(setcar (nthcdr ,n ,x) ,v)) 642 (cl-defsetf nth (n x) (v) `(setcar (nthcdr ,n ,x) ,v))
640 643
641\(fn NAME [FUNC | ARGLIST (STORE) BODY...])" nil t) 644\(fn NAME [FUNC | ARGLIST (STORE) BODY...])" nil t)
642 645
643(autoload 'get-setf-method "cl-macs" "\ 646(autoload 'cl-get-setf-method "cl-macs" "\
644Return a list of five values describing the setf-method for PLACE. 647Return a list of five values describing the setf-method for PLACE.
645PLACE may be any Lisp form which can appear as the PLACE argument to 648PLACE may be any Lisp form which can appear as the PLACE argument to
646a macro like `setf' or `incf'. 649a macro like `cl-setf' or `cl-incf'.
647 650
648\(fn PLACE &optional ENV)" nil nil) 651\(fn PLACE &optional ENV)" nil nil)
649 652
650(autoload 'setf "cl-macs" "\ 653(autoload 'cl-setf "cl-macs" "\
651Set each PLACE to the value of its VAL. 654Set each PLACE to the value of its VAL.
652This is a generalized version of `setq'; the PLACEs may be symbolic 655This is a generalized version of `setq'; the PLACEs may be symbolic
653references such as (car x) or (aref x i), as well as plain symbols. 656references such as (car x) or (aref x i), as well as plain symbols.
654For example, (setf (cadar x) y) is equivalent to (setcar (cdar x) y). 657For example, (cl-setf (cl-cadar x) y) is equivalent to (setcar (cdar x) y).
655The return value is the last VAL in the list. 658The return value is the last VAL in the list.
656 659
657\(fn PLACE VAL PLACE VAL ...)" nil t) 660\(fn PLACE VAL PLACE VAL ...)" nil t)
658 661
659(autoload 'psetf "cl-macs" "\ 662(autoload 'cl-psetf "cl-macs" "\
660Set PLACEs to the values VALs in parallel. 663Set PLACEs to the values VALs in parallel.
661This is like `setf', except that all VAL forms are evaluated (in order) 664This is like `cl-setf', except that all VAL forms are evaluated (in order)
662before assigning any PLACEs to the corresponding values. 665before assigning any PLACEs to the corresponding values.
663 666
664\(fn PLACE VAL PLACE VAL ...)" nil t) 667\(fn PLACE VAL PLACE VAL ...)" nil t)
@@ -668,31 +671,31 @@ before assigning any PLACEs to the corresponding values.
668 671
669\(fn PLACE)" nil nil) 672\(fn PLACE)" nil nil)
670 673
671(autoload 'remf "cl-macs" "\ 674(autoload 'cl-remf "cl-macs" "\
672Remove TAG from property list PLACE. 675Remove TAG from property list PLACE.
673PLACE may be a symbol, or any generalized variable allowed by `setf'. 676PLACE may be a symbol, or any generalized variable allowed by `cl-setf'.
674The form returns true if TAG was found and removed, nil otherwise. 677The form returns true if TAG was found and removed, nil otherwise.
675 678
676\(fn PLACE TAG)" nil t) 679\(fn PLACE TAG)" nil t)
677 680
678(autoload 'shiftf "cl-macs" "\ 681(autoload 'cl-shiftf "cl-macs" "\
679Shift left among PLACEs. 682Shift left among PLACEs.
680Example: (shiftf A B C) sets A to B, B to C, and returns the old A. 683Example: (cl-shiftf A B C) sets A to B, B to C, and returns the old A.
681Each PLACE may be a symbol, or any generalized variable allowed by `setf'. 684Each PLACE may be a symbol, or any generalized variable allowed by `cl-setf'.
682 685
683\(fn PLACE... VAL)" nil t) 686\(fn PLACE... VAL)" nil t)
684 687
685(autoload 'rotatef "cl-macs" "\ 688(autoload 'cl-rotatef "cl-macs" "\
686Rotate left among PLACEs. 689Rotate left among PLACEs.
687Example: (rotatef A B C) sets A to B, B to C, and C to A. It returns nil. 690Example: (cl-rotatef A B C) sets A to B, B to C, and C to A. It returns nil.
688Each PLACE may be a symbol, or any generalized variable allowed by `setf'. 691Each PLACE may be a symbol, or any generalized variable allowed by `cl-setf'.
689 692
690\(fn PLACE...)" nil t) 693\(fn PLACE...)" nil t)
691 694
692(autoload 'letf "cl-macs" "\ 695(autoload 'cl-letf "cl-macs" "\
693Temporarily bind to PLACEs. 696Temporarily bind to PLACEs.
694This is the analogue of `let', but with generalized variables (in the 697This is the analogue of `let', but with generalized variables (in the
695sense of `setf') for the PLACEs. Each PLACE is set to the corresponding 698sense of `cl-setf') for the PLACEs. Each PLACE is set to the corresponding
696VALUE, then the BODY forms are executed. On exit, either normally or 699VALUE, then the BODY forms are executed. On exit, either normally or
697because of a `throw' or error, the PLACEs are set back to their original 700because of a `throw' or error, the PLACEs are set back to their original
698values. Note that this macro is *not* available in Common Lisp. 701values. Note that this macro is *not* available in Common Lisp.
@@ -701,12 +704,12 @@ the PLACE is not modified before executing BODY.
701 704
702\(fn ((PLACE VALUE) ...) BODY...)" nil t) 705\(fn ((PLACE VALUE) ...) BODY...)" nil t)
703 706
704(put 'letf 'lisp-indent-function '1) 707(put 'cl-letf 'lisp-indent-function '1)
705 708
706(autoload 'letf* "cl-macs" "\ 709(autoload 'cl-letf* "cl-macs" "\
707Temporarily bind to PLACEs. 710Temporarily bind to PLACEs.
708This is the analogue of `let*', but with generalized variables (in the 711This is the analogue of `let*', but with generalized variables (in the
709sense of `setf') for the PLACEs. Each PLACE is set to the corresponding 712sense of `cl-setf') for the PLACEs. Each PLACE is set to the corresponding
710VALUE, then the BODY forms are executed. On exit, either normally or 713VALUE, then the BODY forms are executed. On exit, either normally or
711because of a `throw' or error, the PLACEs are set back to their original 714because of a `throw' or error, the PLACEs are set back to their original
712values. Note that this macro is *not* available in Common Lisp. 715values. Note that this macro is *not* available in Common Lisp.
@@ -715,38 +718,38 @@ the PLACE is not modified before executing BODY.
715 718
716\(fn ((PLACE VALUE) ...) BODY...)" nil t) 719\(fn ((PLACE VALUE) ...) BODY...)" nil t)
717 720
718(put 'letf* 'lisp-indent-function '1) 721(put 'cl-letf* 'lisp-indent-function '1)
719 722
720(autoload 'callf "cl-macs" "\ 723(autoload 'cl-callf "cl-macs" "\
721Set PLACE to (FUNC PLACE ARGS...). 724Set PLACE to (FUNC PLACE ARGS...).
722FUNC should be an unquoted function name. PLACE may be a symbol, 725FUNC should be an unquoted function name. PLACE may be a symbol,
723or any generalized variable allowed by `setf'. 726or any generalized variable allowed by `cl-setf'.
724 727
725\(fn FUNC PLACE ARGS...)" nil t) 728\(fn FUNC PLACE ARGS...)" nil t)
726 729
727(put 'callf 'lisp-indent-function '2) 730(put 'cl-callf 'lisp-indent-function '2)
728 731
729(autoload 'callf2 "cl-macs" "\ 732(autoload 'cl-callf2 "cl-macs" "\
730Set PLACE to (FUNC ARG1 PLACE ARGS...). 733Set PLACE to (FUNC ARG1 PLACE ARGS...).
731Like `callf', but PLACE is the second argument of FUNC, not the first. 734Like `cl-callf', but PLACE is the second argument of FUNC, not the first.
732 735
733\(fn FUNC ARG1 PLACE ARGS...)" nil t) 736\(fn FUNC ARG1 PLACE ARGS...)" nil t)
734 737
735(put 'callf2 'lisp-indent-function '3) 738(put 'cl-callf2 'lisp-indent-function '3)
736 739
737(autoload 'define-modify-macro "cl-macs" "\ 740(autoload 'cl-define-modify-macro "cl-macs" "\
738Define a `setf'-like modify macro. 741Define a `cl-setf'-like modify macro.
739If NAME is called, it combines its PLACE argument with the other arguments 742If NAME is called, it combines its PLACE argument with the other arguments
740from ARGLIST using FUNC: (define-modify-macro incf (&optional (n 1)) +) 743from ARGLIST using FUNC: (cl-define-modify-macro cl-incf (&optional (n 1)) +)
741 744
742\(fn NAME ARGLIST FUNC &optional DOC)" nil t) 745\(fn NAME ARGLIST FUNC &optional DOC)" nil t)
743 746
744(autoload 'defstruct "cl-macs" "\ 747(autoload 'cl-defstruct "cl-macs" "\
745Define a struct type. 748Define a struct type.
746This macro defines a new data type called NAME that stores data 749This macro defines a new data type called NAME that stores data
747in SLOTs. It defines a `make-NAME' constructor, a `copy-NAME' 750in SLOTs. It defines a `make-NAME' constructor, a `copy-NAME'
748copier, a `NAME-p' predicate, and slot accessors named `NAME-SLOT'. 751copier, a `NAME-p' predicate, and slot accessors named `NAME-SLOT'.
749You can use the accessors to set the corresponding slots, via `setf'. 752You can use the accessors to set the corresponding slots, via `cl-setf'.
750 753
751NAME may instead take the form (NAME OPTIONS...), where each 754NAME may instead take the form (NAME OPTIONS...), where each
752OPTION is either a single keyword or (KEYWORD VALUE). 755OPTION is either a single keyword or (KEYWORD VALUE).
@@ -755,38 +758,38 @@ See Info node `(cl)Structures' for a list of valid keywords.
755Each SLOT may instead take the form (SLOT SLOT-OPTS...), where 758Each SLOT may instead take the form (SLOT SLOT-OPTS...), where
756SLOT-OPTS are keyword-value pairs for that slot. Currently, only 759SLOT-OPTS are keyword-value pairs for that slot. Currently, only
757one keyword is supported, `:read-only'. If this has a non-nil 760one keyword is supported, `:read-only'. If this has a non-nil
758value, that slot cannot be set via `setf'. 761value, that slot cannot be set via `cl-setf'.
759 762
760\(fn NAME SLOTS...)" nil t) 763\(fn NAME SLOTS...)" nil t)
761 764
762(put 'defstruct 'doc-string-elt '2) 765(put 'cl-defstruct 'doc-string-elt '2)
763 766
764(autoload 'cl-struct-setf-expander "cl-macs" "\ 767(autoload 'cl-struct-setf-expander "cl-macs" "\
765 768
766 769
767\(fn X NAME ACCESSOR PRED-FORM POS)" nil nil) 770\(fn X NAME ACCESSOR PRED-FORM POS)" nil nil)
768 771
769(autoload 'deftype "cl-macs" "\ 772(autoload 'cl-deftype "cl-macs" "\
770Define NAME as a new data type. 773Define NAME as a new data type.
771The type name can then be used in `typecase', `check-type', etc. 774The type name can then be used in `cl-typecase', `cl-check-type', etc.
772 775
773\(fn NAME ARGLIST &rest BODY)" nil t) 776\(fn NAME ARGLIST &rest BODY)" nil t)
774 777
775(put 'deftype 'doc-string-elt '3) 778(put 'cl-deftype 'doc-string-elt '3)
776 779
777(autoload 'typep "cl-macs" "\ 780(autoload 'cl-typep "cl-macs" "\
778Check that OBJECT is of type TYPE. 781Check that OBJECT is of type TYPE.
779TYPE is a Common Lisp-style type specifier. 782TYPE is a Common Lisp-style type specifier.
780 783
781\(fn OBJECT TYPE)" nil nil) 784\(fn OBJECT TYPE)" nil nil)
782 785
783(autoload 'check-type "cl-macs" "\ 786(autoload 'cl-check-type "cl-macs" "\
784Verify that FORM is of type TYPE; signal an error if not. 787Verify that FORM is of type TYPE; signal an error if not.
785STRING is an optional description of the desired type. 788STRING is an optional description of the desired type.
786 789
787\(fn FORM TYPE &optional STRING)" nil t) 790\(fn FORM TYPE &optional STRING)" nil t)
788 791
789(autoload 'assert "cl-macs" "\ 792(autoload 'cl-assert "cl-macs" "\
790Verify that FORM returns non-nil; signal an error if not. 793Verify that FORM returns non-nil; signal an error if not.
791Second arg SHOW-ARGS means to include arguments of FORM in message. 794Second arg SHOW-ARGS means to include arguments of FORM in message.
792Other args STRING and ARGS... are arguments to be passed to `error'. 795Other args STRING and ARGS... are arguments to be passed to `error'.
@@ -795,7 +798,7 @@ omitted, a default message listing FORM itself is used.
795 798
796\(fn FORM &optional SHOW-ARGS STRING &rest ARGS)" nil t) 799\(fn FORM &optional SHOW-ARGS STRING &rest ARGS)" nil t)
797 800
798(autoload 'define-compiler-macro "cl-macs" "\ 801(autoload 'cl-define-compiler-macro "cl-macs" "\
799Define a compiler-only macro. 802Define a compiler-only macro.
800This is like `defmacro', but macro expansion occurs only if the call to 803This is like `defmacro', but macro expansion occurs only if the call to
801FUNC is compiled (i.e., not interpreted). Compiler macros should be used 804FUNC is compiled (i.e., not interpreted). Compiler macros should be used
@@ -809,49 +812,51 @@ and then returning foo.
809 812
810\(fn FUNC ARGS &rest BODY)" nil t) 813\(fn FUNC ARGS &rest BODY)" nil t)
811 814
812(autoload 'compiler-macroexpand "cl-macs" "\ 815(autoload 'cl-compiler-macroexpand "cl-macs" "\
813 816
814 817
815\(fn FORM)" nil nil) 818\(fn FORM)" nil nil)
816 819
817(autoload 'defsubst* "cl-macs" "\ 820(autoload 'cl-defsubst "cl-macs" "\
818Define NAME as a function. 821Define NAME as a function.
819Like `defun', except the function is automatically declared `inline', 822Like `defun', except the function is automatically declared `inline',
820ARGLIST allows full Common Lisp conventions, and BODY is implicitly 823ARGLIST allows full Common Lisp conventions, and BODY is implicitly
821surrounded by (block NAME ...). 824surrounded by (cl-block NAME ...).
822 825
823\(fn NAME ARGLIST [DOCSTRING] BODY...)" nil t) 826\(fn NAME ARGLIST [DOCSTRING] BODY...)" nil t)
824 827
825;;;*** 828;;;***
826 829
827;;;### (autoloads (tree-equal nsublis sublis nsubst-if-not nsubst-if 830;;;### (autoloads (cl-tree-equal cl-nsublis cl-sublis cl-nsubst-if-not
828;;;;;; nsubst subst-if-not subst-if subsetp nset-exclusive-or set-exclusive-or 831;;;;;; cl-nsubst-if cl-nsubst cl-subst-if-not cl-subst-if cl-subsetp
829;;;;;; nset-difference set-difference nintersection intersection 832;;;;;; cl-nset-exclusive-or cl-set-exclusive-or cl-nset-difference
830;;;;;; nunion union rassoc-if-not rassoc-if rassoc* assoc-if-not 833;;;;;; cl-set-difference cl-nintersection cl-intersection cl-nunion
831;;;;;; assoc-if assoc* cl--adjoin member-if-not member-if member* 834;;;;;; cl-union cl-rassoc-if-not cl-rassoc-if cl-rassoc cl-assoc-if-not
832;;;;;; merge stable-sort sort* search mismatch count-if-not count-if 835;;;;;; cl-assoc-if cl-assoc cl--adjoin cl-member-if-not cl-member-if
833;;;;;; count position-if-not position-if position find-if-not find-if 836;;;;;; cl-member cl-merge cl-stable-sort cl-sort cl-search cl-mismatch
834;;;;;; find nsubstitute-if-not nsubstitute-if nsubstitute substitute-if-not 837;;;;;; cl-count-if-not cl-count-if cl-count cl-position-if-not cl-position-if
835;;;;;; substitute-if substitute delete-duplicates remove-duplicates 838;;;;;; cl-position cl-find-if-not cl-find-if cl-find cl-nsubstitute-if-not
836;;;;;; delete-if-not delete-if delete* remove-if-not remove-if remove* 839;;;;;; cl-nsubstitute-if cl-nsubstitute cl-substitute-if-not cl-substitute-if
837;;;;;; replace fill reduce) "cl-seq" "cl-seq.el" "2d8563fcbdf4bc77e569d0aeb0a35cfc") 840;;;;;; cl-substitute cl-delete-duplicates cl-remove-duplicates cl-delete-if-not
841;;;;;; cl-delete-if cl-delete cl-remove-if-not cl-remove-if cl-remove
842;;;;;; cl-replace cl-fill cl-reduce) "cl-seq" "cl-seq.el" "d3eaca7a24bdb10b381bb94729c5d7e9")
838;;; Generated autoloads from cl-seq.el 843;;; Generated autoloads from cl-seq.el
839 844
840(autoload 'reduce "cl-seq" "\ 845(autoload 'cl-reduce "cl-seq" "\
841Reduce two-argument FUNCTION across SEQ. 846Reduce two-argument FUNCTION across SEQ.
842 847
843Keywords supported: :start :end :from-end :initial-value :key 848Keywords supported: :start :end :from-end :initial-value :key
844 849
845\(fn FUNCTION SEQ [KEYWORD VALUE]...)" nil nil) 850\(fn FUNCTION SEQ [KEYWORD VALUE]...)" nil nil)
846 851
847(autoload 'fill "cl-seq" "\ 852(autoload 'cl-fill "cl-seq" "\
848Fill the elements of SEQ with ITEM. 853Fill the elements of SEQ with ITEM.
849 854
850Keywords supported: :start :end 855Keywords supported: :start :end
851 856
852\(fn SEQ ITEM [KEYWORD VALUE]...)" nil nil) 857\(fn SEQ ITEM [KEYWORD VALUE]...)" nil nil)
853 858
854(autoload 'replace "cl-seq" "\ 859(autoload 'cl-replace "cl-seq" "\
855Replace the elements of SEQ1 with the elements of SEQ2. 860Replace the elements of SEQ1 with the elements of SEQ2.
856SEQ1 is destructively modified, then returned. 861SEQ1 is destructively modified, then returned.
857 862
@@ -859,7 +864,7 @@ Keywords supported: :start1 :end1 :start2 :end2
859 864
860\(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil) 865\(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil)
861 866
862(autoload 'remove* "cl-seq" "\ 867(autoload 'cl-remove "cl-seq" "\
863Remove all occurrences of ITEM in SEQ. 868Remove all occurrences of ITEM in SEQ.
864This is a non-destructive function; it makes a copy of SEQ if necessary 869This is a non-destructive function; it makes a copy of SEQ if necessary
865to avoid corrupting the original SEQ. 870to avoid corrupting the original SEQ.
@@ -868,7 +873,7 @@ Keywords supported: :test :test-not :key :count :start :end :from-end
868 873
869\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil) 874\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
870 875
871(autoload 'remove-if "cl-seq" "\ 876(autoload 'cl-remove-if "cl-seq" "\
872Remove all items satisfying PREDICATE in SEQ. 877Remove all items satisfying PREDICATE in SEQ.
873This is a non-destructive function; it makes a copy of SEQ if necessary 878This is a non-destructive function; it makes a copy of SEQ if necessary
874to avoid corrupting the original SEQ. 879to avoid corrupting the original SEQ.
@@ -877,7 +882,7 @@ Keywords supported: :key :count :start :end :from-end
877 882
878\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) 883\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
879 884
880(autoload 'remove-if-not "cl-seq" "\ 885(autoload 'cl-remove-if-not "cl-seq" "\
881Remove all items not satisfying PREDICATE in SEQ. 886Remove all items not satisfying PREDICATE in SEQ.
882This is a non-destructive function; it makes a copy of SEQ if necessary 887This is a non-destructive function; it makes a copy of SEQ if necessary
883to avoid corrupting the original SEQ. 888to avoid corrupting the original SEQ.
@@ -886,7 +891,7 @@ Keywords supported: :key :count :start :end :from-end
886 891
887\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) 892\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
888 893
889(autoload 'delete* "cl-seq" "\ 894(autoload 'cl-delete "cl-seq" "\
890Remove all occurrences of ITEM in SEQ. 895Remove all occurrences of ITEM in SEQ.
891This is a destructive function; it reuses the storage of SEQ whenever possible. 896This is a destructive function; it reuses the storage of SEQ whenever possible.
892 897
@@ -894,7 +899,7 @@ Keywords supported: :test :test-not :key :count :start :end :from-end
894 899
895\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil) 900\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
896 901
897(autoload 'delete-if "cl-seq" "\ 902(autoload 'cl-delete-if "cl-seq" "\
898Remove all items satisfying PREDICATE in SEQ. 903Remove all items satisfying PREDICATE in SEQ.
899This is a destructive function; it reuses the storage of SEQ whenever possible. 904This is a destructive function; it reuses the storage of SEQ whenever possible.
900 905
@@ -902,7 +907,7 @@ Keywords supported: :key :count :start :end :from-end
902 907
903\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) 908\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
904 909
905(autoload 'delete-if-not "cl-seq" "\ 910(autoload 'cl-delete-if-not "cl-seq" "\
906Remove all items not satisfying PREDICATE in SEQ. 911Remove all items not satisfying PREDICATE in SEQ.
907This is a destructive function; it reuses the storage of SEQ whenever possible. 912This is a destructive function; it reuses the storage of SEQ whenever possible.
908 913
@@ -910,21 +915,21 @@ Keywords supported: :key :count :start :end :from-end
910 915
911\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) 916\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
912 917
913(autoload 'remove-duplicates "cl-seq" "\ 918(autoload 'cl-remove-duplicates "cl-seq" "\
914Return a copy of SEQ with all duplicate elements removed. 919Return a copy of SEQ with all duplicate elements removed.
915 920
916Keywords supported: :test :test-not :key :start :end :from-end 921Keywords supported: :test :test-not :key :start :end :from-end
917 922
918\(fn SEQ [KEYWORD VALUE]...)" nil nil) 923\(fn SEQ [KEYWORD VALUE]...)" nil nil)
919 924
920(autoload 'delete-duplicates "cl-seq" "\ 925(autoload 'cl-delete-duplicates "cl-seq" "\
921Remove all duplicate elements from SEQ (destructively). 926Remove all duplicate elements from SEQ (destructively).
922 927
923Keywords supported: :test :test-not :key :start :end :from-end 928Keywords supported: :test :test-not :key :start :end :from-end
924 929
925\(fn SEQ [KEYWORD VALUE]...)" nil nil) 930\(fn SEQ [KEYWORD VALUE]...)" nil nil)
926 931
927(autoload 'substitute "cl-seq" "\ 932(autoload 'cl-substitute "cl-seq" "\
928Substitute NEW for OLD in SEQ. 933Substitute NEW for OLD in SEQ.
929This is a non-destructive function; it makes a copy of SEQ if necessary 934This is a non-destructive function; it makes a copy of SEQ if necessary
930to avoid corrupting the original SEQ. 935to avoid corrupting the original SEQ.
@@ -933,7 +938,7 @@ Keywords supported: :test :test-not :key :count :start :end :from-end
933 938
934\(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil) 939\(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil)
935 940
936(autoload 'substitute-if "cl-seq" "\ 941(autoload 'cl-substitute-if "cl-seq" "\
937Substitute NEW for all items satisfying PREDICATE in SEQ. 942Substitute NEW for all items satisfying PREDICATE in SEQ.
938This is a non-destructive function; it makes a copy of SEQ if necessary 943This is a non-destructive function; it makes a copy of SEQ if necessary
939to avoid corrupting the original SEQ. 944to avoid corrupting the original SEQ.
@@ -942,7 +947,7 @@ Keywords supported: :key :count :start :end :from-end
942 947
943\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) 948\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
944 949
945(autoload 'substitute-if-not "cl-seq" "\ 950(autoload 'cl-substitute-if-not "cl-seq" "\
946Substitute NEW for all items not satisfying PREDICATE in SEQ. 951Substitute NEW for all items not satisfying PREDICATE in SEQ.
947This is a non-destructive function; it makes a copy of SEQ if necessary 952This is a non-destructive function; it makes a copy of SEQ if necessary
948to avoid corrupting the original SEQ. 953to avoid corrupting the original SEQ.
@@ -951,7 +956,7 @@ Keywords supported: :key :count :start :end :from-end
951 956
952\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) 957\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
953 958
954(autoload 'nsubstitute "cl-seq" "\ 959(autoload 'cl-nsubstitute "cl-seq" "\
955Substitute NEW for OLD in SEQ. 960Substitute NEW for OLD in SEQ.
956This is a destructive function; it reuses the storage of SEQ whenever possible. 961This is a destructive function; it reuses the storage of SEQ whenever possible.
957 962
@@ -959,7 +964,7 @@ Keywords supported: :test :test-not :key :count :start :end :from-end
959 964
960\(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil) 965\(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil)
961 966
962(autoload 'nsubstitute-if "cl-seq" "\ 967(autoload 'cl-nsubstitute-if "cl-seq" "\
963Substitute NEW for all items satisfying PREDICATE in SEQ. 968Substitute NEW for all items satisfying PREDICATE in SEQ.
964This is a destructive function; it reuses the storage of SEQ whenever possible. 969This is a destructive function; it reuses the storage of SEQ whenever possible.
965 970
@@ -967,7 +972,7 @@ Keywords supported: :key :count :start :end :from-end
967 972
968\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) 973\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
969 974
970(autoload 'nsubstitute-if-not "cl-seq" "\ 975(autoload 'cl-nsubstitute-if-not "cl-seq" "\
971Substitute NEW for all items not satisfying PREDICATE in SEQ. 976Substitute NEW for all items not satisfying PREDICATE in SEQ.
972This is a destructive function; it reuses the storage of SEQ whenever possible. 977This is a destructive function; it reuses the storage of SEQ whenever possible.
973 978
@@ -975,7 +980,7 @@ Keywords supported: :key :count :start :end :from-end
975 980
976\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) 981\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
977 982
978(autoload 'find "cl-seq" "\ 983(autoload 'cl-find "cl-seq" "\
979Find the first occurrence of ITEM in SEQ. 984Find the first occurrence of ITEM in SEQ.
980Return the matching ITEM, or nil if not found. 985Return the matching ITEM, or nil if not found.
981 986
@@ -983,7 +988,7 @@ Keywords supported: :test :test-not :key :start :end :from-end
983 988
984\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil) 989\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
985 990
986(autoload 'find-if "cl-seq" "\ 991(autoload 'cl-find-if "cl-seq" "\
987Find the first item satisfying PREDICATE in SEQ. 992Find the first item satisfying PREDICATE in SEQ.
988Return the matching item, or nil if not found. 993Return the matching item, or nil if not found.
989 994
@@ -991,7 +996,7 @@ Keywords supported: :key :start :end :from-end
991 996
992\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) 997\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
993 998
994(autoload 'find-if-not "cl-seq" "\ 999(autoload 'cl-find-if-not "cl-seq" "\
995Find the first item not satisfying PREDICATE in SEQ. 1000Find the first item not satisfying PREDICATE in SEQ.
996Return the matching item, or nil if not found. 1001Return the matching item, or nil if not found.
997 1002
@@ -999,7 +1004,7 @@ Keywords supported: :key :start :end :from-end
999 1004
1000\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) 1005\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
1001 1006
1002(autoload 'position "cl-seq" "\ 1007(autoload 'cl-position "cl-seq" "\
1003Find the first occurrence of ITEM in SEQ. 1008Find the first occurrence of ITEM in SEQ.
1004Return the index of the matching item, or nil if not found. 1009Return the index of the matching item, or nil if not found.
1005 1010
@@ -1007,7 +1012,7 @@ Keywords supported: :test :test-not :key :start :end :from-end
1007 1012
1008\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil) 1013\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
1009 1014
1010(autoload 'position-if "cl-seq" "\ 1015(autoload 'cl-position-if "cl-seq" "\
1011Find the first item satisfying PREDICATE in SEQ. 1016Find the first item satisfying PREDICATE in SEQ.
1012Return the index of the matching item, or nil if not found. 1017Return the index of the matching item, or nil if not found.
1013 1018
@@ -1015,7 +1020,7 @@ Keywords supported: :key :start :end :from-end
1015 1020
1016\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) 1021\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
1017 1022
1018(autoload 'position-if-not "cl-seq" "\ 1023(autoload 'cl-position-if-not "cl-seq" "\
1019Find the first item not satisfying PREDICATE in SEQ. 1024Find the first item not satisfying PREDICATE in SEQ.
1020Return the index of the matching item, or nil if not found. 1025Return the index of the matching item, or nil if not found.
1021 1026
@@ -1023,28 +1028,28 @@ Keywords supported: :key :start :end :from-end
1023 1028
1024\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) 1029\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
1025 1030
1026(autoload 'count "cl-seq" "\ 1031(autoload 'cl-count "cl-seq" "\
1027Count the number of occurrences of ITEM in SEQ. 1032Count the number of occurrences of ITEM in SEQ.
1028 1033
1029Keywords supported: :test :test-not :key :start :end 1034Keywords supported: :test :test-not :key :start :end
1030 1035
1031\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil) 1036\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
1032 1037
1033(autoload 'count-if "cl-seq" "\ 1038(autoload 'cl-count-if "cl-seq" "\
1034Count the number of items satisfying PREDICATE in SEQ. 1039Count the number of items satisfying PREDICATE in SEQ.
1035 1040
1036Keywords supported: :key :start :end 1041Keywords supported: :key :start :end
1037 1042
1038\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) 1043\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
1039 1044
1040(autoload 'count-if-not "cl-seq" "\ 1045(autoload 'cl-count-if-not "cl-seq" "\
1041Count the number of items not satisfying PREDICATE in SEQ. 1046Count the number of items not satisfying PREDICATE in SEQ.
1042 1047
1043Keywords supported: :key :start :end 1048Keywords supported: :key :start :end
1044 1049
1045\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) 1050\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
1046 1051
1047(autoload 'mismatch "cl-seq" "\ 1052(autoload 'cl-mismatch "cl-seq" "\
1048Compare SEQ1 with SEQ2, return index of first mismatching element. 1053Compare SEQ1 with SEQ2, return index of first mismatching element.
1049Return nil if the sequences match. If one sequence is a prefix of the 1054Return nil if the sequences match. If one sequence is a prefix of the
1050other, the return value indicates the end of the shorter sequence. 1055other, the return value indicates the end of the shorter sequence.
@@ -1053,7 +1058,7 @@ Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end
1053 1058
1054\(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil) 1059\(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil)
1055 1060
1056(autoload 'search "cl-seq" "\ 1061(autoload 'cl-search "cl-seq" "\
1057Search for SEQ1 as a subsequence of SEQ2. 1062Search for SEQ1 as a subsequence of SEQ2.
1058Return the index of the leftmost element of the first match found; 1063Return the index of the leftmost element of the first match found;
1059return nil if there are no matches. 1064return nil if there are no matches.
@@ -1062,7 +1067,7 @@ Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end
1062 1067
1063\(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil) 1068\(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil)
1064 1069
1065(autoload 'sort* "cl-seq" "\ 1070(autoload 'cl-sort "cl-seq" "\
1066Sort the argument SEQ according to PREDICATE. 1071Sort the argument SEQ according to PREDICATE.
1067This is a destructive function; it reuses the storage of SEQ if possible. 1072This is a destructive function; it reuses the storage of SEQ if possible.
1068 1073
@@ -1070,7 +1075,7 @@ Keywords supported: :key
1070 1075
1071\(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil) 1076\(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil)
1072 1077
1073(autoload 'stable-sort "cl-seq" "\ 1078(autoload 'cl-stable-sort "cl-seq" "\
1074Sort the argument SEQ stably according to PREDICATE. 1079Sort the argument SEQ stably according to PREDICATE.
1075This is a destructive function; it reuses the storage of SEQ if possible. 1080This is a destructive function; it reuses the storage of SEQ if possible.
1076 1081
@@ -1078,7 +1083,7 @@ Keywords supported: :key
1078 1083
1079\(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil) 1084\(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil)
1080 1085
1081(autoload 'merge "cl-seq" "\ 1086(autoload 'cl-merge "cl-seq" "\
1082Destructively merge the two sequences to produce a new sequence. 1087Destructively merge the two sequences to produce a new sequence.
1083TYPE is the sequence type to return, SEQ1 and SEQ2 are the two argument 1088TYPE is the sequence type to return, SEQ1 and SEQ2 are the two argument
1084sequences, and PREDICATE is a `less-than' predicate on the elements. 1089sequences, and PREDICATE is a `less-than' predicate on the elements.
@@ -1087,7 +1092,7 @@ Keywords supported: :key
1087 1092
1088\(fn TYPE SEQ1 SEQ2 PREDICATE [KEYWORD VALUE]...)" nil nil) 1093\(fn TYPE SEQ1 SEQ2 PREDICATE [KEYWORD VALUE]...)" nil nil)
1089 1094
1090(autoload 'member* "cl-seq" "\ 1095(autoload 'cl-member "cl-seq" "\
1091Find the first occurrence of ITEM in LIST. 1096Find the first occurrence of ITEM in LIST.
1092Return the sublist of LIST whose car is ITEM. 1097Return the sublist of LIST whose car is ITEM.
1093 1098
@@ -1095,7 +1100,7 @@ Keywords supported: :test :test-not :key
1095 1100
1096\(fn ITEM LIST [KEYWORD VALUE]...)" nil nil) 1101\(fn ITEM LIST [KEYWORD VALUE]...)" nil nil)
1097 1102
1098(autoload 'member-if "cl-seq" "\ 1103(autoload 'cl-member-if "cl-seq" "\
1099Find the first item satisfying PREDICATE in LIST. 1104Find the first item satisfying PREDICATE in LIST.
1100Return the sublist of LIST whose car matches. 1105Return the sublist of LIST whose car matches.
1101 1106
@@ -1103,7 +1108,7 @@ Keywords supported: :key
1103 1108
1104\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil) 1109\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
1105 1110
1106(autoload 'member-if-not "cl-seq" "\ 1111(autoload 'cl-member-if-not "cl-seq" "\
1107Find the first item not satisfying PREDICATE in LIST. 1112Find the first item not satisfying PREDICATE in LIST.
1108Return the sublist of LIST whose car matches. 1113Return the sublist of LIST whose car matches.
1109 1114
@@ -1116,49 +1121,49 @@ Keywords supported: :key
1116 1121
1117\(fn CL-ITEM CL-LIST &rest CL-KEYS)" nil nil) 1122\(fn CL-ITEM CL-LIST &rest CL-KEYS)" nil nil)
1118 1123
1119(autoload 'assoc* "cl-seq" "\ 1124(autoload 'cl-assoc "cl-seq" "\
1120Find the first item whose car matches ITEM in LIST. 1125Find the first item whose car matches ITEM in LIST.
1121 1126
1122Keywords supported: :test :test-not :key 1127Keywords supported: :test :test-not :key
1123 1128
1124\(fn ITEM LIST [KEYWORD VALUE]...)" nil nil) 1129\(fn ITEM LIST [KEYWORD VALUE]...)" nil nil)
1125 1130
1126(autoload 'assoc-if "cl-seq" "\ 1131(autoload 'cl-assoc-if "cl-seq" "\
1127Find the first item whose car satisfies PREDICATE in LIST. 1132Find the first item whose car satisfies PREDICATE in LIST.
1128 1133
1129Keywords supported: :key 1134Keywords supported: :key
1130 1135
1131\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil) 1136\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
1132 1137
1133(autoload 'assoc-if-not "cl-seq" "\ 1138(autoload 'cl-assoc-if-not "cl-seq" "\
1134Find the first item whose car does not satisfy PREDICATE in LIST. 1139Find the first item whose car does not satisfy PREDICATE in LIST.
1135 1140
1136Keywords supported: :key 1141Keywords supported: :key
1137 1142
1138\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil) 1143\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
1139 1144
1140(autoload 'rassoc* "cl-seq" "\ 1145(autoload 'cl-rassoc "cl-seq" "\
1141Find the first item whose cdr matches ITEM in LIST. 1146Find the first item whose cdr matches ITEM in LIST.
1142 1147
1143Keywords supported: :test :test-not :key 1148Keywords supported: :test :test-not :key
1144 1149
1145\(fn ITEM LIST [KEYWORD VALUE]...)" nil nil) 1150\(fn ITEM LIST [KEYWORD VALUE]...)" nil nil)
1146 1151
1147(autoload 'rassoc-if "cl-seq" "\ 1152(autoload 'cl-rassoc-if "cl-seq" "\
1148Find the first item whose cdr satisfies PREDICATE in LIST. 1153Find the first item whose cdr satisfies PREDICATE in LIST.
1149 1154
1150Keywords supported: :key 1155Keywords supported: :key
1151 1156
1152\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil) 1157\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
1153 1158
1154(autoload 'rassoc-if-not "cl-seq" "\ 1159(autoload 'cl-rassoc-if-not "cl-seq" "\
1155Find the first item whose cdr does not satisfy PREDICATE in LIST. 1160Find the first item whose cdr does not satisfy PREDICATE in LIST.
1156 1161
1157Keywords supported: :key 1162Keywords supported: :key
1158 1163
1159\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil) 1164\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
1160 1165
1161(autoload 'union "cl-seq" "\ 1166(autoload 'cl-union "cl-seq" "\
1162Combine LIST1 and LIST2 using a set-union operation. 1167Combine LIST1 and LIST2 using a set-union operation.
1163The resulting list contains all items that appear in either LIST1 or LIST2. 1168The resulting list contains all items that appear in either LIST1 or LIST2.
1164This is a non-destructive function; it makes a copy of the data if necessary 1169This is a non-destructive function; it makes a copy of the data if necessary
@@ -1168,7 +1173,7 @@ Keywords supported: :test :test-not :key
1168 1173
1169\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) 1174\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1170 1175
1171(autoload 'nunion "cl-seq" "\ 1176(autoload 'cl-nunion "cl-seq" "\
1172Combine LIST1 and LIST2 using a set-union operation. 1177Combine LIST1 and LIST2 using a set-union operation.
1173The resulting list contains all items that appear in either LIST1 or LIST2. 1178The resulting list contains all items that appear in either LIST1 or LIST2.
1174This is a destructive function; it reuses the storage of LIST1 and LIST2 1179This is a destructive function; it reuses the storage of LIST1 and LIST2
@@ -1178,7 +1183,7 @@ Keywords supported: :test :test-not :key
1178 1183
1179\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) 1184\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1180 1185
1181(autoload 'intersection "cl-seq" "\ 1186(autoload 'cl-intersection "cl-seq" "\
1182Combine LIST1 and LIST2 using a set-intersection operation. 1187Combine LIST1 and LIST2 using a set-intersection operation.
1183The resulting list contains all items that appear in both LIST1 and LIST2. 1188The resulting list contains all items that appear in both LIST1 and LIST2.
1184This is a non-destructive function; it makes a copy of the data if necessary 1189This is a non-destructive function; it makes a copy of the data if necessary
@@ -1188,7 +1193,7 @@ Keywords supported: :test :test-not :key
1188 1193
1189\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) 1194\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1190 1195
1191(autoload 'nintersection "cl-seq" "\ 1196(autoload 'cl-nintersection "cl-seq" "\
1192Combine LIST1 and LIST2 using a set-intersection operation. 1197Combine LIST1 and LIST2 using a set-intersection operation.
1193The resulting list contains all items that appear in both LIST1 and LIST2. 1198The resulting list contains all items that appear in both LIST1 and LIST2.
1194This is a destructive function; it reuses the storage of LIST1 and LIST2 1199This is a destructive function; it reuses the storage of LIST1 and LIST2
@@ -1198,7 +1203,7 @@ Keywords supported: :test :test-not :key
1198 1203
1199\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) 1204\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1200 1205
1201(autoload 'set-difference "cl-seq" "\ 1206(autoload 'cl-set-difference "cl-seq" "\
1202Combine LIST1 and LIST2 using a set-difference operation. 1207Combine LIST1 and LIST2 using a set-difference operation.
1203The resulting list contains all items that appear in LIST1 but not LIST2. 1208The resulting list contains all items that appear in LIST1 but not LIST2.
1204This is a non-destructive function; it makes a copy of the data if necessary 1209This is a non-destructive function; it makes a copy of the data if necessary
@@ -1208,7 +1213,7 @@ Keywords supported: :test :test-not :key
1208 1213
1209\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) 1214\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1210 1215
1211(autoload 'nset-difference "cl-seq" "\ 1216(autoload 'cl-nset-difference "cl-seq" "\
1212Combine LIST1 and LIST2 using a set-difference operation. 1217Combine LIST1 and LIST2 using a set-difference operation.
1213The resulting list contains all items that appear in LIST1 but not LIST2. 1218The resulting list contains all items that appear in LIST1 but not LIST2.
1214This is a destructive function; it reuses the storage of LIST1 and LIST2 1219This is a destructive function; it reuses the storage of LIST1 and LIST2
@@ -1218,7 +1223,7 @@ Keywords supported: :test :test-not :key
1218 1223
1219\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) 1224\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1220 1225
1221(autoload 'set-exclusive-or "cl-seq" "\ 1226(autoload 'cl-set-exclusive-or "cl-seq" "\
1222Combine LIST1 and LIST2 using a set-exclusive-or operation. 1227Combine LIST1 and LIST2 using a set-exclusive-or operation.
1223The resulting list contains all items appearing in exactly one of LIST1, LIST2. 1228The resulting list contains all items appearing in exactly one of LIST1, LIST2.
1224This is a non-destructive function; it makes a copy of the data if necessary 1229This is a non-destructive function; it makes a copy of the data if necessary
@@ -1228,7 +1233,7 @@ Keywords supported: :test :test-not :key
1228 1233
1229\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) 1234\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1230 1235
1231(autoload 'nset-exclusive-or "cl-seq" "\ 1236(autoload 'cl-nset-exclusive-or "cl-seq" "\
1232Combine LIST1 and LIST2 using a set-exclusive-or operation. 1237Combine LIST1 and LIST2 using a set-exclusive-or operation.
1233The resulting list contains all items appearing in exactly one of LIST1, LIST2. 1238The resulting list contains all items appearing in exactly one of LIST1, LIST2.
1234This is a destructive function; it reuses the storage of LIST1 and LIST2 1239This is a destructive function; it reuses the storage of LIST1 and LIST2
@@ -1238,7 +1243,7 @@ Keywords supported: :test :test-not :key
1238 1243
1239\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) 1244\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1240 1245
1241(autoload 'subsetp "cl-seq" "\ 1246(autoload 'cl-subsetp "cl-seq" "\
1242Return true if LIST1 is a subset of LIST2. 1247Return true if LIST1 is a subset of LIST2.
1243I.e., if every element of LIST1 also appears in LIST2. 1248I.e., if every element of LIST1 also appears in LIST2.
1244 1249
@@ -1246,7 +1251,7 @@ Keywords supported: :test :test-not :key
1246 1251
1247\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) 1252\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1248 1253
1249(autoload 'subst-if "cl-seq" "\ 1254(autoload 'cl-subst-if "cl-seq" "\
1250Substitute NEW for elements matching PREDICATE in TREE (non-destructively). 1255Substitute NEW for elements matching PREDICATE in TREE (non-destructively).
1251Return a copy of TREE with all matching elements replaced by NEW. 1256Return a copy of TREE with all matching elements replaced by NEW.
1252 1257
@@ -1254,7 +1259,7 @@ Keywords supported: :key
1254 1259
1255\(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil) 1260\(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil)
1256 1261
1257(autoload 'subst-if-not "cl-seq" "\ 1262(autoload 'cl-subst-if-not "cl-seq" "\
1258Substitute NEW for elts not matching PREDICATE in TREE (non-destructively). 1263Substitute NEW for elts not matching PREDICATE in TREE (non-destructively).
1259Return a copy of TREE with all non-matching elements replaced by NEW. 1264Return a copy of TREE with all non-matching elements replaced by NEW.
1260 1265
@@ -1262,7 +1267,7 @@ Keywords supported: :key
1262 1267
1263\(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil) 1268\(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil)
1264 1269
1265(autoload 'nsubst "cl-seq" "\ 1270(autoload 'cl-nsubst "cl-seq" "\
1266Substitute NEW for OLD everywhere in TREE (destructively). 1271Substitute NEW for OLD everywhere in TREE (destructively).
1267Any element of TREE which is `eql' to OLD is changed to NEW (via a call 1272Any element of TREE which is `eql' to OLD is changed to NEW (via a call
1268to `setcar'). 1273to `setcar').
@@ -1271,7 +1276,7 @@ Keywords supported: :test :test-not :key
1271 1276
1272\(fn NEW OLD TREE [KEYWORD VALUE]...)" nil nil) 1277\(fn NEW OLD TREE [KEYWORD VALUE]...)" nil nil)
1273 1278
1274(autoload 'nsubst-if "cl-seq" "\ 1279(autoload 'cl-nsubst-if "cl-seq" "\
1275Substitute NEW for elements matching PREDICATE in TREE (destructively). 1280Substitute NEW for elements matching PREDICATE in TREE (destructively).
1276Any element of TREE which matches is changed to NEW (via a call to `setcar'). 1281Any element of TREE which matches is changed to NEW (via a call to `setcar').
1277 1282
@@ -1279,7 +1284,7 @@ Keywords supported: :key
1279 1284
1280\(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil) 1285\(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil)
1281 1286
1282(autoload 'nsubst-if-not "cl-seq" "\ 1287(autoload 'cl-nsubst-if-not "cl-seq" "\
1283Substitute NEW for elements not matching PREDICATE in TREE (destructively). 1288Substitute NEW for elements not matching PREDICATE in TREE (destructively).
1284Any element of TREE which matches is changed to NEW (via a call to `setcar'). 1289Any element of TREE which matches is changed to NEW (via a call to `setcar').
1285 1290
@@ -1287,7 +1292,7 @@ Keywords supported: :key
1287 1292
1288\(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil) 1293\(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil)
1289 1294
1290(autoload 'sublis "cl-seq" "\ 1295(autoload 'cl-sublis "cl-seq" "\
1291Perform substitutions indicated by ALIST in TREE (non-destructively). 1296Perform substitutions indicated by ALIST in TREE (non-destructively).
1292Return a copy of TREE with all matching elements replaced. 1297Return a copy of TREE with all matching elements replaced.
1293 1298
@@ -1295,7 +1300,7 @@ Keywords supported: :test :test-not :key
1295 1300
1296\(fn ALIST TREE [KEYWORD VALUE]...)" nil nil) 1301\(fn ALIST TREE [KEYWORD VALUE]...)" nil nil)
1297 1302
1298(autoload 'nsublis "cl-seq" "\ 1303(autoload 'cl-nsublis "cl-seq" "\
1299Perform substitutions indicated by ALIST in TREE (destructively). 1304Perform substitutions indicated by ALIST in TREE (destructively).
1300Any matching element of TREE is changed via a call to `setcar'. 1305Any matching element of TREE is changed via a call to `setcar'.
1301 1306
@@ -1303,7 +1308,7 @@ Keywords supported: :test :test-not :key
1303 1308
1304\(fn ALIST TREE [KEYWORD VALUE]...)" nil nil) 1309\(fn ALIST TREE [KEYWORD VALUE]...)" nil nil)
1305 1310
1306(autoload 'tree-equal "cl-seq" "\ 1311(autoload 'cl-tree-equal "cl-seq" "\
1307Return t if trees TREE1 and TREE2 have `eql' leaves. 1312Return t if trees TREE1 and TREE2 have `eql' leaves.
1308Atoms are compared by `eql'; cons cells are compared recursively. 1313Atoms are compared by `eql'; cons cells are compared recursively.
1309 1314
generated by cgit v1.2.1 (git 2.18.0) at 2026-01-25 11:00:47 +0000