comparison lisp/emacs-lisp/cl-loaddefs.el @ 78370:72c49bf90ee7

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