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" "26339d9571f9485bf34fa6d2ae38fc84")
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 `*random-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" "\
187 (autoload '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.
192 \(fn SEQ START &optional END)" nil nil
)
194 (autoload 'concatenate
"cl-extra" "\
195 Concatenate, into a sequence of type TYPE, the argument SEQUENCEs.
197 \(fn TYPE SEQUENCE...)" nil nil
)
199 (autoload 'revappend
"cl-extra" "\
200 Equivalent to (append (reverse X) Y).
204 (autoload 'nreconc
"cl-extra" "\
205 Equivalent to (nconc (nreverse X) Y).
209 (autoload 'list-length
"cl-extra" "\
210 Return the length of list X. Return nil if list is circular.
214 (autoload 'tailp
"cl-extra" "\
215 Return true if SUBLIST is a tail of LIST.
217 \(fn SUBLIST LIST)" nil nil
)
219 (autoload 'get
* "cl-extra" "\
220 Return the value of SYMBOL's PROPNAME property, or DEFAULT if none.
222 \(fn SYMBOL PROPNAME &optional DEFAULT)" nil nil
)
224 (autoload '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 (defalias 'remprop
'cl-remprop
)
247 (defalias 'cl-gethash
'gethash
)
249 (defalias 'cl-puthash
'puthash
)
251 (defalias 'cl-remhash
'remhash
)
253 (defalias 'cl-clrhash
'clrhash
)
255 (defalias 'cl-maphash
'maphash
)
257 (defalias 'cl-make-hash-table
'make-hash-table
)
259 (defalias 'cl-hash-table-p
'hash-table-p
)
261 (defalias 'cl-hash-table-count
'hash-table-count
)
263 (autoload '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.
267 \(fn FORM &optional ENV)" nil nil
)
269 (autoload 'cl-prettyexpand
"cl-extra" "\
272 \(fn FORM &optional FULL)" nil nil
)
276 ;;;### (autoloads (defsubst* compiler-macroexpand define-compiler-macro
277 ;;;;;; assert check-type typep deftype 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-macs" "cl-macs.el" "2261724608e3223036b863d214f7dc0c")
286 ;;; Generated autoloads from cl-macs.el
288 (autoload 'gensym
"cl-macs" "\
289 Generate a new uninterned symbol.
290 The name is made by appending a number to PREFIX, default \"G\".
292 \(fn &optional PREFIX)" nil nil
)
294 (autoload 'gentemp
"cl-macs" "\
295 Generate a new interned symbol with a unique name.
296 The name is made by appending a number to PREFIX, default \"G\".
298 \(fn &optional PREFIX)" nil nil
)
300 (autoload 'defun
* "cl-macs" "\
301 Define NAME as a function.
302 Like normal `defun', except ARGLIST allows full Common Lisp conventions,
303 and BODY is implicitly surrounded by (block NAME ...).
305 \(fn NAME ARGLIST [DOCSTRING] BODY...)" nil
(quote macro
))
307 (autoload 'defmacro
* "cl-macs" "\
308 Define NAME as a macro.
309 Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
310 and BODY is implicitly surrounded by (block NAME ...).
312 \(fn NAME ARGLIST [DOCSTRING] BODY...)" nil
(quote macro
))
314 (autoload 'function
* "cl-macs" "\
315 Introduce a function.
316 Like normal `function', except that if argument is a lambda form,
317 its argument list allows full Common Lisp conventions.
319 \(fn FUNC)" nil
(quote macro
))
321 (autoload 'destructuring-bind
"cl-macs" "\
324 \(fn ARGS EXPR &rest BODY)" nil
(quote macro
))
326 (autoload 'eval-when
"cl-macs" "\
327 Control when BODY is evaluated.
328 If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
329 If `load' is in WHEN, BODY is evaluated when loaded after top-level compile.
330 If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level.
332 \(fn (WHEN...) BODY...)" nil
(quote macro
))
334 (autoload '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
(quote macro
))
340 (autoload '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, 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
(quote macro
))
351 (autoload 'ecase
"cl-macs" "\
352 Like `case', but error if no case fits.
353 `otherwise'-clauses are not allowed.
355 \(fn EXPR (KEYLIST BODY...)...)" nil
(quote macro
))
357 (autoload 'typecase
"cl-macs" "\
358 Evals EXPR, chooses among clauses on that value.
359 Each clause looks like (TYPE BODY...). EXPR is evaluated and, if it
360 satisfies TYPE, the corresponding BODY is evaluated. If no clause succeeds,
361 typecase returns nil. A TYPE of t or `otherwise' is allowed only in the
362 final clause, and matches if no other keys match.
364 \(fn EXPR (TYPE BODY...)...)" nil
(quote macro
))
366 (autoload 'etypecase
"cl-macs" "\
367 Like `typecase', but error if no case fits.
368 `otherwise'-clauses are not allowed.
370 \(fn EXPR (TYPE BODY...)...)" nil
(quote macro
))
372 (autoload 'block
"cl-macs" "\
373 Define a lexically-scoped block named NAME.
374 NAME may be any symbol. Code inside the BODY forms can call `return-from'
375 to jump prematurely out of the block. This differs from `catch' and `throw'
376 in two respects: First, the NAME is an unevaluated symbol rather than a
377 quoted symbol or other form; and second, NAME is lexically rather than
378 dynamically scoped: Only references to it within BODY will work. These
379 references may appear inside macro expansions, but not inside functions
382 \(fn NAME &rest BODY)" nil
(quote macro
))
384 (autoload 'return
"cl-macs" "\
385 Return from the block named nil.
386 This is equivalent to `(return-from nil RESULT)'.
388 \(fn &optional RESULT)" nil
(quote macro
))
390 (autoload 'return-from
"cl-macs" "\
391 Return from the block named NAME.
392 This jumps out to the innermost enclosing `(block NAME ...)' form,
393 returning RESULT from that form (or nil if RESULT is omitted).
394 This is compatible with Common Lisp, but note that `defun' and
395 `defmacro' do not create implicit blocks as they do in Common Lisp.
397 \(fn NAME &optional RESULT)" nil
(quote macro
))
399 (autoload 'loop
"cl-macs" "\
400 The Common Lisp `loop' macro.
402 for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM,
403 for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR,
404 for VAR across ARRAY, repeat NUM, with VAR = INIT, while COND, until COND,
405 always COND, never COND, thereis COND, collect EXPR into VAR,
406 append EXPR into VAR, nconc EXPR into VAR, sum EXPR into VAR,
407 count EXPR into VAR, maximize EXPR into VAR, minimize EXPR into VAR,
408 if COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
409 unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
410 do EXPRS..., initially EXPRS..., finally EXPRS..., return EXPR,
411 finally return EXPR, named NAME.
413 \(fn CLAUSE...)" nil
(quote macro
))
415 (autoload 'do
"cl-macs" "\
416 The Common Lisp `do' loop.
418 \(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil
(quote macro
))
420 (autoload 'do
* "cl-macs" "\
421 The Common Lisp `do*' loop.
423 \(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil
(quote macro
))
425 (autoload 'dolist
"cl-macs" "\
427 Evaluate BODY with VAR bound to each `car' from LIST, in turn.
428 Then evaluate RESULT to get return value, default nil.
430 \(fn (VAR LIST [RESULT]) BODY...)" nil
(quote macro
))
432 (autoload 'dotimes
"cl-macs" "\
433 Loop a certain number of times.
434 Evaluate BODY with VAR bound to successive integers from 0, inclusive,
435 to COUNT, exclusive. Then evaluate RESULT to get return value, default
438 \(fn (VAR COUNT [RESULT]) BODY...)" nil
(quote macro
))
440 (autoload 'do-symbols
"cl-macs" "\
441 Loop over all symbols.
442 Evaluate BODY with VAR bound to each interned symbol, or to each symbol
445 \(fn (VAR [OBARRAY [RESULT]]) BODY...)" nil
(quote macro
))
447 (autoload 'do-all-symbols
"cl-macs" "\
450 \(fn SPEC &rest BODY)" nil
(quote macro
))
452 (autoload 'psetq
"cl-macs" "\
453 Set SYMs to the values VALs in parallel.
454 This is like `setq', except that all VAL forms are evaluated (in order)
455 before assigning any symbols SYM to the corresponding values.
457 \(fn SYM VAL SYM VAL ...)" nil
(quote macro
))
459 (autoload 'progv
"cl-macs" "\
460 Bind SYMBOLS to VALUES dynamically in BODY.
461 The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
462 Each symbol in the first list is bound to the corresponding value in the
463 second list (or made unbound if VALUES is shorter than SYMBOLS); then the
464 BODY forms are executed and their result is returned. This is much like
465 a `let' form, except that the list of symbols can be computed at run-time.
467 \(fn SYMBOLS VALUES &rest BODY)" nil
(quote macro
))
469 (autoload 'flet
"cl-macs" "\
470 Make temporary function definitions.
471 This is an analogue of `let' that operates on the function cell of FUNC
472 rather than its value cell. The FORMs are evaluated with the specified
473 function definitions in place, then the definitions are undone (the FUNCs
474 go back to their previous definitions, or lack thereof).
476 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil
(quote macro
))
478 (autoload 'labels
"cl-macs" "\
479 Make temporary function bindings.
480 This is like `flet', except the bindings are lexical instead of dynamic.
481 Unlike `flet', this macro is fully compliant with the Common Lisp standard.
483 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil
(quote macro
))
485 (autoload 'macrolet
"cl-macs" "\
486 Make temporary macro definitions.
487 This is like `flet', but for macros instead of functions.
489 \(fn ((NAME ARGLIST BODY...) ...) FORM...)" nil
(quote macro
))
491 (autoload 'symbol-macrolet
"cl-macs" "\
492 Make symbol macro definitions.
493 Within the body FORMs, references to the variable NAME will be replaced
494 by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...).
496 \(fn ((NAME EXPANSION) ...) FORM...)" nil
(quote macro
))
498 (autoload 'lexical-let
"cl-macs" "\
499 Like `let', but lexically scoped.
500 The main visible difference is that lambdas inside BODY will create
501 lexical closures as in Common Lisp.
503 \(fn BINDINGS BODY)" nil
(quote macro
))
505 (autoload 'lexical-let
* "cl-macs" "\
506 Like `let*', but lexically scoped.
507 The main visible difference is that lambdas inside BODY, and in
508 successive bindings within BINDINGS, will create lexical closures
509 as in Common Lisp. This is similar to the behavior of `let*' in
512 \(fn BINDINGS BODY)" nil
(quote macro
))
514 (autoload 'multiple-value-bind
"cl-macs" "\
515 Collect multiple return values.
516 FORM must return a list; the BODY is then executed with the first N elements
517 of this list bound (`let'-style) to each of the symbols SYM in turn. This
518 is analogous to the Common Lisp `multiple-value-bind' macro, using lists to
519 simulate true multiple return values. For compatibility, (values A B C) is
520 a synonym for (list A B C).
522 \(fn (SYM...) FORM BODY)" nil
(quote macro
))
524 (autoload 'multiple-value-setq
"cl-macs" "\
525 Collect multiple return values.
526 FORM must return a list; the first N elements of this list are stored in
527 each of the symbols SYM in turn. This is analogous to the Common Lisp
528 `multiple-value-setq' macro, using lists to simulate true multiple return
529 values. For compatibility, (values A B C) is a synonym for (list A B C).
531 \(fn (SYM...) FORM)" nil
(quote macro
))
533 (autoload 'locally
"cl-macs" "\
536 \(fn &rest BODY)" nil
(quote macro
))
538 (autoload 'the
"cl-macs" "\
541 \(fn TYPE FORM)" nil
(quote macro
))
543 (autoload 'declare
"cl-macs" "\
544 Declare SPECS about the current function while compiling.
549 will turn off byte-compile warnings in the function.
550 See Info node `(cl)Declarations' for details.
552 \(fn &rest SPECS)" nil
(quote macro
))
554 (autoload 'define-setf-method
"cl-macs" "\
555 Define a `setf' method.
556 This method shows how to handle `setf's to places of the form (NAME ARGS...).
557 The argument forms ARGS are bound according to ARGLIST, as if NAME were
558 going to be expanded as a macro, then the BODY forms are executed and must
559 return a list of five elements: a temporary-variables list, a value-forms
560 list, a store-variables list (of length one), a store-form, and an access-
561 form. See `defsetf' for a simpler way to define most setf-methods.
563 \(fn NAME ARGLIST BODY...)" nil
(quote macro
))
565 (autoload 'defsetf
"cl-macs" "\
566 Define a `setf' method.
567 This macro is an easy-to-use substitute for `define-setf-method' that works
568 well for simple place forms. In the simple `defsetf' form, `setf's of
569 the form (setf (NAME ARGS...) VAL) are transformed to function or macro
570 calls of the form (FUNC ARGS... VAL). Example:
574 Alternate form: (defsetf NAME ARGLIST (STORE) BODY...).
575 Here, the above `setf' call is expanded by binding the argument forms ARGS
576 according to ARGLIST, binding the value form VAL to STORE, then executing
577 BODY, which must return a Lisp form that does the necessary `setf' operation.
578 Actually, ARGLIST and STORE may be bound to temporary variables which are
579 introduced automatically to preserve proper execution order of the arguments.
582 (defsetf nth (n x) (v) (list 'setcar (list 'nthcdr n x) v))
584 \(fn NAME [FUNC | ARGLIST (STORE) BODY...])" nil
(quote macro
))
586 (autoload 'get-setf-method
"cl-macs" "\
587 Return a list of five values describing the setf-method for PLACE.
588 PLACE may be any Lisp form which can appear as the PLACE argument to
589 a macro like `setf' or `incf'.
591 \(fn PLACE &optional ENV)" nil nil
)
593 (autoload 'setf
"cl-macs" "\
594 Set each PLACE to the value of its VAL.
595 This is a generalized version of `setq'; the PLACEs may be symbolic
596 references such as (car x) or (aref x i), as well as plain symbols.
597 For example, (setf (cadar x) y) is equivalent to (setcar (cdar x) y).
598 The return value is the last VAL in the list.
600 \(fn PLACE VAL PLACE VAL ...)" nil
(quote macro
))
602 (autoload 'psetf
"cl-macs" "\
603 Set PLACEs to the values VALs in parallel.
604 This is like `setf', except that all VAL forms are evaluated (in order)
605 before assigning any PLACEs to the corresponding values.
607 \(fn PLACE VAL PLACE VAL ...)" nil
(quote macro
))
609 (autoload 'cl-do-pop
"cl-macs" "\
612 \(fn PLACE)" nil nil
)
614 (autoload 'remf
"cl-macs" "\
615 Remove TAG from property list PLACE.
616 PLACE may be a symbol, or any generalized variable allowed by `setf'.
617 The form returns true if TAG was found and removed, nil otherwise.
619 \(fn PLACE TAG)" nil
(quote macro
))
621 (autoload 'shiftf
"cl-macs" "\
622 Shift left among PLACEs.
623 Example: (shiftf A B C) sets A to B, B to C, and returns the old A.
624 Each PLACE may be a symbol, or any generalized variable allowed by `setf'.
626 \(fn PLACE... VAL)" nil
(quote macro
))
628 (autoload 'rotatef
"cl-macs" "\
629 Rotate left among PLACEs.
630 Example: (rotatef A B C) sets A to B, B to C, and C to A. It returns nil.
631 Each PLACE may be a symbol, or any generalized variable allowed by `setf'.
633 \(fn PLACE...)" nil
(quote macro
))
635 (autoload 'letf
"cl-macs" "\
636 Temporarily bind to PLACEs.
637 This is the analogue of `let', but with generalized variables (in the
638 sense of `setf') for the PLACEs. Each PLACE is set to the corresponding
639 VALUE, then the BODY forms are executed. On exit, either normally or
640 because of a `throw' or error, the PLACEs are set back to their original
641 values. Note that this macro is *not* available in Common Lisp.
642 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
643 the PLACE is not modified before executing BODY.
645 \(fn ((PLACE VALUE) ...) BODY...)" nil
(quote macro
))
647 (autoload 'letf
* "cl-macs" "\
648 Temporarily bind to PLACEs.
649 This is the analogue of `let*', but with generalized variables (in the
650 sense of `setf') for the PLACEs. Each PLACE is set to the corresponding
651 VALUE, then the BODY forms are executed. On exit, either normally or
652 because of a `throw' or error, the PLACEs are set back to their original
653 values. Note that this macro is *not* available in Common Lisp.
654 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
655 the PLACE is not modified before executing BODY.
657 \(fn ((PLACE VALUE) ...) BODY...)" nil
(quote macro
))
659 (autoload 'callf
"cl-macs" "\
660 Set PLACE to (FUNC PLACE ARGS...).
661 FUNC should be an unquoted function name. PLACE may be a symbol,
662 or any generalized variable allowed by `setf'.
664 \(fn FUNC PLACE ARGS...)" nil
(quote macro
))
666 (autoload 'callf2
"cl-macs" "\
667 Set PLACE to (FUNC ARG1 PLACE ARGS...).
668 Like `callf', but PLACE is the second argument of FUNC, not the first.
670 \(fn FUNC ARG1 PLACE ARGS...)" nil
(quote macro
))
672 (autoload 'define-modify-macro
"cl-macs" "\
673 Define a `setf'-like modify macro.
674 If NAME is called, it combines its PLACE argument with the other arguments
675 from ARGLIST using FUNC: (define-modify-macro incf (&optional (n 1)) +)
677 \(fn NAME ARGLIST FUNC &optional DOC)" nil
(quote macro
))
679 (autoload 'defstruct
"cl-macs" "\
680 Define a struct type.
681 This macro defines a new data type called NAME that stores data
682 in SLOTs. It defines a `make-NAME' constructor, a `copy-NAME'
683 copier, a `NAME-p' predicate, and slot accessors named `NAME-SLOT'.
684 You can use the accessors to set the corresponding slots, via `setf'.
686 NAME may instead take the form (NAME OPTIONS...), where each
687 OPTION is either a single keyword or (KEYWORD VALUE).
688 See Info node `(cl)Structures' for a list of valid keywords.
690 Each SLOT may instead take the form (SLOT SLOT-OPTS...), where
691 SLOT-OPTS are keyword-value pairs for that slot. Currently, only
692 one keyword is supported, `:read-only'. If this has a non-nil
693 value, that slot cannot be set via `setf'.
695 \(fn NAME SLOTS...)" nil
(quote macro
))
697 (autoload 'cl-struct-setf-expander
"cl-macs" "\
700 \(fn X NAME ACCESSOR PRED-FORM POS)" nil nil
)
702 (autoload 'deftype
"cl-macs" "\
703 Define NAME as a new data type.
704 The type name can then be used in `typecase', `check-type', etc.
706 \(fn NAME ARGLIST &rest BODY)" nil
(quote macro
))
708 (autoload 'typep
"cl-macs" "\
709 Check that OBJECT is of type TYPE.
710 TYPE is a Common Lisp-style type specifier.
712 \(fn OBJECT TYPE)" nil nil
)
714 (autoload 'check-type
"cl-macs" "\
715 Verify that FORM is of type TYPE; signal an error if not.
716 STRING is an optional description of the desired type.
718 \(fn FORM TYPE &optional STRING)" nil
(quote macro
))
720 (autoload 'assert
"cl-macs" "\
721 Verify that FORM returns non-nil; signal an error if not.
722 Second arg SHOW-ARGS means to include arguments of FORM in message.
723 Other args STRING and ARGS... are arguments to be passed to `error'.
724 They are not evaluated unless the assertion fails. If STRING is
725 omitted, a default message listing FORM itself is used.
727 \(fn FORM &optional SHOW-ARGS STRING &rest ARGS)" nil
(quote macro
))
729 (autoload 'define-compiler-macro
"cl-macs" "\
730 Define a compiler-only macro.
731 This is like `defmacro', but macro expansion occurs only if the call to
732 FUNC is compiled (i.e., not interpreted). Compiler macros should be used
733 for optimizing the way calls to FUNC are compiled; the form returned by
734 BODY should do the same thing as a call to the normal function called
735 FUNC, though possibly more efficiently. Note that, like regular macros,
736 compiler macros are expanded repeatedly until no further expansions are
737 possible. Unlike regular macros, BODY can decide to \"punt\" and leave the
738 original function call alone by declaring an initial `&whole foo' parameter
739 and then returning foo.
741 \(fn FUNC ARGS &rest BODY)" nil
(quote macro
))
743 (autoload 'compiler-macroexpand
"cl-macs" "\
748 (autoload 'defsubst
* "cl-macs" "\
749 Define NAME as a function.
750 Like `defun', except the function is automatically declared `inline',
751 ARGLIST allows full Common Lisp conventions, and BODY is implicitly
752 surrounded by (block NAME ...).
754 \(fn NAME ARGLIST [DOCSTRING] BODY...)" nil
(quote macro
))
758 ;;;### (autoloads (tree-equal nsublis sublis nsubst-if-not nsubst-if
759 ;;;;;; nsubst subst-if-not subst-if subsetp nset-exclusive-or set-exclusive-or
760 ;;;;;; nset-difference set-difference nintersection intersection
761 ;;;;;; nunion union rassoc-if-not rassoc-if rassoc* assoc-if-not
762 ;;;;;; assoc-if assoc* cl-adjoin member-if-not member-if member*
763 ;;;;;; merge stable-sort sort* search mismatch count-if-not count-if
764 ;;;;;; count position-if-not position-if position find-if-not find-if
765 ;;;;;; find nsubstitute-if-not nsubstitute-if nsubstitute substitute-if-not
766 ;;;;;; substitute-if substitute delete-duplicates remove-duplicates
767 ;;;;;; delete-if-not delete-if delete* remove-if-not remove-if remove*
768 ;;;;;; replace fill reduce) "cl-seq" "cl-seq.el" "df375ddc313f0c1c262cacab5cffd3e4")
769 ;;; Generated autoloads from cl-seq.el
771 (autoload 'reduce
"cl-seq" "\
772 Reduce two-argument FUNCTION across SEQ.
774 Keywords supported: :start :end :from-end :initial-value :key
776 \(fn FUNCTION SEQ [KEYWORD VALUE]...)" nil nil
)
778 (autoload 'fill
"cl-seq" "\
779 Fill the elements of SEQ with ITEM.
781 Keywords supported: :start :end
783 \(fn SEQ ITEM [KEYWORD VALUE]...)" nil nil
)
785 (autoload 'replace
"cl-seq" "\
786 Replace the elements of SEQ1 with the elements of SEQ2.
787 SEQ1 is destructively modified, then returned.
789 Keywords supported: :start1 :end1 :start2 :end2
791 \(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil
)
793 (autoload 'remove
* "cl-seq" "\
794 Remove all occurrences of ITEM in SEQ.
795 This is a non-destructive function; it makes a copy of SEQ if necessary
796 to avoid corrupting the original SEQ.
798 Keywords supported: :test :test-not :key :count :start :end :from-end
800 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil
)
802 (autoload 'remove-if
"cl-seq" "\
803 Remove all items satisfying PREDICATE in SEQ.
804 This is a non-destructive function; it makes a copy of SEQ if necessary
805 to avoid corrupting the original SEQ.
807 Keywords supported: :key :count :start :end :from-end
809 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
811 (autoload 'remove-if-not
"cl-seq" "\
812 Remove all items not satisfying PREDICATE in SEQ.
813 This is a non-destructive function; it makes a copy of SEQ if necessary
814 to avoid corrupting the original SEQ.
816 Keywords supported: :key :count :start :end :from-end
818 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
820 (autoload 'delete
* "cl-seq" "\
821 Remove all occurrences of ITEM in SEQ.
822 This is a destructive function; it reuses the storage of SEQ whenever possible.
824 Keywords supported: :test :test-not :key :count :start :end :from-end
826 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil
)
828 (autoload 'delete-if
"cl-seq" "\
829 Remove all items satisfying PREDICATE in SEQ.
830 This is a destructive function; it reuses the storage of SEQ whenever possible.
832 Keywords supported: :key :count :start :end :from-end
834 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
836 (autoload 'delete-if-not
"cl-seq" "\
837 Remove all items not satisfying PREDICATE in SEQ.
838 This is a destructive function; it reuses the storage of SEQ whenever possible.
840 Keywords supported: :key :count :start :end :from-end
842 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
844 (autoload 'remove-duplicates
"cl-seq" "\
845 Return a copy of SEQ with all duplicate elements removed.
847 Keywords supported: :test :test-not :key :start :end :from-end
849 \(fn SEQ [KEYWORD VALUE]...)" nil nil
)
851 (autoload 'delete-duplicates
"cl-seq" "\
852 Remove all duplicate elements from SEQ (destructively).
854 Keywords supported: :test :test-not :key :start :end :from-end
856 \(fn SEQ [KEYWORD VALUE]...)" nil nil
)
858 (autoload 'substitute
"cl-seq" "\
859 Substitute NEW for OLD in SEQ.
860 This is a non-destructive function; it makes a copy of SEQ if necessary
861 to avoid corrupting the original SEQ.
863 Keywords supported: :test :test-not :key :count :start :end :from-end
865 \(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil
)
867 (autoload 'substitute-if
"cl-seq" "\
868 Substitute NEW for all items satisfying PREDICATE in SEQ.
869 This is a non-destructive function; it makes a copy of SEQ if necessary
870 to avoid corrupting the original SEQ.
872 Keywords supported: :key :count :start :end :from-end
874 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
876 (autoload 'substitute-if-not
"cl-seq" "\
877 Substitute NEW for all items not satisfying PREDICATE in SEQ.
878 This is a non-destructive function; it makes a copy of SEQ if necessary
879 to avoid corrupting the original SEQ.
881 Keywords supported: :key :count :start :end :from-end
883 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
885 (autoload 'nsubstitute
"cl-seq" "\
886 Substitute NEW for OLD in SEQ.
887 This is a destructive function; it reuses the storage of SEQ whenever possible.
889 Keywords supported: :test :test-not :key :count :start :end :from-end
891 \(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil
)
893 (autoload 'nsubstitute-if
"cl-seq" "\
894 Substitute NEW for all items satisfying PREDICATE in SEQ.
895 This is a destructive function; it reuses the storage of SEQ whenever possible.
897 Keywords supported: :key :count :start :end :from-end
899 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
901 (autoload 'nsubstitute-if-not
"cl-seq" "\
902 Substitute NEW for all items not satisfying PREDICATE in SEQ.
903 This is a destructive function; it reuses the storage of SEQ whenever possible.
905 Keywords supported: :key :count :start :end :from-end
907 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
909 (autoload 'find
"cl-seq" "\
910 Find the first occurrence of ITEM in SEQ.
911 Return the matching ITEM, or nil if not found.
913 Keywords supported: :test :test-not :key :start :end :from-end
915 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil
)
917 (autoload 'find-if
"cl-seq" "\
918 Find the first item satisfying PREDICATE in SEQ.
919 Return the matching item, or nil if not found.
921 Keywords supported: :key :start :end :from-end
923 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
925 (autoload 'find-if-not
"cl-seq" "\
926 Find the first item not satisfying PREDICATE in SEQ.
927 Return 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 'position
"cl-seq" "\
934 Find the first occurrence of ITEM in SEQ.
935 Return the index of the matching item, or nil if not found.
937 Keywords supported: :test :test-not :key :start :end :from-end
939 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil
)
941 (autoload 'position-if
"cl-seq" "\
942 Find the first item satisfying PREDICATE in SEQ.
943 Return the index of the matching item, or nil if not found.
945 Keywords supported: :key :start :end :from-end
947 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
949 (autoload 'position-if-not
"cl-seq" "\
950 Find the first item not satisfying PREDICATE in SEQ.
951 Return the index of the matching item, or nil if not found.
953 Keywords supported: :key :start :end :from-end
955 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
957 (autoload 'count
"cl-seq" "\
958 Count the number of occurrences of ITEM in SEQ.
960 Keywords supported: :test :test-not :key :start :end
962 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil
)
964 (autoload 'count-if
"cl-seq" "\
965 Count the number of items satisfying PREDICATE in SEQ.
967 Keywords supported: :key :start :end
969 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
971 (autoload 'count-if-not
"cl-seq" "\
972 Count the number of items not satisfying PREDICATE in SEQ.
974 Keywords supported: :key :start :end
976 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil
)
978 (autoload 'mismatch
"cl-seq" "\
979 Compare SEQ1 with SEQ2, return index of first mismatching element.
980 Return nil if the sequences match. If one sequence is a prefix of the
981 other, the return value indicates the end of the shorter sequence.
983 Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end
985 \(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil
)
987 (autoload 'search
"cl-seq" "\
988 Search for SEQ1 as a subsequence of SEQ2.
989 Return the index of the leftmost element of the first match found;
990 return nil if there are no matches.
992 Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end
994 \(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil
)
996 (autoload 'sort
* "cl-seq" "\
997 Sort the argument SEQ according to PREDICATE.
998 This is a destructive function; it reuses the storage of SEQ if possible.
1000 Keywords supported: :key
1002 \(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil
)
1004 (autoload 'stable-sort
"cl-seq" "\
1005 Sort the argument SEQ stably according to PREDICATE.
1006 This is a destructive function; it reuses the storage of SEQ if possible.
1008 Keywords supported: :key
1010 \(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil
)
1012 (autoload 'merge
"cl-seq" "\
1013 Destructively merge the two sequences to produce a new sequence.
1014 TYPE is the sequence type to return, SEQ1 and SEQ2 are the two argument
1015 sequences, and PREDICATE is a `less-than' predicate on the elements.
1017 Keywords supported: :key
1019 \(fn TYPE SEQ1 SEQ2 PREDICATE [KEYWORD VALUE]...)" nil nil
)
1021 (autoload 'member
* "cl-seq" "\
1022 Find the first occurrence of ITEM in LIST.
1023 Return the sublist of LIST whose car is ITEM.
1025 Keywords supported: :test :test-not :key
1027 \(fn ITEM LIST [KEYWORD VALUE]...)" nil nil
)
1029 (autoload 'member-if
"cl-seq" "\
1030 Find the first item satisfying PREDICATE in LIST.
1031 Return the sublist of LIST whose car matches.
1033 Keywords supported: :key
1035 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1037 (autoload 'member-if-not
"cl-seq" "\
1038 Find the first item not satisfying PREDICATE in LIST.
1039 Return the sublist of LIST whose car matches.
1041 Keywords supported: :key
1043 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1045 (autoload 'cl-adjoin
"cl-seq" "\
1048 \(fn CL-ITEM CL-LIST &rest CL-KEYS)" nil nil
)
1050 (autoload 'assoc
* "cl-seq" "\
1051 Find the first item whose car matches ITEM in LIST.
1053 Keywords supported: :test :test-not :key
1055 \(fn ITEM LIST [KEYWORD VALUE]...)" nil nil
)
1057 (autoload 'assoc-if
"cl-seq" "\
1058 Find the first item whose car satisfies PREDICATE in LIST.
1060 Keywords supported: :key
1062 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1064 (autoload 'assoc-if-not
"cl-seq" "\
1065 Find the first item whose car does not satisfy PREDICATE in LIST.
1067 Keywords supported: :key
1069 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1071 (autoload 'rassoc
* "cl-seq" "\
1072 Find the first item whose cdr matches ITEM in LIST.
1074 Keywords supported: :test :test-not :key
1076 \(fn ITEM LIST [KEYWORD VALUE]...)" nil nil
)
1078 (autoload 'rassoc-if
"cl-seq" "\
1079 Find the first item whose cdr satisfies PREDICATE in LIST.
1081 Keywords supported: :key
1083 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1085 (autoload 'rassoc-if-not
"cl-seq" "\
1086 Find the first item whose cdr does not satisfy PREDICATE in LIST.
1088 Keywords supported: :key
1090 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil
)
1092 (autoload 'union
"cl-seq" "\
1093 Combine LIST1 and LIST2 using a set-union operation.
1094 The resulting list contains all items that appear in either LIST1 or 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.
1098 Keywords supported: :test :test-not :key
1100 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1102 (autoload 'nunion
"cl-seq" "\
1103 Combine LIST1 and LIST2 using a set-union operation.
1104 The resulting list contains all items that appear in either LIST1 or LIST2.
1105 This is a destructive function; it reuses the storage of LIST1 and LIST2
1108 Keywords supported: :test :test-not :key
1110 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1112 (autoload 'intersection
"cl-seq" "\
1113 Combine LIST1 and LIST2 using a set-intersection operation.
1114 The resulting list contains all items that appear in both LIST1 and 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.
1118 Keywords supported: :test :test-not :key
1120 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1122 (autoload 'nintersection
"cl-seq" "\
1123 Combine LIST1 and LIST2 using a set-intersection operation.
1124 The resulting list contains all items that appear in both LIST1 and LIST2.
1125 This is a destructive function; it reuses the storage of LIST1 and LIST2
1128 Keywords supported: :test :test-not :key
1130 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1132 (autoload 'set-difference
"cl-seq" "\
1133 Combine LIST1 and LIST2 using a set-difference operation.
1134 The resulting list contains all items that appear in LIST1 but not 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.
1138 Keywords supported: :test :test-not :key
1140 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1142 (autoload 'nset-difference
"cl-seq" "\
1143 Combine LIST1 and LIST2 using a set-difference operation.
1144 The resulting list contains all items that appear in LIST1 but not LIST2.
1145 This is a destructive function; it reuses the storage of LIST1 and LIST2
1148 Keywords supported: :test :test-not :key
1150 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1152 (autoload 'set-exclusive-or
"cl-seq" "\
1153 Combine LIST1 and LIST2 using a set-exclusive-or operation.
1154 The resulting list contains all items appearing in exactly one of LIST1, LIST2.
1155 This is a non-destructive function; it makes a copy of the data if necessary
1156 to avoid corrupting the original LIST1 and LIST2.
1158 Keywords supported: :test :test-not :key
1160 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1162 (autoload 'nset-exclusive-or
"cl-seq" "\
1163 Combine LIST1 and LIST2 using a set-exclusive-or operation.
1164 The resulting list contains all items appearing in exactly one of LIST1, LIST2.
1165 This is a destructive function; it reuses the storage of LIST1 and LIST2
1168 Keywords supported: :test :test-not :key
1170 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1172 (autoload 'subsetp
"cl-seq" "\
1173 Return true if LIST1 is a subset of LIST2.
1174 I.e., if every element of LIST1 also appears in LIST2.
1176 Keywords supported: :test :test-not :key
1178 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil
)
1180 (autoload 'subst-if
"cl-seq" "\
1181 Substitute NEW for elements matching PREDICATE in TREE (non-destructively).
1182 Return a copy of TREE with all matching elements replaced by NEW.
1184 Keywords supported: :key
1186 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil
)
1188 (autoload 'subst-if-not
"cl-seq" "\
1189 Substitute NEW for elts not matching PREDICATE in TREE (non-destructively).
1190 Return a copy of TREE with all non-matching elements replaced by NEW.
1192 Keywords supported: :key
1194 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil
)
1196 (autoload 'nsubst
"cl-seq" "\
1197 Substitute NEW for OLD everywhere in TREE (destructively).
1198 Any element of TREE which is `eql' to OLD is changed to NEW (via a call
1201 Keywords supported: :test :test-not :key
1203 \(fn NEW OLD TREE [KEYWORD VALUE]...)" nil nil
)
1205 (autoload 'nsubst-if
"cl-seq" "\
1206 Substitute NEW for elements matching PREDICATE in TREE (destructively).
1207 Any element of TREE which matches is changed to NEW (via a call to `setcar').
1209 Keywords supported: :key
1211 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil
)
1213 (autoload 'nsubst-if-not
"cl-seq" "\
1214 Substitute NEW for elements not matching PREDICATE in TREE (destructively).
1215 Any element of TREE which matches is changed to NEW (via a call to `setcar').
1217 Keywords supported: :key
1219 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil
)
1221 (autoload 'sublis
"cl-seq" "\
1222 Perform substitutions indicated by ALIST in TREE (non-destructively).
1223 Return a copy of TREE with all matching elements replaced.
1225 Keywords supported: :test :test-not :key
1227 \(fn ALIST TREE [KEYWORD VALUE]...)" nil nil
)
1229 (autoload 'nsublis
"cl-seq" "\
1230 Perform substitutions indicated by ALIST in TREE (destructively).
1231 Any matching element of TREE is changed via a call to `setcar'.
1233 Keywords supported: :test :test-not :key
1235 \(fn ALIST TREE [KEYWORD VALUE]...)" nil nil
)
1237 (autoload 'tree-equal
"cl-seq" "\
1238 Return t if trees TREE1 and TREE2 have `eql' leaves.
1239 Atoms are compared by `eql'; cons cells are compared recursively.
1241 Keywords supported: :test :test-not :key
1243 \(fn TREE1 TREE2 [KEYWORD VALUE]...)" nil nil
)
1248 ;; version-control: never
1249 ;; no-byte-compile: t
1250 ;; no-update-autoloads: t
1253 ;;; cl-loaddefs.el ends here