1 ;;; cl-loaddefs.el --- automatically extracted autoloads
6 ;;;### (autoloads (cl-prettyexpand cl-remprop cl--do-remf cl--set-getf
7 ;;;;;; cl-getf cl-get cl-tailp cl-list-length cl-nreconc cl-revappend
8 ;;;;;; cl-concatenate cl-subseq cl-float-limits cl-random-state-p
9 ;;;;;; cl-make-random-state cl-random cl-signum cl-rem cl-mod cl-round
10 ;;;;;; cl-truncate cl-ceiling cl-floor cl-isqrt cl-lcm cl-gcd cl--set-frame-visible-p
11 ;;;;;; cl--map-overlays cl--map-intervals cl--map-keymap-recursively
12 ;;;;;; cl-notevery cl-notany cl-every cl-some cl-mapcon cl-mapcan
13 ;;;;;; cl-mapl cl-maplist cl-map cl--mapcar-many cl-equalp cl-coerce)
14 ;;;;;; "cl-extra" "cl-extra.el" "1572ae52fa4fbd9c4bf89b49a068a865")
15 ;;; Generated autoloads from cl-extra.el
17 (autoload 'cl-coerce
"cl-extra" "\
18 Coerce OBJECT to type TYPE.
19 TYPE is a Common Lisp type specifier.
21 \(fn OBJECT TYPE)" nil nil
)
23 (autoload 'cl-equalp
"cl-extra" "\
24 Return t if two Lisp objects have similar structures and contents.
25 This is like `equal', except that it accepts numerically equal
26 numbers of different types (float vs. integer), and also compares
27 strings case-insensitively.
31 (autoload 'cl--mapcar-many
"cl-extra" "\
34 \(fn CL-FUNC CL-SEQS)" nil nil
)
36 (autoload 'cl-map
"cl-extra" "\
37 Map a FUNCTION across one or more SEQUENCEs, returning a sequence.
38 TYPE is the sequence type to return.
40 \(fn TYPE FUNCTION SEQUENCE...)" nil nil
)
42 (autoload 'cl-maplist
"cl-extra" "\
43 Map FUNCTION to each sublist of LIST or LISTs.
44 Like `mapcar', except applies to lists and their cdr's rather than to
45 the elements themselves.
47 \(fn FUNCTION LIST...)" nil nil
)
49 (autoload 'cl-mapl
"cl-extra" "\
50 Like `cl-maplist', but does not accumulate values returned by the function.
52 \(fn FUNCTION LIST...)" nil nil
)
54 (autoload 'cl-mapcan
"cl-extra" "\
55 Like `mapcar', but nconc's together the values returned by the function.
57 \(fn FUNCTION SEQUENCE...)" nil nil
)
59 (autoload 'cl-mapcon
"cl-extra" "\
60 Like `cl-maplist', but nconc's together the values returned by the function.
62 \(fn FUNCTION LIST...)" nil nil
)
64 (autoload 'cl-some
"cl-extra" "\
65 Return true if PREDICATE is true of any element of SEQ or SEQs.
66 If so, return the true (non-nil) value returned by PREDICATE.
68 \(fn PREDICATE SEQ...)" nil nil
)
70 (autoload 'cl-every
"cl-extra" "\
71 Return true if PREDICATE is true of every element of SEQ or SEQs.
73 \(fn PREDICATE SEQ...)" nil nil
)
75 (autoload 'cl-notany
"cl-extra" "\
76 Return true if PREDICATE is false of every element of SEQ or SEQs.
78 \(fn PREDICATE SEQ...)" nil nil
)
80 (autoload 'cl-notevery
"cl-extra" "\
81 Return true if PREDICATE is false of some element of SEQ or SEQs.
83 \(fn PREDICATE SEQ...)" nil nil
)
85 (autoload 'cl--map-keymap-recursively
"cl-extra" "\
88 \(fn CL-FUNC-REC CL-MAP &optional CL-BASE)" nil nil
)
90 (autoload 'cl--map-intervals
"cl-extra" "\
93 \(fn CL-FUNC &optional CL-WHAT CL-PROP CL-START CL-END)" nil nil
)
95 (autoload 'cl--map-overlays
"cl-extra" "\
98 \(fn CL-FUNC &optional CL-BUFFER CL-START CL-END CL-ARG)" nil nil
)
100 (autoload 'cl--set-frame-visible-p
"cl-extra" "\
103 \(fn FRAME VAL)" nil nil
)
105 (autoload 'cl-gcd
"cl-extra" "\
106 Return the greatest common divisor of the arguments.
108 \(fn &rest ARGS)" nil nil
)
110 (autoload 'cl-lcm
"cl-extra" "\
111 Return the least common multiple of the arguments.
113 \(fn &rest ARGS)" nil nil
)
115 (autoload 'cl-isqrt
"cl-extra" "\
116 Return the integer square root of the argument.
120 (autoload 'cl-floor
"cl-extra" "\
121 Return a list of the floor of X and the fractional part of X.
122 With two arguments, return floor and remainder of their quotient.
124 \(fn X &optional Y)" nil nil
)
126 (autoload 'cl-ceiling
"cl-extra" "\
127 Return a list of the ceiling of X and the fractional part of X.
128 With two arguments, return ceiling and remainder of their quotient.
130 \(fn X &optional Y)" nil nil
)
132 (autoload 'cl-truncate
"cl-extra" "\
133 Return a list of the integer part of X and the fractional part of X.
134 With two arguments, return truncation and remainder of their quotient.
136 \(fn X &optional Y)" nil nil
)
138 (autoload 'cl-round
"cl-extra" "\
139 Return a list of X rounded to the nearest integer and the remainder.
140 With two arguments, return rounding and remainder of their quotient.
142 \(fn X &optional Y)" nil nil
)
144 (autoload 'cl-mod
"cl-extra" "\
145 The remainder of X divided by Y, with the same sign as Y.
149 (autoload 'cl-rem
"cl-extra" "\
150 The remainder of X divided by Y, with the same sign as X.
154 (autoload 'cl-signum
"cl-extra" "\
155 Return 1 if X is positive, -1 if negative, 0 if zero.
159 (autoload 'cl-random
"cl-extra" "\
160 Return a random nonnegative number less than LIM, an integer or float.
161 Optional second arg STATE is a random-state object.
163 \(fn LIM &optional STATE)" nil nil
)
165 (autoload 'cl-make-random-state
"cl-extra" "\
166 Return a copy of random-state STATE, or of the internal state if omitted.
167 If STATE is t, return a new state object seeded from the time of day.
169 \(fn &optional STATE)" nil nil
)
171 (autoload 'cl-random-state-p
"cl-extra" "\
172 Return t if OBJECT is a random-state object.
174 \(fn OBJECT)" nil nil
)
176 (autoload 'cl-float-limits
"cl-extra" "\
177 Initialize the Common Lisp floating-point parameters.
178 This sets the values of: `cl-most-positive-float', `cl-most-negative-float',
179 `cl-least-positive-float', `cl-least-negative-float', `cl-float-epsilon',
180 `cl-float-negative-epsilon', `cl-least-positive-normalized-float', and
181 `cl-least-negative-normalized-float'.
185 (autoload 'cl-subseq
"cl-extra" "\
186 Return the subsequence of SEQ from START to END.
187 If END is omitted, it defaults to the length of the sequence.
188 If START or END is negative, it counts from the end.
190 \(fn SEQ START &optional END)" nil nil
)
192 (autoload 'cl-concatenate
"cl-extra" "\
193 Concatenate, into a sequence of type TYPE, the argument SEQUENCEs.
195 \(fn TYPE SEQUENCE...)" nil nil
)
197 (autoload 'cl-revappend
"cl-extra" "\
198 Equivalent to (append (reverse X) Y).
202 (autoload 'cl-nreconc
"cl-extra" "\
203 Equivalent to (nconc (nreverse X) Y).
207 (autoload 'cl-list-length
"cl-extra" "\
208 Return the length of list X. Return nil if list is circular.
212 (autoload 'cl-tailp
"cl-extra" "\
213 Return true if SUBLIST is a tail of LIST.
215 \(fn SUBLIST LIST)" nil nil
)
217 (autoload 'cl-get
"cl-extra" "\
218 Return the value of SYMBOL's PROPNAME property, or DEFAULT if none.
220 \(fn SYMBOL PROPNAME &optional DEFAULT)" nil nil
)
222 (put 'cl-get
'compiler-macro
#'cl--compiler-macro-get
)
224 (autoload 'cl-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'.
228 \(fn PROPLIST PROPNAME &optional DEFAULT)" nil nil
)
230 (autoload 'cl--set-getf
"cl-extra" "\
233 \(fn PLIST TAG VAL)" nil nil
)
235 (autoload 'cl--do-remf
"cl-extra" "\
238 \(fn PLIST TAG)" nil nil
)
240 (autoload 'cl-remprop
"cl-extra" "\
241 Remove from SYMBOL's plist the property PROPNAME and its value.
243 \(fn SYMBOL PROPNAME)" nil nil
)
245 (autoload 'cl-prettyexpand
"cl-extra" "\
248 \(fn FORM &optional FULL)" nil nil
)
252 ;;;### (autoloads (cl--compiler-macro-adjoin cl-defsubst cl-compiler-macroexpand
253 ;;;;;; cl-define-compiler-macro cl-assert cl-check-type cl-typep
254 ;;;;;; cl-deftype cl-defstruct cl-callf2 cl-callf cl-letf* cl-letf
255 ;;;;;; cl-rotatef cl-shiftf cl-remf cl-psetf cl-declare cl-the cl-locally
256 ;;;;;; cl-multiple-value-setq cl-multiple-value-bind cl-symbol-macrolet
257 ;;;;;; cl-macrolet cl-labels cl-flet* cl-flet cl-progv cl-psetq
258 ;;;;;; cl-do-all-symbols cl-do-symbols cl-dotimes cl-dolist cl-do*
259 ;;;;;; cl-do cl-loop cl-return-from cl-return cl-block cl-etypecase
260 ;;;;;; cl-typecase cl-ecase cl-case cl-load-time-value cl-eval-when
261 ;;;;;; cl-destructuring-bind cl-function cl-defmacro cl-defun cl-gentemp
262 ;;;;;; cl-gensym cl--compiler-macro-cXXr cl--compiler-macro-list*)
263 ;;;;;; "cl-macs" "cl-macs.el" "6951d080daefb5194b1d21fe9b2deae4")
264 ;;; Generated autoloads from cl-macs.el
266 (autoload 'cl--compiler-macro-list
* "cl-macs" "\
269 \(fn FORM ARG &rest OTHERS)" nil nil
)
271 (autoload 'cl--compiler-macro-cXXr
"cl-macs" "\
274 \(fn FORM X)" nil nil
)
276 (autoload 'cl-gensym
"cl-macs" "\
277 Generate a new uninterned symbol.
278 The name is made by appending a number to PREFIX, default \"G\".
280 \(fn &optional PREFIX)" nil nil
)
282 (autoload 'cl-gentemp
"cl-macs" "\
283 Generate a new interned symbol with a unique name.
284 The name is made by appending a number to PREFIX, default \"G\".
286 \(fn &optional PREFIX)" nil nil
)
288 (autoload 'cl-defun
"cl-macs" "\
289 Define NAME as a function.
290 Like normal `defun', except ARGLIST allows full Common Lisp conventions,
291 and BODY is implicitly surrounded by (cl-block NAME ...).
293 \(fn NAME ARGLIST [DOCSTRING] BODY...)" nil t
)
295 (put 'cl-defun
'doc-string-elt
'3)
297 (put 'cl-defun
'lisp-indent-function
'2)
299 (autoload 'cl-defmacro
"cl-macs" "\
300 Define NAME as a macro.
301 Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
302 and BODY is implicitly surrounded by (cl-block NAME ...).
304 \(fn NAME ARGLIST [DOCSTRING] BODY...)" nil t
)
306 (put 'cl-defmacro
'doc-string-elt
'3)
308 (put 'cl-defmacro
'lisp-indent-function
'2)
310 (autoload 'cl-function
"cl-macs" "\
311 Introduce a function.
312 Like normal `function', except that if argument is a lambda form,
313 its argument list allows full Common Lisp conventions.
317 (autoload 'cl-destructuring-bind
"cl-macs" "\
320 \(fn ARGS EXPR &rest BODY)" nil t
)
322 (put 'cl-destructuring-bind
'lisp-indent-function
'2)
324 (autoload 'cl-eval-when
"cl-macs" "\
325 Control when BODY is evaluated.
326 If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
327 If `load' is in WHEN, BODY is evaluated when loaded after top-level compile.
328 If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level.
330 \(fn (WHEN...) BODY...)" nil t
)
332 (put 'cl-eval-when
'lisp-indent-function
'1)
334 (autoload 'cl-load-time-value
"cl-macs" "\
335 Like `progn', but evaluates the body at load time.
336 The result of the body appears to the compiler as a quoted constant.
338 \(fn FORM &optional READ-ONLY)" nil t
)
340 (autoload 'cl-case
"cl-macs" "\
341 Eval EXPR and choose among clauses on that value.
342 Each clause looks like (KEYLIST BODY...). EXPR is evaluated and compared
343 against each key in each KEYLIST; the corresponding BODY is evaluated.
344 If no clause succeeds, cl-case returns nil. A single atom may be used in
345 place of a KEYLIST of one atom. A KEYLIST of t or `otherwise' is
346 allowed only in the final clause, and matches if no other keys match.
347 Key values are compared by `eql'.
349 \(fn EXPR (KEYLIST BODY...)...)" nil t
)
351 (put 'cl-case
'lisp-indent-function
'1)
353 (autoload 'cl-ecase
"cl-macs" "\
354 Like `cl-case', but error if no case fits.
355 `otherwise'-clauses are not allowed.
357 \(fn EXPR (KEYLIST BODY...)...)" nil t
)
359 (put 'cl-ecase
'lisp-indent-function
'1)
361 (autoload 'cl-typecase
"cl-macs" "\
362 Evals EXPR, chooses among clauses on that value.
363 Each clause looks like (TYPE BODY...). EXPR is evaluated and, if it
364 satisfies TYPE, the corresponding BODY is evaluated. If no clause succeeds,
365 cl-typecase returns nil. A TYPE of t or `otherwise' is allowed only in the
366 final clause, and matches if no other keys match.
368 \(fn EXPR (TYPE BODY...)...)" nil t
)
370 (put 'cl-typecase
'lisp-indent-function
'1)
372 (autoload 'cl-etypecase
"cl-macs" "\
373 Like `cl-typecase', but error if no case fits.
374 `otherwise'-clauses are not allowed.
376 \(fn EXPR (TYPE BODY...)...)" nil t
)
378 (put 'cl-etypecase
'lisp-indent-function
'1)
380 (autoload 'cl-block
"cl-macs" "\
381 Define a lexically-scoped block named NAME.
382 NAME may be any symbol. Code inside the BODY forms can call `cl-return-from'
383 to jump prematurely out of the block. This differs from `catch' and `throw'
384 in two respects: First, the NAME is an unevaluated symbol rather than a
385 quoted symbol or other form; and second, NAME is lexically rather than
386 dynamically scoped: Only references to it within BODY will work. These
387 references may appear inside macro expansions, but not inside functions
390 \(fn NAME &rest BODY)" nil t
)
392 (put 'cl-block
'lisp-indent-function
'1)
394 (autoload 'cl-return
"cl-macs" "\
395 Return from the block named nil.
396 This is equivalent to `(cl-return-from nil RESULT)'.
398 \(fn &optional RESULT)" nil t
)
400 (autoload 'cl-return-from
"cl-macs" "\
401 Return from the block named NAME.
402 This jumps out to the innermost enclosing `(cl-block NAME ...)' form,
403 returning RESULT from that form (or nil if RESULT is omitted).
404 This is compatible with Common Lisp, but note that `defun' and
405 `defmacro' do not create implicit blocks as they do in Common Lisp.
407 \(fn NAME &optional RESULT)" nil t
)
409 (put 'cl-return-from
'lisp-indent-function
'1)
411 (autoload 'cl-loop
"cl-macs" "\
412 The Common Lisp `cl-loop' macro.
414 for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM,
415 for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR,
416 for VAR across ARRAY, repeat NUM, with VAR = INIT, while COND, until COND,
417 always COND, never COND, thereis COND, collect EXPR into VAR,
418 append EXPR into VAR, nconc EXPR into VAR, sum EXPR into VAR,
419 count EXPR into VAR, maximize EXPR into VAR, minimize EXPR into VAR,
420 if COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
421 unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
422 do EXPRS..., initially EXPRS..., finally EXPRS..., return EXPR,
423 finally return EXPR, named NAME.
425 \(fn CLAUSE...)" nil t
)
427 (autoload 'cl-do
"cl-macs" "\
428 The Common Lisp `cl-do' loop.
430 \(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil t
)
432 (put 'cl-do
'lisp-indent-function
'2)
434 (autoload 'cl-do
* "cl-macs" "\
435 The Common Lisp `cl-do*' loop.
437 \(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil t
)
439 (put 'cl-do
* 'lisp-indent-function
'2)
441 (autoload 'cl-dolist
"cl-macs" "\
443 Evaluate BODY with VAR bound to each `car' from LIST, in turn.
444 Then evaluate RESULT to get return value, default nil.
445 An implicit nil block is established around the loop.
447 \(fn (VAR LIST [RESULT]) BODY...)" nil t
)
449 (put 'cl-dolist
'lisp-indent-function
'1)
451 (autoload 'cl-dotimes
"cl-macs" "\
452 Loop a certain number of times.
453 Evaluate BODY with VAR bound to successive integers from 0, inclusive,
454 to COUNT, exclusive. Then evaluate RESULT to get return value, default
457 \(fn (VAR COUNT [RESULT]) BODY...)" nil t
)
459 (put 'cl-dotimes
'lisp-indent-function
'1)
461 (autoload 'cl-do-symbols
"cl-macs" "\
462 Loop over all symbols.
463 Evaluate BODY with VAR bound to each interned symbol, or to each symbol
466 \(fn (VAR [OBARRAY [RESULT]]) BODY...)" nil t
)
468 (put 'cl-do-symbols
'lisp-indent-function
'1)
470 (autoload 'cl-do-all-symbols
"cl-macs" "\
473 \(fn SPEC &rest BODY)" nil t
)
475 (put 'cl-do-all-symbols
'lisp-indent-function
'1)
477 (autoload 'cl-psetq
"cl-macs" "\
478 Set SYMs to the values VALs in parallel.
479 This is like `setq', except that all VAL forms are evaluated (in order)
480 before assigning any symbols SYM to the corresponding values.
482 \(fn SYM VAL SYM VAL ...)" nil t
)
484 (autoload 'cl-progv
"cl-macs" "\
485 Bind SYMBOLS to VALUES dynamically in BODY.
486 The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
487 Each symbol in the first list is bound to the corresponding value in the
488 second list (or made unbound if VALUES is shorter than SYMBOLS); then the
489 BODY forms are executed and their result is returned. This is much like
490 a `let' form, except that the list of symbols can be computed at run-time.
492 \(fn SYMBOLS VALUES &rest BODY)" nil t
)
494 (put 'cl-progv
'lisp-indent-function
'2)
496 (autoload 'cl-flet
"cl-macs" "\
497 Make temporary function definitions.
498 Like `cl-labels' but the definitions are not recursive.
500 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil t
)
502 (put 'cl-flet
'lisp-indent-function
'1)
504 (autoload 'cl-flet
* "cl-macs" "\
505 Make temporary function definitions.
506 Like `cl-flet' but the definitions can refer to previous ones.
508 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil t
)
510 (put 'cl-flet
* 'lisp-indent-function
'1)
512 (autoload 'cl-labels
"cl-macs" "\
513 Make temporary function bindings.
514 The bindings can be recursive and the scoping is lexical, but capturing them
515 in closures will only work if `lexical-binding' is in use.
517 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil t
)
519 (put 'cl-labels
'lisp-indent-function
'1)
521 (autoload 'cl-macrolet
"cl-macs" "\
522 Make temporary macro definitions.
523 This is like `cl-flet', but for macros instead of functions.
525 \(fn ((NAME ARGLIST BODY...) ...) FORM...)" nil t
)
527 (put 'cl-macrolet
'lisp-indent-function
'1)
529 (autoload 'cl-symbol-macrolet
"cl-macs" "\
530 Make symbol macro definitions.
531 Within the body FORMs, references to the variable NAME will be replaced
532 by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...).
534 \(fn ((NAME EXPANSION) ...) FORM...)" nil t
)
536 (put 'cl-symbol-macrolet
'lisp-indent-function
'1)
538 (autoload 'cl-multiple-value-bind
"cl-macs" "\
539 Collect multiple return values.
540 FORM must return a list; the BODY is then executed with the first N elements
541 of this list bound (`let'-style) to each of the symbols SYM in turn. This
542 is analogous to the Common Lisp `cl-multiple-value-bind' macro, using lists to
543 simulate true multiple return values. For compatibility, (cl-values A B C) is
544 a synonym for (list A B C).
546 \(fn (SYM...) FORM BODY)" nil t
)
548 (put 'cl-multiple-value-bind
'lisp-indent-function
'2)
550 (autoload 'cl-multiple-value-setq
"cl-macs" "\
551 Collect multiple return values.
552 FORM must return a list; the first N elements of this list are stored in
553 each of the symbols SYM in turn. This is analogous to the Common Lisp
554 `cl-multiple-value-setq' macro, using lists to simulate true multiple return
555 values. For compatibility, (cl-values A B C) is a synonym for (list A B C).
557 \(fn (SYM...) FORM)" nil t
)
559 (put 'cl-multiple-value-setq
'lisp-indent-function
'1)
561 (autoload 'cl-locally
"cl-macs" "\
564 \(fn &rest BODY)" nil t
)
566 (autoload 'cl-the
"cl-macs" "\
569 \(fn TYPE FORM)" nil t
)
571 (put 'cl-the
'lisp-indent-function
'1)
573 (autoload 'cl-declare
"cl-macs" "\
574 Declare SPECS about the current function while compiling.
577 (cl-declare (warn 0))
579 will turn off byte-compile warnings in the function.
580 See Info node `(cl)Declarations' for details.
582 \(fn &rest SPECS)" nil t
)
584 (autoload 'cl-psetf
"cl-macs" "\
585 Set PLACEs to the values VALs in parallel.
586 This is like `setf', except that all VAL forms are evaluated (in order)
587 before assigning any PLACEs to the corresponding values.
589 \(fn PLACE VAL PLACE VAL ...)" nil t
)
591 (autoload 'cl-remf
"cl-macs" "\
592 Remove TAG from property list PLACE.
593 PLACE may be a symbol, or any generalized variable allowed by `setf'.
594 The form returns true if TAG was found and removed, nil otherwise.
596 \(fn PLACE TAG)" nil t
)
598 (autoload 'cl-shiftf
"cl-macs" "\
599 Shift left among PLACEs.
600 Example: (cl-shiftf A B C) sets A to B, B to C, and returns the old A.
601 Each PLACE may be a symbol, or any generalized variable allowed by `setf'.
603 \(fn PLACE... VAL)" nil t
)
605 (autoload 'cl-rotatef
"cl-macs" "\
606 Rotate left among PLACEs.
607 Example: (cl-rotatef A B C) sets A to B, B to C, and C to A. It returns nil.
608 Each PLACE may be a symbol, or any generalized variable allowed by `setf'.
610 \(fn PLACE...)" nil t
)
612 (autoload 'cl-letf
"cl-macs" "\
613 Temporarily bind to PLACEs.
614 This is the analogue of `let', but with generalized variables (in the
615 sense of `setf') for the PLACEs. Each PLACE is set to the corresponding
616 VALUE, then the BODY forms are executed. On exit, either normally or
617 because of a `throw' or error, the PLACEs are set back to their original
618 values. Note that this macro is *not* available in Common Lisp.
619 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
620 the PLACE is not modified before executing BODY.
622 \(fn ((PLACE VALUE) ...) BODY...)" nil t
)
624 (put 'cl-letf
'lisp-indent-function
'1)
626 (autoload 'cl-letf
* "cl-macs" "\
627 Temporarily bind to PLACEs.
628 Like `cl-letf' but where the bindings are performed one at a time,
629 rather than all at the end (i.e. like `let*' rather than like `let').
631 \(fn BINDINGS &rest BODY)" nil t
)
633 (put 'cl-letf
* 'lisp-indent-function
'1)
635 (autoload 'cl-callf
"cl-macs" "\
636 Set PLACE to (FUNC PLACE ARGS...).
637 FUNC should be an unquoted function name. PLACE may be a symbol,
638 or any generalized variable allowed by `setf'.
640 \(fn FUNC PLACE &rest ARGS)" nil t
)
642 (put 'cl-callf
'lisp-indent-function
'2)
644 (autoload 'cl-callf2
"cl-macs" "\
645 Set PLACE to (FUNC ARG1 PLACE ARGS...).
646 Like `cl-callf', but PLACE is the second argument of FUNC, not the first.
648 \(fn FUNC ARG1 PLACE ARGS...)" nil t
)
650 (put 'cl-callf2
'lisp-indent-function
'3)
652 (autoload 'cl-defstruct
"cl-macs" "\
653 Define a struct type.
654 This macro defines a new data type called NAME that stores data
655 in SLOTs. It defines a `make-NAME' constructor, a `copy-NAME'
656 copier, a `NAME-p' predicate, and slot accessors named `NAME-SLOT'.
657 You can use the accessors to set the corresponding slots, via `setf'.
659 NAME may instead take the form (NAME OPTIONS...), where each
660 OPTION is either a single keyword or (KEYWORD VALUE) where
661 KEYWORD can be one of :conc-name, :constructor, :copier, :predicate,
662 :type, :named, :initial-offset, :print-function, or :include.
664 Each SLOT may instead take the form (SLOT SLOT-OPTS...), where
665 SLOT-OPTS are keyword-value pairs for that slot. Currently, only
666 one keyword is supported, `:read-only'. If this has a non-nil
667 value, that slot cannot be set via `setf'.
669 \(fn NAME SLOTS...)" nil t
)
671 (put 'cl-defstruct
'doc-string-elt
'2)
673 (put 'cl-defstruct
'lisp-indent-function
'1)
675 (autoload 'cl-deftype
"cl-macs" "\
676 Define NAME as a new data type.
677 The type name can then be used in `cl-typecase', `cl-check-type', etc.
679 \(fn NAME ARGLIST &rest BODY)" nil t
)
681 (put 'cl-deftype
'doc-string-elt
'3)
683 (autoload 'cl-typep
"cl-macs" "\
684 Check that OBJECT is of type TYPE.
685 TYPE is a Common Lisp-style type specifier.
687 \(fn OBJECT TYPE)" nil nil
)
689 (autoload 'cl-check-type
"cl-macs" "\
690 Verify that FORM is of type TYPE; signal an error if not.
691 STRING is an optional description of the desired type.
693 \(fn FORM TYPE &optional STRING)" nil t
)
695 (autoload 'cl-assert
"cl-macs" "\
696 Verify that FORM returns non-nil; signal an error if not.
697 Second arg SHOW-ARGS means to include arguments of FORM in message.
698 Other args STRING and ARGS... are arguments to be passed to `error'.
699 They are not evaluated unless the assertion fails. If STRING is
700 omitted, a default message listing FORM itself is used.
702 \(fn FORM &optional SHOW-ARGS STRING &rest ARGS)" nil t
)
704 (autoload 'cl-define-compiler-macro
"cl-macs" "\
705 Define a compiler-only macro.
706 This is like `defmacro', but macro expansion occurs only if the call to
707 FUNC is compiled (i.e., not interpreted). Compiler macros should be used
708 for optimizing the way calls to FUNC are compiled; the form returned by
709 BODY should do the same thing as a call to the normal function called
710 FUNC, though possibly more efficiently. Note that, like regular macros,
711 compiler macros are expanded repeatedly until no further expansions are
712 possible. Unlike regular macros, BODY can decide to \"punt\" and leave the
713 original function call alone by declaring an initial `&whole foo' parameter
714 and then returning foo.
716 \(fn FUNC ARGS &rest BODY)" nil t
)
718 (autoload 'cl-compiler-macroexpand
"cl-macs" "\
723 (autoload 'cl-defsubst
"cl-macs" "\
724 Define NAME as a function.
725 Like `defun', except the function is automatically declared `inline',
726 ARGLIST allows full Common Lisp conventions, and BODY is implicitly
727 surrounded by (cl-block NAME ...).
729 \(fn NAME ARGLIST [DOCSTRING] BODY...)" nil t
)
731 (put 'cl-defsubst
'lisp-indent-function
'2)
733 (autoload 'cl--compiler-macro-adjoin
"cl-macs" "\
736 \(fn FORM A LIST &rest KEYS)" nil nil
)
740 ;;;### (autoloads (cl-tree-equal cl-nsublis cl-sublis cl-nsubst-if-not
741 ;;;;;; cl-nsubst-if cl-nsubst cl-subst-if-not cl-subst-if cl-subsetp
742 ;;;;;; cl-nset-exclusive-or cl-set-exclusive-or cl-nset-difference
743 ;;;;;; cl-set-difference cl-nintersection cl-intersection cl-nunion
744 ;;;;;; cl-union cl-rassoc-if-not cl-rassoc-if cl-rassoc cl-assoc-if-not
745 ;;;;;; cl-assoc-if cl-assoc cl--adjoin cl-member-if-not cl-member-if
746 ;;;;;; cl-member cl-merge cl-stable-sort cl-sort cl-search cl-mismatch
747 ;;;;;; cl-count-if-not cl-count-if cl-count cl-position-if-not cl-position-if
748 ;;;;;; cl-position cl-find-if-not cl-find-if cl-find cl-nsubstitute-if-not
749 ;;;;;; cl-nsubstitute-if cl-nsubstitute cl-substitute-if-not cl-substitute-if
750 ;;;;;; cl-substitute cl-delete-duplicates cl-remove-duplicates cl-delete-if-not
751 ;;;;;; cl-delete-if cl-delete cl-remove-if-not cl-remove-if cl-remove
752 ;;;;;; cl-replace cl-fill cl-reduce) "cl-seq" "cl-seq.el" "4c1e1191e82dc8d5449a5ec4d59efc10")
753 ;;; Generated autoloads from cl-seq.el
755 (autoload 'cl-reduce
"cl-seq" "\
756 Reduce two-argument FUNCTION across SEQ.
758 Keywords supported: :start :end :from-end :initial-value :key
760 \(fn FUNCTION SEQ [KEYWORD VALUE]...)" nil nil
)
762 (autoload 'cl-fill
"cl-seq" "\
763 Fill the elements of SEQ with ITEM.
765 Keywords supported: :start :end
767 \(fn SEQ ITEM [KEYWORD VALUE]...)" nil nil
)
769 (autoload 'cl-replace
"cl-seq" "\
770 Replace the elements of SEQ1 with the elements of SEQ2.
771 SEQ1 is destructively modified, then returned.
773 Keywords supported: :start1 :end1 :start2 :end2
775 \(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil
)
777 (autoload 'cl-remove
"cl-seq" "\
778 Remove all occurrences of ITEM in SEQ.
779 This is a non-destructive function; it makes a copy of SEQ if necessary
780 to avoid corrupting the original SEQ.
782 Keywords supported: :test :test-not :key :count :start :end :from-end
784 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil
)
786 (autoload 'cl-remove-if
"cl-seq" "\
787 Remove all items satisfying PREDICATE in SEQ.
788 This is a non-destructive function; it makes a copy of SEQ if necessary
789 to avoid corrupting the original SEQ.
791 Keywords supported: :key :count :start :end :from-end
793 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
795 (autoload 'cl-remove-if-not
"cl-seq" "\
796 Remove all items not satisfying PREDICATE in SEQ.
797 This is a non-destructive function; it makes a copy of SEQ if necessary
798 to avoid corrupting the original SEQ.
800 Keywords supported: :key :count :start :end :from-end
802 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
804 (autoload 'cl-delete
"cl-seq" "\
805 Remove all occurrences of ITEM in SEQ.
806 This is a destructive function; it reuses the storage of SEQ whenever possible.
808 Keywords supported: :test :test-not :key :count :start :end :from-end
810 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil
)
812 (autoload 'cl-delete-if
"cl-seq" "\
813 Remove all items satisfying PREDICATE in SEQ.
814 This is a destructive function; it reuses the storage of SEQ whenever possible.
816 Keywords supported: :key :count :start :end :from-end
818 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
820 (autoload 'cl-delete-if-not
"cl-seq" "\
821 Remove all items not satisfying PREDICATE in SEQ.
822 This is a destructive function; it reuses the storage of SEQ whenever possible.
824 Keywords supported: :key :count :start :end :from-end
826 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
828 (autoload 'cl-remove-duplicates
"cl-seq" "\
829 Return a copy of SEQ with all duplicate elements removed.
831 Keywords supported: :test :test-not :key :start :end :from-end
833 \(fn SEQ [KEYWORD VALUE]...)" nil nil
)
835 (autoload 'cl-delete-duplicates
"cl-seq" "\
836 Remove all duplicate elements from SEQ (destructively).
838 Keywords supported: :test :test-not :key :start :end :from-end
840 \(fn SEQ [KEYWORD VALUE]...)" nil nil
)
842 (autoload 'cl-substitute
"cl-seq" "\
843 Substitute NEW for OLD in SEQ.
844 This is a non-destructive function; it makes a copy of SEQ if necessary
845 to avoid corrupting the original SEQ.
847 Keywords supported: :test :test-not :key :count :start :end :from-end
849 \(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil
)
851 (autoload 'cl-substitute-if
"cl-seq" "\
852 Substitute NEW for all items satisfying PREDICATE in SEQ.
853 This is a non-destructive function; it makes a copy of SEQ if necessary
854 to avoid corrupting the original SEQ.
856 Keywords supported: :key :count :start :end :from-end
858 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
860 (autoload 'cl-substitute-if-not
"cl-seq" "\
861 Substitute NEW for all items not satisfying PREDICATE in SEQ.
862 This is a non-destructive function; it makes a copy of SEQ if necessary
863 to avoid corrupting the original SEQ.
865 Keywords supported: :key :count :start :end :from-end
867 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
869 (autoload 'cl-nsubstitute
"cl-seq" "\
870 Substitute NEW for OLD in SEQ.
871 This is a destructive function; it reuses the storage of SEQ whenever possible.
873 Keywords supported: :test :test-not :key :count :start :end :from-end
875 \(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil
)
877 (autoload 'cl-nsubstitute-if
"cl-seq" "\
878 Substitute NEW for all items satisfying PREDICATE in SEQ.
879 This is a destructive function; it reuses the storage of SEQ whenever possible.
881 Keywords supported: :key :count :start :end :from-end
883 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
885 (autoload 'cl-nsubstitute-if-not
"cl-seq" "\
886 Substitute NEW for all items not satisfying PREDICATE in SEQ.
887 This is a destructive function; it reuses the storage of SEQ whenever possible.
889 Keywords supported: :key :count :start :end :from-end
891 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
893 (autoload 'cl-find
"cl-seq" "\
894 Find the first occurrence of ITEM in SEQ.
895 Return the matching ITEM, or nil if not found.
897 Keywords supported: :test :test-not :key :start :end :from-end
899 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil
)
901 (autoload 'cl-find-if
"cl-seq" "\
902 Find the first item satisfying PREDICATE in SEQ.
903 Return the matching item, or nil if not found.
905 Keywords supported: :key :start :end :from-end
907 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
909 (autoload 'cl-find-if-not
"cl-seq" "\
910 Find the first item not satisfying PREDICATE in SEQ.
911 Return the matching item, or nil if not found.
913 Keywords supported: :key :start :end :from-end
915 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
917 (autoload 'cl-position
"cl-seq" "\
918 Find the first occurrence of ITEM in SEQ.
919 Return the index of the matching item, or nil if not found.
921 Keywords supported: :test :test-not :key :start :end :from-end
923 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil
)
925 (autoload 'cl-position-if
"cl-seq" "\
926 Find the first item satisfying PREDICATE in SEQ.
927 Return the index of the matching item, or nil if not found.
929 Keywords supported: :key :start :end :from-end
931 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
933 (autoload 'cl-position-if-not
"cl-seq" "\
934 Find the first item not satisfying PREDICATE in SEQ.
935 Return the index of the matching item, or nil if not found.
937 Keywords supported: :key :start :end :from-end
939 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
941 (autoload 'cl-count
"cl-seq" "\
942 Count the number of occurrences of ITEM in SEQ.
944 Keywords supported: :test :test-not :key :start :end
946 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil
)
948 (autoload 'cl-count-if
"cl-seq" "\
949 Count the number of items satisfying PREDICATE in SEQ.
951 Keywords supported: :key :start :end
953 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
955 (autoload 'cl-count-if-not
"cl-seq" "\
956 Count the number of items not satisfying PREDICATE in SEQ.
958 Keywords supported: :key :start :end
960 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
962 (autoload 'cl-mismatch
"cl-seq" "\
963 Compare SEQ1 with SEQ2, return index of first mismatching element.
964 Return nil if the sequences match. If one sequence is a prefix of the
965 other, the return value indicates the end of the shorter sequence.
967 Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end
969 \(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil
)
971 (autoload 'cl-search
"cl-seq" "\
972 Search for SEQ1 as a subsequence of SEQ2.
973 Return the index of the leftmost element of the first match found;
974 return nil if there are no matches.
976 Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end
978 \(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil
)
980 (autoload 'cl-sort
"cl-seq" "\
981 Sort the argument SEQ according to PREDICATE.
982 This is a destructive function; it reuses the storage of SEQ if possible.
984 Keywords supported: :key
986 \(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil
)
988 (autoload 'cl-stable-sort
"cl-seq" "\
989 Sort the argument SEQ stably according to PREDICATE.
990 This is a destructive function; it reuses the storage of SEQ if possible.
992 Keywords supported: :key
994 \(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil
)
996 (autoload 'cl-merge
"cl-seq" "\
997 Destructively merge the two sequences to produce a new sequence.
998 TYPE is the sequence type to return, SEQ1 and SEQ2 are the two argument
999 sequences, and PREDICATE is a `less-than' predicate on the elements.
1001 Keywords supported: :key
1003 \(fn TYPE SEQ1 SEQ2 PREDICATE [KEYWORD VALUE]...)" nil nil
)
1005 (autoload 'cl-member
"cl-seq" "\
1006 Find the first occurrence of ITEM in LIST.
1007 Return the sublist of LIST whose car is ITEM.
1009 Keywords supported: :test :test-not :key
1011 \(fn ITEM LIST [KEYWORD VALUE]...)" nil nil
)
1013 (put 'cl-member
'compiler-macro
#'cl--compiler-macro-member
)
1015 (autoload 'cl-member-if
"cl-seq" "\
1016 Find the first item satisfying PREDICATE in LIST.
1017 Return the sublist of LIST whose car matches.
1019 Keywords supported: :key
1021 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1023 (autoload 'cl-member-if-not
"cl-seq" "\
1024 Find the first item not satisfying PREDICATE in LIST.
1025 Return the sublist of LIST whose car matches.
1027 Keywords supported: :key
1029 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1031 (autoload 'cl--adjoin
"cl-seq" "\
1034 \(fn CL-ITEM CL-LIST &rest CL-KEYS)" nil nil
)
1036 (autoload 'cl-assoc
"cl-seq" "\
1037 Find the first item whose car matches ITEM in LIST.
1039 Keywords supported: :test :test-not :key
1041 \(fn ITEM LIST [KEYWORD VALUE]...)" nil nil
)
1043 (put 'cl-assoc
'compiler-macro
#'cl--compiler-macro-assoc
)
1045 (autoload 'cl-assoc-if
"cl-seq" "\
1046 Find the first item whose car satisfies PREDICATE in LIST.
1048 Keywords supported: :key
1050 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1052 (autoload 'cl-assoc-if-not
"cl-seq" "\
1053 Find the first item whose car does not satisfy PREDICATE in LIST.
1055 Keywords supported: :key
1057 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1059 (autoload 'cl-rassoc
"cl-seq" "\
1060 Find the first item whose cdr matches ITEM in LIST.
1062 Keywords supported: :test :test-not :key
1064 \(fn ITEM LIST [KEYWORD VALUE]...)" nil nil
)
1066 (autoload 'cl-rassoc-if
"cl-seq" "\
1067 Find the first item whose cdr satisfies PREDICATE in LIST.
1069 Keywords supported: :key
1071 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1073 (autoload 'cl-rassoc-if-not
"cl-seq" "\
1074 Find the first item whose cdr does not satisfy PREDICATE in LIST.
1076 Keywords supported: :key
1078 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1080 (autoload 'cl-union
"cl-seq" "\
1081 Combine LIST1 and LIST2 using a set-union operation.
1082 The resulting list contains all items that appear in either LIST1 or LIST2.
1083 This is a non-destructive function; it makes a copy of the data if necessary
1084 to avoid corrupting the original LIST1 and LIST2.
1086 Keywords supported: :test :test-not :key
1088 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1090 (autoload 'cl-nunion
"cl-seq" "\
1091 Combine LIST1 and LIST2 using a set-union operation.
1092 The resulting list contains all items that appear in either LIST1 or LIST2.
1093 This is a destructive function; it reuses the storage of LIST1 and LIST2
1096 Keywords supported: :test :test-not :key
1098 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1100 (autoload 'cl-intersection
"cl-seq" "\
1101 Combine LIST1 and LIST2 using a set-intersection operation.
1102 The resulting list contains all items that appear in both LIST1 and LIST2.
1103 This is a non-destructive function; it makes a copy of the data if necessary
1104 to avoid corrupting the original LIST1 and LIST2.
1106 Keywords supported: :test :test-not :key
1108 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1110 (autoload 'cl-nintersection
"cl-seq" "\
1111 Combine LIST1 and LIST2 using a set-intersection operation.
1112 The resulting list contains all items that appear in both LIST1 and LIST2.
1113 This is a destructive function; it reuses the storage of LIST1 and LIST2
1116 Keywords supported: :test :test-not :key
1118 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1120 (autoload 'cl-set-difference
"cl-seq" "\
1121 Combine LIST1 and LIST2 using a set-difference operation.
1122 The resulting list contains all items that appear in LIST1 but not LIST2.
1123 This is a non-destructive function; it makes a copy of the data if necessary
1124 to avoid corrupting the original LIST1 and LIST2.
1126 Keywords supported: :test :test-not :key
1128 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1130 (autoload 'cl-nset-difference
"cl-seq" "\
1131 Combine LIST1 and LIST2 using a set-difference operation.
1132 The resulting list contains all items that appear in LIST1 but not LIST2.
1133 This is a destructive function; it reuses the storage of LIST1 and LIST2
1136 Keywords supported: :test :test-not :key
1138 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1140 (autoload 'cl-set-exclusive-or
"cl-seq" "\
1141 Combine LIST1 and LIST2 using a set-exclusive-or operation.
1142 The resulting list contains all items appearing in exactly one of LIST1, LIST2.
1143 This is a non-destructive function; it makes a copy of the data if necessary
1144 to avoid corrupting the original LIST1 and LIST2.
1146 Keywords supported: :test :test-not :key
1148 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1150 (autoload 'cl-nset-exclusive-or
"cl-seq" "\
1151 Combine LIST1 and LIST2 using a set-exclusive-or operation.
1152 The resulting list contains all items appearing in exactly one of LIST1, LIST2.
1153 This is a destructive function; it reuses the storage of LIST1 and LIST2
1156 Keywords supported: :test :test-not :key
1158 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1160 (autoload 'cl-subsetp
"cl-seq" "\
1161 Return true if LIST1 is a subset of LIST2.
1162 I.e., if every element of LIST1 also appears in LIST2.
1164 Keywords supported: :test :test-not :key
1166 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1168 (autoload 'cl-subst-if
"cl-seq" "\
1169 Substitute NEW for elements matching PREDICATE in TREE (non-destructively).
1170 Return a copy of TREE with all matching elements replaced by NEW.
1172 Keywords supported: :key
1174 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil
)
1176 (autoload 'cl-subst-if-not
"cl-seq" "\
1177 Substitute NEW for elts not matching PREDICATE in TREE (non-destructively).
1178 Return a copy of TREE with all non-matching elements replaced by NEW.
1180 Keywords supported: :key
1182 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil
)
1184 (autoload 'cl-nsubst
"cl-seq" "\
1185 Substitute NEW for OLD everywhere in TREE (destructively).
1186 Any element of TREE which is `eql' to OLD is changed to NEW (via a call
1189 Keywords supported: :test :test-not :key
1191 \(fn NEW OLD TREE [KEYWORD VALUE]...)" nil nil
)
1193 (autoload 'cl-nsubst-if
"cl-seq" "\
1194 Substitute NEW for elements matching PREDICATE in TREE (destructively).
1195 Any element of TREE which matches is changed to NEW (via a call to `setcar').
1197 Keywords supported: :key
1199 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil
)
1201 (autoload 'cl-nsubst-if-not
"cl-seq" "\
1202 Substitute NEW for elements not matching PREDICATE in TREE (destructively).
1203 Any element of TREE which matches is changed to NEW (via a call to `setcar').
1205 Keywords supported: :key
1207 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil
)
1209 (autoload 'cl-sublis
"cl-seq" "\
1210 Perform substitutions indicated by ALIST in TREE (non-destructively).
1211 Return a copy of TREE with all matching elements replaced.
1213 Keywords supported: :test :test-not :key
1215 \(fn ALIST TREE [KEYWORD VALUE]...)" nil nil
)
1217 (autoload 'cl-nsublis
"cl-seq" "\
1218 Perform substitutions indicated by ALIST in TREE (destructively).
1219 Any matching element of TREE is changed via a call to `setcar'.
1221 Keywords supported: :test :test-not :key
1223 \(fn ALIST TREE [KEYWORD VALUE]...)" nil nil
)
1225 (autoload 'cl-tree-equal
"cl-seq" "\
1226 Return t if trees TREE1 and TREE2 have `eql' leaves.
1227 Atoms are compared by `eql'; cons cells are compared recursively.
1229 Keywords supported: :test :test-not :key
1231 \(fn TREE1 TREE2 [KEYWORD VALUE]...)" nil nil
)
1236 ;; version-control: never
1237 ;; no-byte-compile: t
1238 ;; no-update-autoloads: t
1241 ;;; cl-loaddefs.el ends here