1 ;;; cl-loaddefs.el --- automatically extracted autoloads
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" "1a3a04c6a0286373093bea4b9bcf2e91")
14 ;;; Generated autoloads from cl-extra.el
16 (autoload 'coerce
"cl-extra" "\
17 Coerce OBJECT to type TYPE.
18 TYPE is a Common Lisp type specifier.
20 \(fn OBJECT TYPE)" nil nil
)
22 (autoload '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.
30 (autoload 'cl-mapcar-many
"cl-extra" "\
33 \(fn CL-FUNC CL-SEQS)" nil nil
)
35 (autoload 'map
"cl-extra" "\
36 Map a FUNCTION across one or more SEQUENCEs, returning a sequence.
37 TYPE is the sequence type to return.
39 \(fn TYPE FUNCTION SEQUENCE...)" nil nil
)
41 (autoload '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.
46 \(fn FUNCTION LIST...)" nil nil
)
48 (autoload 'mapl
"cl-extra" "\
49 Like `maplist', but does not accumulate values returned by the function.
51 \(fn FUNCTION LIST...)" nil nil
)
53 (autoload 'mapcan
"cl-extra" "\
54 Like `mapcar', but nconc's together the values returned by the function.
56 \(fn FUNCTION SEQUENCE...)" nil nil
)
58 (autoload 'mapcon
"cl-extra" "\
59 Like `maplist', but nconc's together the values returned by the function.
61 \(fn FUNCTION LIST...)" nil nil
)
63 (autoload '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.
67 \(fn PREDICATE SEQ...)" nil nil
)
69 (autoload 'every
"cl-extra" "\
70 Return true if PREDICATE is true of every element of SEQ or SEQs.
72 \(fn PREDICATE SEQ...)" nil nil
)
74 (autoload 'notany
"cl-extra" "\
75 Return true if PREDICATE is false of every element of SEQ or SEQs.
77 \(fn PREDICATE SEQ...)" nil nil
)
79 (autoload 'notevery
"cl-extra" "\
80 Return true if PREDICATE is false of some element of SEQ or SEQs.
82 \(fn PREDICATE SEQ...)" nil nil
)
84 (defalias 'cl-map-keymap
'map-keymap
)
86 (autoload 'cl-map-keymap-recursively
"cl-extra" "\
89 \(fn CL-FUNC-REC CL-MAP &optional CL-BASE)" nil nil
)
91 (autoload 'cl-map-intervals
"cl-extra" "\
94 \(fn CL-FUNC &optional CL-WHAT CL-PROP CL-START CL-END)" nil nil
)
96 (autoload 'cl-map-overlays
"cl-extra" "\
99 \(fn CL-FUNC &optional CL-BUFFER CL-START CL-END CL-ARG)" nil nil
)
101 (autoload 'cl-set-frame-visible-p
"cl-extra" "\
104 \(fn FRAME VAL)" nil nil
)
106 (autoload 'cl-progv-before
"cl-extra" "\
109 \(fn SYMS VALUES)" nil nil
)
111 (autoload 'gcd
"cl-extra" "\
112 Return the greatest common divisor of the arguments.
114 \(fn &rest ARGS)" nil nil
)
116 (autoload 'lcm
"cl-extra" "\
117 Return the least common multiple of the arguments.
119 \(fn &rest ARGS)" nil nil
)
121 (autoload 'isqrt
"cl-extra" "\
122 Return the integer square root of the argument.
126 (autoload '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.
130 \(fn X &optional Y)" nil nil
)
132 (autoload '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.
136 \(fn X &optional Y)" nil nil
)
138 (autoload '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.
142 \(fn X &optional Y)" nil nil
)
144 (autoload '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.
148 \(fn X &optional Y)" nil nil
)
150 (autoload 'mod
* "cl-extra" "\
151 The remainder of X divided by Y, with the same sign as Y.
155 (autoload 'rem
* "cl-extra" "\
156 The remainder of X divided by Y, with the same sign as X.
160 (autoload 'signum
"cl-extra" "\
161 Return 1 if X is positive, -1 if negative, 0 if zero.
165 (autoload '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.
169 \(fn LIM &optional STATE)" nil nil
)
171 (autoload 'make-random-state
"cl-extra" "\
172 Return a copy of random-state STATE, or of the internal state if omitted.
173 If STATE is t, return a new state object seeded from the time of day.
175 \(fn &optional STATE)" nil nil
)
177 (autoload 'random-state-p
"cl-extra" "\
178 Return t if OBJECT is a random-state object.
180 \(fn OBJECT)" nil nil
)
182 (autoload 'cl-float-limits
"cl-extra" "\
183 Initialize the Common Lisp floating-point parameters.
184 This sets the values of: `most-positive-float', `most-negative-float',
185 `least-positive-float', `least-negative-float', `float-epsilon',
186 `float-negative-epsilon', `least-positive-normalized-float', and
187 `least-negative-normalized-float'.
191 (autoload 'subseq
"cl-extra" "\
192 Return the subsequence of SEQ from START to END.
193 If END is omitted, it defaults to the length of the sequence.
194 If START or END is negative, it counts from the end.
196 \(fn SEQ START &optional END)" nil nil
)
198 (autoload 'concatenate
"cl-extra" "\
199 Concatenate, into a sequence of type TYPE, the argument SEQUENCEs.
201 \(fn TYPE SEQUENCE...)" nil nil
)
203 (autoload 'revappend
"cl-extra" "\
204 Equivalent to (append (reverse X) Y).
208 (autoload 'nreconc
"cl-extra" "\
209 Equivalent to (nconc (nreverse X) Y).
213 (autoload 'list-length
"cl-extra" "\
214 Return the length of list X. Return nil if list is circular.
218 (autoload 'tailp
"cl-extra" "\
219 Return true if SUBLIST is a tail of LIST.
221 \(fn SUBLIST LIST)" nil nil
)
223 (autoload 'get
* "cl-extra" "\
224 Return the value of SYMBOL's PROPNAME property, or DEFAULT if none.
226 \(fn SYMBOL PROPNAME &optional DEFAULT)" nil nil
)
228 (autoload 'getf
"cl-extra" "\
229 Search PROPLIST for property PROPNAME; return its value or DEFAULT.
230 PROPLIST is a list of the sort returned by `symbol-plist'.
232 \(fn PROPLIST PROPNAME &optional DEFAULT)" nil nil
)
234 (autoload 'cl-set-getf
"cl-extra" "\
237 \(fn PLIST TAG VAL)" nil nil
)
239 (autoload 'cl-do-remf
"cl-extra" "\
242 \(fn PLIST TAG)" nil nil
)
244 (autoload 'cl-remprop
"cl-extra" "\
245 Remove from SYMBOL's plist the property PROPNAME and its value.
247 \(fn SYMBOL PROPNAME)" nil nil
)
249 (defalias 'remprop
'cl-remprop
)
251 (defalias 'cl-gethash
'gethash
)
253 (defalias 'cl-puthash
'puthash
)
255 (defalias 'cl-remhash
'remhash
)
257 (defalias 'cl-clrhash
'clrhash
)
259 (defalias 'cl-maphash
'maphash
)
261 (defalias 'cl-make-hash-table
'make-hash-table
)
263 (defalias 'cl-hash-table-p
'hash-table-p
)
265 (defalias 'cl-hash-table-count
'hash-table-count
)
267 (autoload 'cl-macroexpand-all
"cl-extra" "\
268 Expand all macro calls through a Lisp FORM.
269 This also does some trivial optimizations to make the form prettier.
271 \(fn FORM &optional ENV)" nil nil
)
273 (autoload 'cl-prettyexpand
"cl-extra" "\
276 \(fn FORM &optional FULL)" nil nil
)
280 ;;;### (autoloads (defsubst* compiler-macroexpand define-compiler-macro
281 ;;;;;; assert check-type typep deftype cl-struct-setf-expander defstruct
282 ;;;;;; define-modify-macro callf2 callf letf* letf rotatef shiftf
283 ;;;;;; remf cl-do-pop psetf setf get-setf-method defsetf define-setf-method
284 ;;;;;; declare the locally multiple-value-setq multiple-value-bind
285 ;;;;;; lexical-let* lexical-let symbol-macrolet macrolet labels
286 ;;;;;; flet progv psetq do-all-symbols do-symbols dotimes dolist
287 ;;;;;; do* do loop return-from return block etypecase typecase ecase
288 ;;;;;; case load-time-value eval-when destructuring-bind function*
289 ;;;;;; defmacro* defun* gentemp gensym) "cl-macs" "cl-macs.el" "609f133b406e41ac5609fcd85e3f23de")
290 ;;; Generated autoloads from cl-macs.el
292 (autoload 'gensym
"cl-macs" "\
293 Generate a new uninterned symbol.
294 The name is made by appending a number to PREFIX, default \"G\".
296 \(fn &optional PREFIX)" nil nil
)
298 (autoload 'gentemp
"cl-macs" "\
299 Generate a new interned symbol with a unique name.
300 The name is made by appending a number to PREFIX, default \"G\".
302 \(fn &optional PREFIX)" nil nil
)
304 (autoload 'defun
* "cl-macs" "\
305 Define NAME as a function.
306 Like normal `defun', except ARGLIST allows full Common Lisp conventions,
307 and BODY is implicitly surrounded by (block NAME ...).
309 \(fn NAME ARGLIST [DOCSTRING] BODY...)" nil t
)
311 (put 'defun
* 'doc-string-elt
'3)
313 (put 'defun
* 'lisp-indent-function
'2)
315 (autoload 'defmacro
* "cl-macs" "\
316 Define NAME as a macro.
317 Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
318 and BODY is implicitly surrounded by (block NAME ...).
320 \(fn NAME ARGLIST [DOCSTRING] BODY...)" nil t
)
322 (put 'defmacro
* 'doc-string-elt
'3)
324 (put 'defmacro
* 'lisp-indent-function
'2)
326 (autoload 'function
* "cl-macs" "\
327 Introduce a function.
328 Like normal `function', except that if argument is a lambda form,
329 its argument list allows full Common Lisp conventions.
333 (autoload 'destructuring-bind
"cl-macs" "\
336 \(fn ARGS EXPR &rest BODY)" nil t
)
338 (put 'destructuring-bind
'lisp-indent-function
'2)
340 (autoload 'eval-when
"cl-macs" "\
341 Control when BODY is evaluated.
342 If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
343 If `load' is in WHEN, BODY is evaluated when loaded after top-level compile.
344 If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level.
346 \(fn (WHEN...) BODY...)" nil t
)
348 (put 'eval-when
'lisp-indent-function
'1)
350 (autoload 'load-time-value
"cl-macs" "\
351 Like `progn', but evaluates the body at load time.
352 The result of the body appears to the compiler as a quoted constant.
354 \(fn FORM &optional READ-ONLY)" nil t
)
356 (autoload 'case
"cl-macs" "\
357 Eval EXPR and choose among clauses on that value.
358 Each clause looks like (KEYLIST BODY...). EXPR is evaluated and compared
359 against each key in each KEYLIST; the corresponding BODY is evaluated.
360 If no clause succeeds, case returns nil. A single atom may be used in
361 place of a KEYLIST of one atom. A KEYLIST of t or `otherwise' is
362 allowed only in the final clause, and matches if no other keys match.
363 Key values are compared by `eql'.
365 \(fn EXPR (KEYLIST BODY...)...)" nil t
)
367 (put 'case
'lisp-indent-function
'1)
369 (autoload 'ecase
"cl-macs" "\
370 Like `case', but error if no case fits.
371 `otherwise'-clauses are not allowed.
373 \(fn EXPR (KEYLIST BODY...)...)" nil t
)
375 (put 'ecase
'lisp-indent-function
'1)
377 (autoload 'typecase
"cl-macs" "\
378 Evals EXPR, chooses among clauses on that value.
379 Each clause looks like (TYPE BODY...). EXPR is evaluated and, if it
380 satisfies TYPE, the corresponding BODY is evaluated. If no clause succeeds,
381 typecase returns nil. A TYPE of t or `otherwise' is allowed only in the
382 final clause, and matches if no other keys match.
384 \(fn EXPR (TYPE BODY...)...)" nil t
)
386 (put 'typecase
'lisp-indent-function
'1)
388 (autoload 'etypecase
"cl-macs" "\
389 Like `typecase', but error if no case fits.
390 `otherwise'-clauses are not allowed.
392 \(fn EXPR (TYPE BODY...)...)" nil t
)
394 (put 'etypecase
'lisp-indent-function
'1)
396 (autoload 'block
"cl-macs" "\
397 Define a lexically-scoped block named NAME.
398 NAME may be any symbol. Code inside the BODY forms can call `return-from'
399 to jump prematurely out of the block. This differs from `catch' and `throw'
400 in two respects: First, the NAME is an unevaluated symbol rather than a
401 quoted symbol or other form; and second, NAME is lexically rather than
402 dynamically scoped: Only references to it within BODY will work. These
403 references may appear inside macro expansions, but not inside functions
406 \(fn NAME &rest BODY)" nil t
)
408 (put 'block
'lisp-indent-function
'1)
410 (autoload 'return
"cl-macs" "\
411 Return from the block named nil.
412 This is equivalent to `(return-from nil RESULT)'.
414 \(fn &optional RESULT)" nil t
)
416 (autoload 'return-from
"cl-macs" "\
417 Return from the block named NAME.
418 This jumps out to the innermost enclosing `(block NAME ...)' form,
419 returning RESULT from that form (or nil if RESULT is omitted).
420 This is compatible with Common Lisp, but note that `defun' and
421 `defmacro' do not create implicit blocks as they do in Common Lisp.
423 \(fn NAME &optional RESULT)" nil t
)
425 (put 'return-from
'lisp-indent-function
'1)
427 (autoload 'loop
"cl-macs" "\
428 The Common Lisp `loop' macro.
430 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,
432 for VAR across ARRAY, repeat NUM, with VAR = INIT, while COND, until COND,
433 always COND, never COND, thereis COND, collect EXPR into VAR,
434 append EXPR into VAR, nconc EXPR into VAR, sum EXPR into VAR,
435 count EXPR into VAR, maximize EXPR into VAR, minimize EXPR into VAR,
436 if COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
437 unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
438 do EXPRS..., initially EXPRS..., finally EXPRS..., return EXPR,
439 finally return EXPR, named NAME.
441 \(fn CLAUSE...)" nil t
)
443 (autoload 'do
"cl-macs" "\
444 The Common Lisp `do' loop.
446 \(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil t
)
448 (put 'do
'lisp-indent-function
'2)
450 (autoload 'do
* "cl-macs" "\
451 The Common Lisp `do*' loop.
453 \(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil t
)
455 (put 'do
* 'lisp-indent-function
'2)
457 (autoload 'dolist
"cl-macs" "\
459 Evaluate BODY with VAR bound to each `car' from LIST, in turn.
460 Then evaluate RESULT to get return value, default nil.
461 An implicit nil block is established around the loop.
463 \(fn (VAR LIST [RESULT]) BODY...)" nil t
)
465 (autoload 'dotimes
"cl-macs" "\
466 Loop a certain number of times.
467 Evaluate BODY with VAR bound to successive integers from 0, inclusive,
468 to COUNT, exclusive. Then evaluate RESULT to get return value, default
471 \(fn (VAR COUNT [RESULT]) BODY...)" nil t
)
473 (autoload 'do-symbols
"cl-macs" "\
474 Loop over all symbols.
475 Evaluate BODY with VAR bound to each interned symbol, or to each symbol
478 \(fn (VAR [OBARRAY [RESULT]]) BODY...)" nil t
)
480 (put 'do-symbols
'lisp-indent-function
'1)
482 (autoload 'do-all-symbols
"cl-macs" "\
485 \(fn SPEC &rest BODY)" nil t
)
487 (put 'do-all-symbols
'lisp-indent-function
'1)
489 (autoload 'psetq
"cl-macs" "\
490 Set SYMs to the values VALs in parallel.
491 This is like `setq', except that all VAL forms are evaluated (in order)
492 before assigning any symbols SYM to the corresponding values.
494 \(fn SYM VAL SYM VAL ...)" nil t
)
496 (autoload 'progv
"cl-macs" "\
497 Bind SYMBOLS to VALUES dynamically in BODY.
498 The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
499 Each symbol in the first list is bound to the corresponding value in the
500 second list (or made unbound if VALUES is shorter than SYMBOLS); then the
501 BODY forms are executed and their result is returned. This is much like
502 a `let' form, except that the list of symbols can be computed at run-time.
504 \(fn SYMBOLS VALUES &rest BODY)" nil t
)
506 (put 'progv
'lisp-indent-function
'2)
508 (autoload 'flet
"cl-macs" "\
509 Make temporary function definitions.
510 This is an analogue of `let' that operates on the function cell of FUNC
511 rather than its value cell. The FORMs are evaluated with the specified
512 function definitions in place, then the definitions are undone (the FUNCs
513 go back to their previous definitions, or lack thereof).
515 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil t
)
517 (put 'flet
'lisp-indent-function
'1)
519 (autoload 'labels
"cl-macs" "\
520 Make temporary function bindings.
521 This is like `flet', except the bindings are lexical instead of dynamic.
522 Unlike `flet', this macro is fully compliant with the Common Lisp standard.
524 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil t
)
526 (put 'labels
'lisp-indent-function
'1)
528 (autoload 'macrolet
"cl-macs" "\
529 Make temporary macro definitions.
530 This is like `flet', but for macros instead of functions.
532 \(fn ((NAME ARGLIST BODY...) ...) FORM...)" nil t
)
534 (put 'macrolet
'lisp-indent-function
'1)
536 (autoload 'symbol-macrolet
"cl-macs" "\
537 Make symbol macro definitions.
538 Within the body FORMs, references to the variable NAME will be replaced
539 by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...).
541 \(fn ((NAME EXPANSION) ...) FORM...)" nil t
)
543 (put 'symbol-macrolet
'lisp-indent-function
'1)
545 (autoload 'lexical-let
"cl-macs" "\
546 Like `let', but lexically scoped.
547 The main visible difference is that lambdas inside BODY will create
548 lexical closures as in Common Lisp.
550 \(fn BINDINGS BODY)" nil t
)
552 (put 'lexical-let
'lisp-indent-function
'1)
554 (autoload 'lexical-let
* "cl-macs" "\
555 Like `let*', but lexically scoped.
556 The main visible difference is that lambdas inside BODY, and in
557 successive bindings within BINDINGS, will create lexical closures
558 as in Common Lisp. This is similar to the behavior of `let*' in
561 \(fn BINDINGS BODY)" nil t
)
563 (put 'lexical-let
* 'lisp-indent-function
'1)
565 (autoload 'multiple-value-bind
"cl-macs" "\
566 Collect multiple return values.
567 FORM must return a list; the BODY is then executed with the first N elements
568 of this list bound (`let'-style) to each of the symbols SYM in turn. This
569 is analogous to the Common Lisp `multiple-value-bind' macro, using lists to
570 simulate true multiple return values. For compatibility, (values A B C) is
571 a synonym for (list A B C).
573 \(fn (SYM...) FORM BODY)" nil t
)
575 (put 'multiple-value-bind
'lisp-indent-function
'2)
577 (autoload 'multiple-value-setq
"cl-macs" "\
578 Collect multiple return values.
579 FORM must return a list; the first N elements of this list are stored in
580 each 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
582 values. For compatibility, (values A B C) is a synonym for (list A B C).
584 \(fn (SYM...) FORM)" nil t
)
586 (put 'multiple-value-setq
'lisp-indent-function
'1)
588 (autoload 'locally
"cl-macs" "\
591 \(fn &rest BODY)" nil t
)
593 (autoload 'the
"cl-macs" "\
596 \(fn TYPE FORM)" nil t
)
598 (put 'the
'lisp-indent-function
'1)
600 (autoload 'declare
"cl-macs" "\
601 Declare SPECS about the current function while compiling.
606 will turn off byte-compile warnings in the function.
607 See Info node `(cl)Declarations' for details.
609 \(fn &rest SPECS)" nil t
)
611 (autoload 'define-setf-method
"cl-macs" "\
612 Define a `setf' method.
613 This method shows how to handle `setf's to places of the form (NAME ARGS...).
614 The argument forms ARGS are bound according to ARGLIST, as if NAME were
615 going to be expanded as a macro, then the BODY forms are executed and must
616 return a list of five elements: a temporary-variables list, a value-forms
617 list, a store-variables list (of length one), a store-form, and an access-
618 form. See `defsetf' for a simpler way to define most setf-methods.
620 \(fn NAME ARGLIST BODY...)" nil t
)
622 (autoload 'defsetf
"cl-macs" "\
623 Define a `setf' method.
624 This macro is an easy-to-use substitute for `define-setf-method' that works
625 well for simple place forms. In the simple `defsetf' form, `setf's of
626 the form (setf (NAME ARGS...) VAL) are transformed to function or macro
627 calls of the form (FUNC ARGS... VAL). Example:
631 Alternate form: (defsetf NAME ARGLIST (STORE) BODY...).
632 Here, the above `setf' call is expanded by binding the argument forms ARGS
633 according to ARGLIST, binding the value form VAL to STORE, then executing
634 BODY, which must return a Lisp form that does the necessary `setf' operation.
635 Actually, ARGLIST and STORE may be bound to temporary variables which are
636 introduced automatically to preserve proper execution order of the arguments.
639 (defsetf nth (n x) (v) `(setcar (nthcdr ,n ,x) ,v))
641 \(fn NAME [FUNC | ARGLIST (STORE) BODY...])" nil t
)
643 (autoload 'get-setf-method
"cl-macs" "\
644 Return a list of five values describing the setf-method for PLACE.
645 PLACE may be any Lisp form which can appear as the PLACE argument to
646 a macro like `setf' or `incf'.
648 \(fn PLACE &optional ENV)" nil nil
)
650 (autoload 'setf
"cl-macs" "\
651 Set each PLACE to the value of its VAL.
652 This is a generalized version of `setq'; the PLACEs may be symbolic
653 references such as (car x) or (aref x i), as well as plain symbols.
654 For example, (setf (cadar x) y) is equivalent to (setcar (cdar x) y).
655 The return value is the last VAL in the list.
657 \(fn PLACE VAL PLACE VAL ...)" nil t
)
659 (autoload 'psetf
"cl-macs" "\
660 Set PLACEs to the values VALs in parallel.
661 This is like `setf', except that all VAL forms are evaluated (in order)
662 before assigning any PLACEs to the corresponding values.
664 \(fn PLACE VAL PLACE VAL ...)" nil t
)
666 (autoload 'cl-do-pop
"cl-macs" "\
669 \(fn PLACE)" nil nil
)
671 (autoload 'remf
"cl-macs" "\
672 Remove TAG from property list PLACE.
673 PLACE may be a symbol, or any generalized variable allowed by `setf'.
674 The form returns true if TAG was found and removed, nil otherwise.
676 \(fn PLACE TAG)" nil t
)
678 (autoload 'shiftf
"cl-macs" "\
679 Shift left among PLACEs.
680 Example: (shiftf A B C) sets A to B, B to C, and returns the old A.
681 Each PLACE may be a symbol, or any generalized variable allowed by `setf'.
683 \(fn PLACE... VAL)" nil t
)
685 (autoload 'rotatef
"cl-macs" "\
686 Rotate left among PLACEs.
687 Example: (rotatef A B C) sets A to B, B to C, and C to A. It returns nil.
688 Each PLACE may be a symbol, or any generalized variable allowed by `setf'.
690 \(fn PLACE...)" nil t
)
692 (autoload 'letf
"cl-macs" "\
693 Temporarily bind to PLACEs.
694 This is the analogue of `let', but with generalized variables (in the
695 sense of `setf') for the PLACEs. Each PLACE is set to the corresponding
696 VALUE, then the BODY forms are executed. On exit, either normally or
697 because of a `throw' or error, the PLACEs are set back to their original
698 values. Note that this macro is *not* available in Common Lisp.
699 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
700 the PLACE is not modified before executing BODY.
702 \(fn ((PLACE VALUE) ...) BODY...)" nil t
)
704 (put 'letf
'lisp-indent-function
'1)
706 (autoload 'letf
* "cl-macs" "\
707 Temporarily bind to PLACEs.
708 This is the analogue of `let*', but with generalized variables (in the
709 sense of `setf') for the PLACEs. Each PLACE is set to the corresponding
710 VALUE, then the BODY forms are executed. On exit, either normally or
711 because of a `throw' or error, the PLACEs are set back to their original
712 values. Note that this macro is *not* available in Common Lisp.
713 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
714 the PLACE is not modified before executing BODY.
716 \(fn ((PLACE VALUE) ...) BODY...)" nil t
)
718 (put 'letf
* 'lisp-indent-function
'1)
720 (autoload 'callf
"cl-macs" "\
721 Set PLACE to (FUNC PLACE ARGS...).
722 FUNC should be an unquoted function name. PLACE may be a symbol,
723 or any generalized variable allowed by `setf'.
725 \(fn FUNC PLACE ARGS...)" nil t
)
727 (put 'callf
'lisp-indent-function
'2)
729 (autoload 'callf2
"cl-macs" "\
730 Set PLACE to (FUNC ARG1 PLACE ARGS...).
731 Like `callf', but PLACE is the second argument of FUNC, not the first.
733 \(fn FUNC ARG1 PLACE ARGS...)" nil t
)
735 (put 'callf2
'lisp-indent-function
'3)
737 (autoload 'define-modify-macro
"cl-macs" "\
738 Define a `setf'-like modify macro.
739 If NAME is called, it combines its PLACE argument with the other arguments
740 from ARGLIST using FUNC: (define-modify-macro incf (&optional (n 1)) +)
742 \(fn NAME ARGLIST FUNC &optional DOC)" nil t
)
744 (autoload 'defstruct
"cl-macs" "\
745 Define a struct type.
746 This macro defines a new data type called NAME that stores data
747 in SLOTs. It defines a `make-NAME' constructor, a `copy-NAME'
748 copier, a `NAME-p' predicate, and slot accessors named `NAME-SLOT'.
749 You can use the accessors to set the corresponding slots, via `setf'.
751 NAME may instead take the form (NAME OPTIONS...), where each
752 OPTION is either a single keyword or (KEYWORD VALUE).
753 See Info node `(cl)Structures' for a list of valid keywords.
755 Each SLOT may instead take the form (SLOT SLOT-OPTS...), where
756 SLOT-OPTS are keyword-value pairs for that slot. Currently, only
757 one keyword is supported, `:read-only'. If this has a non-nil
758 value, that slot cannot be set via `setf'.
760 \(fn NAME SLOTS...)" nil t
)
762 (put 'defstruct
'doc-string-elt
'2)
764 (autoload 'cl-struct-setf-expander
"cl-macs" "\
767 \(fn X NAME ACCESSOR PRED-FORM POS)" nil nil
)
769 (autoload 'deftype
"cl-macs" "\
770 Define NAME as a new data type.
771 The type name can then be used in `typecase', `check-type', etc.
773 \(fn NAME ARGLIST &rest BODY)" nil t
)
775 (put 'deftype
'doc-string-elt
'3)
777 (autoload 'typep
"cl-macs" "\
778 Check that OBJECT is of type TYPE.
779 TYPE is a Common Lisp-style type specifier.
781 \(fn OBJECT TYPE)" nil nil
)
783 (autoload 'check-type
"cl-macs" "\
784 Verify that FORM is of type TYPE; signal an error if not.
785 STRING is an optional description of the desired type.
787 \(fn FORM TYPE &optional STRING)" nil t
)
789 (autoload 'assert
"cl-macs" "\
790 Verify that FORM returns non-nil; signal an error if not.
791 Second arg SHOW-ARGS means to include arguments of FORM in message.
792 Other args STRING and ARGS... are arguments to be passed to `error'.
793 They are not evaluated unless the assertion fails. If STRING is
794 omitted, a default message listing FORM itself is used.
796 \(fn FORM &optional SHOW-ARGS STRING &rest ARGS)" nil t
)
798 (autoload 'define-compiler-macro
"cl-macs" "\
799 Define a compiler-only macro.
800 This is like `defmacro', but macro expansion occurs only if the call to
801 FUNC is compiled (i.e., not interpreted). Compiler macros should be used
802 for optimizing the way calls to FUNC are compiled; the form returned by
803 BODY should do the same thing as a call to the normal function called
804 FUNC, though possibly more efficiently. Note that, like regular macros,
805 compiler macros are expanded repeatedly until no further expansions are
806 possible. Unlike regular macros, BODY can decide to \"punt\" and leave the
807 original function call alone by declaring an initial `&whole foo' parameter
808 and then returning foo.
810 \(fn FUNC ARGS &rest BODY)" nil t
)
812 (autoload 'compiler-macroexpand
"cl-macs" "\
817 (autoload 'defsubst
* "cl-macs" "\
818 Define NAME as a function.
819 Like `defun', except the function is automatically declared `inline',
820 ARGLIST allows full Common Lisp conventions, and BODY is implicitly
821 surrounded by (block NAME ...).
823 \(fn NAME ARGLIST [DOCSTRING] BODY...)" nil t
)
827 ;;;### (autoloads (tree-equal nsublis sublis nsubst-if-not nsubst-if
828 ;;;;;; nsubst subst-if-not subst-if subsetp nset-exclusive-or set-exclusive-or
829 ;;;;;; nset-difference set-difference nintersection intersection
830 ;;;;;; nunion union rassoc-if-not rassoc-if rassoc* assoc-if-not
831 ;;;;;; assoc-if assoc* cl--adjoin member-if-not member-if member*
832 ;;;;;; merge stable-sort sort* search mismatch count-if-not count-if
833 ;;;;;; count position-if-not position-if position find-if-not find-if
834 ;;;;;; find nsubstitute-if-not nsubstitute-if nsubstitute substitute-if-not
835 ;;;;;; substitute-if substitute delete-duplicates remove-duplicates
836 ;;;;;; delete-if-not delete-if delete* remove-if-not remove-if remove*
837 ;;;;;; replace fill reduce) "cl-seq" "cl-seq.el" "2d8563fcbdf4bc77e569d0aeb0a35cfc")
838 ;;; Generated autoloads from cl-seq.el
840 (autoload 'reduce
"cl-seq" "\
841 Reduce two-argument FUNCTION across SEQ.
843 Keywords supported: :start :end :from-end :initial-value :key
845 \(fn FUNCTION SEQ [KEYWORD VALUE]...)" nil nil
)
847 (autoload 'fill
"cl-seq" "\
848 Fill the elements of SEQ with ITEM.
850 Keywords supported: :start :end
852 \(fn SEQ ITEM [KEYWORD VALUE]...)" nil nil
)
854 (autoload 'replace
"cl-seq" "\
855 Replace the elements of SEQ1 with the elements of SEQ2.
856 SEQ1 is destructively modified, then returned.
858 Keywords supported: :start1 :end1 :start2 :end2
860 \(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil
)
862 (autoload 'remove
* "cl-seq" "\
863 Remove all occurrences of ITEM in SEQ.
864 This is a non-destructive function; it makes a copy of SEQ if necessary
865 to avoid corrupting the original SEQ.
867 Keywords supported: :test :test-not :key :count :start :end :from-end
869 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil
)
871 (autoload 'remove-if
"cl-seq" "\
872 Remove all items satisfying PREDICATE in SEQ.
873 This is a non-destructive function; it makes a copy of SEQ if necessary
874 to avoid corrupting the original SEQ.
876 Keywords supported: :key :count :start :end :from-end
878 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
880 (autoload 'remove-if-not
"cl-seq" "\
881 Remove all items not satisfying PREDICATE in SEQ.
882 This is a non-destructive function; it makes a copy of SEQ if necessary
883 to avoid corrupting the original SEQ.
885 Keywords supported: :key :count :start :end :from-end
887 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
889 (autoload 'delete
* "cl-seq" "\
890 Remove all occurrences of ITEM in SEQ.
891 This is a destructive function; it reuses the storage of SEQ whenever possible.
893 Keywords supported: :test :test-not :key :count :start :end :from-end
895 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil
)
897 (autoload 'delete-if
"cl-seq" "\
898 Remove all items satisfying PREDICATE in SEQ.
899 This is a destructive function; it reuses the storage of SEQ whenever possible.
901 Keywords supported: :key :count :start :end :from-end
903 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
905 (autoload 'delete-if-not
"cl-seq" "\
906 Remove all items not satisfying PREDICATE in SEQ.
907 This is a destructive function; it reuses the storage of SEQ whenever possible.
909 Keywords supported: :key :count :start :end :from-end
911 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
913 (autoload 'remove-duplicates
"cl-seq" "\
914 Return a copy of SEQ with all duplicate elements removed.
916 Keywords supported: :test :test-not :key :start :end :from-end
918 \(fn SEQ [KEYWORD VALUE]...)" nil nil
)
920 (autoload 'delete-duplicates
"cl-seq" "\
921 Remove all duplicate elements from SEQ (destructively).
923 Keywords supported: :test :test-not :key :start :end :from-end
925 \(fn SEQ [KEYWORD VALUE]...)" nil nil
)
927 (autoload 'substitute
"cl-seq" "\
928 Substitute NEW for OLD in SEQ.
929 This is a non-destructive function; it makes a copy of SEQ if necessary
930 to avoid corrupting the original SEQ.
932 Keywords supported: :test :test-not :key :count :start :end :from-end
934 \(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil
)
936 (autoload 'substitute-if
"cl-seq" "\
937 Substitute NEW for all items satisfying PREDICATE in SEQ.
938 This is a non-destructive function; it makes a copy of SEQ if necessary
939 to avoid corrupting the original SEQ.
941 Keywords supported: :key :count :start :end :from-end
943 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
945 (autoload 'substitute-if-not
"cl-seq" "\
946 Substitute NEW for all items not satisfying PREDICATE in SEQ.
947 This is a non-destructive function; it makes a copy of SEQ if necessary
948 to avoid corrupting the original SEQ.
950 Keywords supported: :key :count :start :end :from-end
952 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
954 (autoload 'nsubstitute
"cl-seq" "\
955 Substitute NEW for OLD in SEQ.
956 This is a destructive function; it reuses the storage of SEQ whenever possible.
958 Keywords supported: :test :test-not :key :count :start :end :from-end
960 \(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil
)
962 (autoload 'nsubstitute-if
"cl-seq" "\
963 Substitute NEW for all items satisfying PREDICATE in SEQ.
964 This is a destructive function; it reuses the storage of SEQ whenever possible.
966 Keywords supported: :key :count :start :end :from-end
968 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
970 (autoload 'nsubstitute-if-not
"cl-seq" "\
971 Substitute NEW for all items not satisfying PREDICATE in SEQ.
972 This is a destructive function; it reuses the storage of SEQ whenever possible.
974 Keywords supported: :key :count :start :end :from-end
976 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
978 (autoload 'find
"cl-seq" "\
979 Find the first occurrence of ITEM in SEQ.
980 Return the matching ITEM, or nil if not found.
982 Keywords supported: :test :test-not :key :start :end :from-end
984 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil
)
986 (autoload 'find-if
"cl-seq" "\
987 Find the first item satisfying PREDICATE in SEQ.
988 Return the matching item, or nil if not found.
990 Keywords supported: :key :start :end :from-end
992 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
994 (autoload 'find-if-not
"cl-seq" "\
995 Find the first item not satisfying PREDICATE in SEQ.
996 Return the matching item, or nil if not found.
998 Keywords supported: :key :start :end :from-end
1000 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
1002 (autoload 'position
"cl-seq" "\
1003 Find the first occurrence of ITEM in SEQ.
1004 Return the index of the matching item, or nil if not found.
1006 Keywords supported: :test :test-not :key :start :end :from-end
1008 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil
)
1010 (autoload 'position-if
"cl-seq" "\
1011 Find the first item satisfying PREDICATE in SEQ.
1012 Return the index of the matching item, or nil if not found.
1014 Keywords supported: :key :start :end :from-end
1016 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
1018 (autoload 'position-if-not
"cl-seq" "\
1019 Find the first item not satisfying PREDICATE in SEQ.
1020 Return the index of the matching item, or nil if not found.
1022 Keywords supported: :key :start :end :from-end
1024 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
1026 (autoload 'count
"cl-seq" "\
1027 Count the number of occurrences of ITEM in SEQ.
1029 Keywords supported: :test :test-not :key :start :end
1031 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil
)
1033 (autoload 'count-if
"cl-seq" "\
1034 Count the number of items satisfying PREDICATE in SEQ.
1036 Keywords supported: :key :start :end
1038 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
1040 (autoload 'count-if-not
"cl-seq" "\
1041 Count the number of items not satisfying PREDICATE in SEQ.
1043 Keywords supported: :key :start :end
1045 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
1047 (autoload 'mismatch
"cl-seq" "\
1048 Compare SEQ1 with SEQ2, return index of first mismatching element.
1049 Return nil if the sequences match. If one sequence is a prefix of the
1050 other, the return value indicates the end of the shorter sequence.
1052 Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end
1054 \(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil
)
1056 (autoload 'search
"cl-seq" "\
1057 Search for SEQ1 as a subsequence of SEQ2.
1058 Return the index of the leftmost element of the first match found;
1059 return nil if there are no matches.
1061 Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end
1063 \(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil
)
1065 (autoload 'sort
* "cl-seq" "\
1066 Sort the argument SEQ according to PREDICATE.
1067 This is a destructive function; it reuses the storage of SEQ if possible.
1069 Keywords supported: :key
1071 \(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil
)
1073 (autoload 'stable-sort
"cl-seq" "\
1074 Sort the argument SEQ stably according to PREDICATE.
1075 This is a destructive function; it reuses the storage of SEQ if possible.
1077 Keywords supported: :key
1079 \(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil
)
1081 (autoload 'merge
"cl-seq" "\
1082 Destructively merge the two sequences to produce a new sequence.
1083 TYPE is the sequence type to return, SEQ1 and SEQ2 are the two argument
1084 sequences, and PREDICATE is a `less-than' predicate on the elements.
1086 Keywords supported: :key
1088 \(fn TYPE SEQ1 SEQ2 PREDICATE [KEYWORD VALUE]...)" nil nil
)
1090 (autoload 'member
* "cl-seq" "\
1091 Find the first occurrence of ITEM in LIST.
1092 Return the sublist of LIST whose car is ITEM.
1094 Keywords supported: :test :test-not :key
1096 \(fn ITEM LIST [KEYWORD VALUE]...)" nil nil
)
1098 (autoload 'member-if
"cl-seq" "\
1099 Find the first item satisfying PREDICATE in LIST.
1100 Return the sublist of LIST whose car matches.
1102 Keywords supported: :key
1104 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1106 (autoload 'member-if-not
"cl-seq" "\
1107 Find the first item not satisfying PREDICATE in LIST.
1108 Return the sublist of LIST whose car matches.
1110 Keywords supported: :key
1112 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1114 (autoload 'cl--adjoin
"cl-seq" "\
1117 \(fn CL-ITEM CL-LIST &rest CL-KEYS)" nil nil
)
1119 (autoload 'assoc
* "cl-seq" "\
1120 Find the first item whose car matches ITEM in LIST.
1122 Keywords supported: :test :test-not :key
1124 \(fn ITEM LIST [KEYWORD VALUE]...)" nil nil
)
1126 (autoload 'assoc-if
"cl-seq" "\
1127 Find the first item whose car satisfies PREDICATE in LIST.
1129 Keywords supported: :key
1131 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1133 (autoload 'assoc-if-not
"cl-seq" "\
1134 Find the first item whose car does not satisfy PREDICATE in LIST.
1136 Keywords supported: :key
1138 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1140 (autoload 'rassoc
* "cl-seq" "\
1141 Find the first item whose cdr matches ITEM in LIST.
1143 Keywords supported: :test :test-not :key
1145 \(fn ITEM LIST [KEYWORD VALUE]...)" nil nil
)
1147 (autoload 'rassoc-if
"cl-seq" "\
1148 Find the first item whose cdr satisfies PREDICATE in LIST.
1150 Keywords supported: :key
1152 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1154 (autoload 'rassoc-if-not
"cl-seq" "\
1155 Find the first item whose cdr does not satisfy PREDICATE in LIST.
1157 Keywords supported: :key
1159 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1161 (autoload 'union
"cl-seq" "\
1162 Combine LIST1 and LIST2 using a set-union operation.
1163 The resulting list contains all items that appear in either LIST1 or LIST2.
1164 This is a non-destructive function; it makes a copy of the data if necessary
1165 to avoid corrupting the original LIST1 and LIST2.
1167 Keywords supported: :test :test-not :key
1169 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1171 (autoload 'nunion
"cl-seq" "\
1172 Combine LIST1 and LIST2 using a set-union operation.
1173 The resulting list contains all items that appear in either LIST1 or LIST2.
1174 This is a destructive function; it reuses the storage of LIST1 and LIST2
1177 Keywords supported: :test :test-not :key
1179 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1181 (autoload 'intersection
"cl-seq" "\
1182 Combine LIST1 and LIST2 using a set-intersection operation.
1183 The resulting list contains all items that appear in both LIST1 and LIST2.
1184 This is a non-destructive function; it makes a copy of the data if necessary
1185 to avoid corrupting the original LIST1 and LIST2.
1187 Keywords supported: :test :test-not :key
1189 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1191 (autoload 'nintersection
"cl-seq" "\
1192 Combine LIST1 and LIST2 using a set-intersection operation.
1193 The resulting list contains all items that appear in both LIST1 and LIST2.
1194 This is a destructive function; it reuses the storage of LIST1 and LIST2
1197 Keywords supported: :test :test-not :key
1199 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1201 (autoload 'set-difference
"cl-seq" "\
1202 Combine LIST1 and LIST2 using a set-difference operation.
1203 The resulting list contains all items that appear in LIST1 but not LIST2.
1204 This is a non-destructive function; it makes a copy of the data if necessary
1205 to avoid corrupting the original LIST1 and LIST2.
1207 Keywords supported: :test :test-not :key
1209 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1211 (autoload 'nset-difference
"cl-seq" "\
1212 Combine LIST1 and LIST2 using a set-difference operation.
1213 The resulting list contains all items that appear in LIST1 but not LIST2.
1214 This is a destructive function; it reuses the storage of LIST1 and LIST2
1217 Keywords supported: :test :test-not :key
1219 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1221 (autoload 'set-exclusive-or
"cl-seq" "\
1222 Combine LIST1 and LIST2 using a set-exclusive-or operation.
1223 The resulting list contains all items appearing in exactly one of LIST1, LIST2.
1224 This is a non-destructive function; it makes a copy of the data if necessary
1225 to avoid corrupting the original LIST1 and LIST2.
1227 Keywords supported: :test :test-not :key
1229 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1231 (autoload 'nset-exclusive-or
"cl-seq" "\
1232 Combine LIST1 and LIST2 using a set-exclusive-or operation.
1233 The resulting list contains all items appearing in exactly one of LIST1, LIST2.
1234 This is a destructive function; it reuses the storage of LIST1 and LIST2
1237 Keywords supported: :test :test-not :key
1239 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1241 (autoload 'subsetp
"cl-seq" "\
1242 Return true if LIST1 is a subset of LIST2.
1243 I.e., if every element of LIST1 also appears in LIST2.
1245 Keywords supported: :test :test-not :key
1247 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1249 (autoload 'subst-if
"cl-seq" "\
1250 Substitute NEW for elements matching PREDICATE in TREE (non-destructively).
1251 Return a copy of TREE with all matching elements replaced by NEW.
1253 Keywords supported: :key
1255 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil
)
1257 (autoload 'subst-if-not
"cl-seq" "\
1258 Substitute NEW for elts not matching PREDICATE in TREE (non-destructively).
1259 Return a copy of TREE with all non-matching elements replaced by NEW.
1261 Keywords supported: :key
1263 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil
)
1265 (autoload 'nsubst
"cl-seq" "\
1266 Substitute NEW for OLD everywhere in TREE (destructively).
1267 Any element of TREE which is `eql' to OLD is changed to NEW (via a call
1270 Keywords supported: :test :test-not :key
1272 \(fn NEW OLD TREE [KEYWORD VALUE]...)" nil nil
)
1274 (autoload 'nsubst-if
"cl-seq" "\
1275 Substitute NEW for elements matching PREDICATE in TREE (destructively).
1276 Any element of TREE which matches is changed to NEW (via a call to `setcar').
1278 Keywords supported: :key
1280 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil
)
1282 (autoload 'nsubst-if-not
"cl-seq" "\
1283 Substitute NEW for elements not matching PREDICATE in TREE (destructively).
1284 Any element of TREE which matches is changed to NEW (via a call to `setcar').
1286 Keywords supported: :key
1288 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil
)
1290 (autoload 'sublis
"cl-seq" "\
1291 Perform substitutions indicated by ALIST in TREE (non-destructively).
1292 Return a copy of TREE with all matching elements replaced.
1294 Keywords supported: :test :test-not :key
1296 \(fn ALIST TREE [KEYWORD VALUE]...)" nil nil
)
1298 (autoload 'nsublis
"cl-seq" "\
1299 Perform substitutions indicated by ALIST in TREE (destructively).
1300 Any matching element of TREE is changed via a call to `setcar'.
1302 Keywords supported: :test :test-not :key
1304 \(fn ALIST TREE [KEYWORD VALUE]...)" nil nil
)
1306 (autoload 'tree-equal
"cl-seq" "\
1307 Return t if trees TREE1 and TREE2 have `eql' leaves.
1308 Atoms are compared by `eql'; cons cells are compared recursively.
1310 Keywords supported: :test :test-not :key
1312 \(fn TREE1 TREE2 [KEYWORD VALUE]...)" nil nil
)
1317 ;; version-control: never
1318 ;; no-byte-compile: t
1319 ;; no-update-autoloads: t
1322 ;;; cl-loaddefs.el ends here