;;;;;; ceiling* floor* isqrt lcm gcd cl-progv-before cl-set-frame-visible-p
;;;;;; cl-map-overlays cl-map-intervals cl-map-keymap-recursively
;;;;;; notevery notany every some mapcon mapcan mapl maplist map
-;;;;;; cl-mapcar-many equalp coerce) "cl-extra" "cl-extra.el" "53c2b3ede19dac62cff13a37f58cdf9c")
+;;;;;; cl-mapcar-many equalp coerce) "cl-extra" "cl-extra.el" "d2000926c438cbd72f37587241cab7ed")
;;; Generated autoloads from cl-extra.el
-(autoload (quote coerce) "cl-extra" "\
+(autoload 'coerce "cl-extra" "\
Coerce OBJECT to type TYPE.
TYPE is a Common Lisp type specifier.
\(fn OBJECT TYPE)" nil nil)
-(autoload (quote equalp) "cl-extra" "\
+(autoload 'equalp "cl-extra" "\
Return t if two Lisp objects have similar structures and contents.
This is like `equal', except that it accepts numerically equal
numbers of different types (float vs. integer), and also compares
\(fn X Y)" nil nil)
-(autoload (quote cl-mapcar-many) "cl-extra" "\
+(autoload 'cl-mapcar-many "cl-extra" "\
Not documented
\(fn CL-FUNC CL-SEQS)" nil nil)
-(autoload (quote map) "cl-extra" "\
+(autoload 'map "cl-extra" "\
Map a FUNCTION across one or more SEQUENCEs, returning a sequence.
TYPE is the sequence type to return.
\(fn TYPE FUNCTION SEQUENCE...)" nil nil)
-(autoload (quote maplist) "cl-extra" "\
+(autoload 'maplist "cl-extra" "\
Map FUNCTION to each sublist of LIST or LISTs.
Like `mapcar', except applies to lists and their cdr's rather than to
the elements themselves.
\(fn FUNCTION LIST...)" nil nil)
-(autoload (quote mapl) "cl-extra" "\
+(autoload 'mapl "cl-extra" "\
Like `maplist', but does not accumulate values returned by the function.
\(fn FUNCTION LIST...)" nil nil)
-(autoload (quote mapcan) "cl-extra" "\
+(autoload 'mapcan "cl-extra" "\
Like `mapcar', but nconc's together the values returned by the function.
\(fn FUNCTION SEQUENCE...)" nil nil)
-(autoload (quote mapcon) "cl-extra" "\
+(autoload 'mapcon "cl-extra" "\
Like `maplist', but nconc's together the values returned by the function.
\(fn FUNCTION LIST...)" nil nil)
-(autoload (quote some) "cl-extra" "\
+(autoload 'some "cl-extra" "\
Return true if PREDICATE is true of any element of SEQ or SEQs.
If so, return the true (non-nil) value returned by PREDICATE.
\(fn PREDICATE SEQ...)" nil nil)
-(autoload (quote every) "cl-extra" "\
+(autoload 'every "cl-extra" "\
Return true if PREDICATE is true of every element of SEQ or SEQs.
\(fn PREDICATE SEQ...)" nil nil)
-(autoload (quote notany) "cl-extra" "\
+(autoload 'notany "cl-extra" "\
Return true if PREDICATE is false of every element of SEQ or SEQs.
\(fn PREDICATE SEQ...)" nil nil)
-(autoload (quote notevery) "cl-extra" "\
+(autoload 'notevery "cl-extra" "\
Return true if PREDICATE is false of some element of SEQ or SEQs.
\(fn PREDICATE SEQ...)" nil nil)
-(defalias (quote cl-map-keymap) (quote map-keymap))
+(defalias 'cl-map-keymap 'map-keymap)
-(autoload (quote cl-map-keymap-recursively) "cl-extra" "\
+(autoload 'cl-map-keymap-recursively "cl-extra" "\
Not documented
\(fn CL-FUNC-REC CL-MAP &optional CL-BASE)" nil nil)
-(autoload (quote cl-map-intervals) "cl-extra" "\
+(autoload 'cl-map-intervals "cl-extra" "\
Not documented
\(fn CL-FUNC &optional CL-WHAT CL-PROP CL-START CL-END)" nil nil)
-(autoload (quote cl-map-overlays) "cl-extra" "\
+(autoload 'cl-map-overlays "cl-extra" "\
Not documented
\(fn CL-FUNC &optional CL-BUFFER CL-START CL-END CL-ARG)" nil nil)
-(autoload (quote cl-set-frame-visible-p) "cl-extra" "\
+(autoload 'cl-set-frame-visible-p "cl-extra" "\
Not documented
\(fn FRAME VAL)" nil nil)
-(autoload (quote cl-progv-before) "cl-extra" "\
+(autoload 'cl-progv-before "cl-extra" "\
Not documented
\(fn SYMS VALUES)" nil nil)
-(autoload (quote gcd) "cl-extra" "\
+(autoload 'gcd "cl-extra" "\
Return the greatest common divisor of the arguments.
\(fn &rest ARGS)" nil nil)
-(autoload (quote lcm) "cl-extra" "\
+(autoload 'lcm "cl-extra" "\
Return the least common multiple of the arguments.
\(fn &rest ARGS)" nil nil)
-(autoload (quote isqrt) "cl-extra" "\
+(autoload 'isqrt "cl-extra" "\
Return the integer square root of the argument.
\(fn X)" nil nil)
-(autoload (quote floor*) "cl-extra" "\
+(autoload 'floor* "cl-extra" "\
Return a list of the floor of X and the fractional part of X.
With two arguments, return floor and remainder of their quotient.
\(fn X &optional Y)" nil nil)
-(autoload (quote ceiling*) "cl-extra" "\
+(autoload 'ceiling* "cl-extra" "\
Return a list of the ceiling of X and the fractional part of X.
With two arguments, return ceiling and remainder of their quotient.
\(fn X &optional Y)" nil nil)
-(autoload (quote truncate*) "cl-extra" "\
+(autoload 'truncate* "cl-extra" "\
Return a list of the integer part of X and the fractional part of X.
With two arguments, return truncation and remainder of their quotient.
\(fn X &optional Y)" nil nil)
-(autoload (quote round*) "cl-extra" "\
+(autoload 'round* "cl-extra" "\
Return a list of X rounded to the nearest integer and the remainder.
With two arguments, return rounding and remainder of their quotient.
\(fn X &optional Y)" nil nil)
-(autoload (quote mod*) "cl-extra" "\
+(autoload 'mod* "cl-extra" "\
The remainder of X divided by Y, with the same sign as Y.
\(fn X Y)" nil nil)
-(autoload (quote rem*) "cl-extra" "\
+(autoload 'rem* "cl-extra" "\
The remainder of X divided by Y, with the same sign as X.
\(fn X Y)" nil nil)
-(autoload (quote signum) "cl-extra" "\
+(autoload 'signum "cl-extra" "\
Return 1 if X is positive, -1 if negative, 0 if zero.
\(fn X)" nil nil)
-(autoload (quote random*) "cl-extra" "\
+(autoload 'random* "cl-extra" "\
Return a random nonnegative number less than LIM, an integer or float.
Optional second arg STATE is a random-state object.
\(fn LIM &optional STATE)" nil nil)
-(autoload (quote make-random-state) "cl-extra" "\
+(autoload 'make-random-state "cl-extra" "\
Return a copy of random-state STATE, or of `*random-state*' if omitted.
If STATE is t, return a new state object seeded from the time of day.
\(fn &optional STATE)" nil nil)
-(autoload (quote random-state-p) "cl-extra" "\
+(autoload 'random-state-p "cl-extra" "\
Return t if OBJECT is a random-state object.
\(fn OBJECT)" nil nil)
-(autoload (quote cl-float-limits) "cl-extra" "\
+(autoload 'cl-float-limits "cl-extra" "\
Not documented
\(fn)" nil nil)
-(autoload (quote subseq) "cl-extra" "\
+(autoload 'subseq "cl-extra" "\
Return the subsequence of SEQ from START to END.
If END is omitted, it defaults to the length of the sequence.
If START or END is negative, it counts from the end.
\(fn SEQ START &optional END)" nil nil)
-(autoload (quote concatenate) "cl-extra" "\
+(autoload 'concatenate "cl-extra" "\
Concatenate, into a sequence of type TYPE, the argument SEQUENCEs.
\(fn TYPE SEQUENCE...)" nil nil)
-(autoload (quote revappend) "cl-extra" "\
+(autoload 'revappend "cl-extra" "\
Equivalent to (append (reverse X) Y).
\(fn X Y)" nil nil)
-(autoload (quote nreconc) "cl-extra" "\
+(autoload 'nreconc "cl-extra" "\
Equivalent to (nconc (nreverse X) Y).
\(fn X Y)" nil nil)
-(autoload (quote list-length) "cl-extra" "\
+(autoload 'list-length "cl-extra" "\
Return the length of list X. Return nil if list is circular.
\(fn X)" nil nil)
-(autoload (quote tailp) "cl-extra" "\
+(autoload 'tailp "cl-extra" "\
Return true if SUBLIST is a tail of LIST.
\(fn SUBLIST LIST)" nil nil)
-(autoload (quote get*) "cl-extra" "\
+(autoload 'get* "cl-extra" "\
Return the value of SYMBOL's PROPNAME property, or DEFAULT if none.
\(fn SYMBOL PROPNAME &optional DEFAULT)" nil nil)
-(autoload (quote getf) "cl-extra" "\
+(autoload 'getf "cl-extra" "\
Search PROPLIST for property PROPNAME; return its value or DEFAULT.
PROPLIST is a list of the sort returned by `symbol-plist'.
\(fn PROPLIST PROPNAME &optional DEFAULT)" nil nil)
-(autoload (quote cl-set-getf) "cl-extra" "\
+(autoload 'cl-set-getf "cl-extra" "\
Not documented
\(fn PLIST TAG VAL)" nil nil)
-(autoload (quote cl-do-remf) "cl-extra" "\
+(autoload 'cl-do-remf "cl-extra" "\
Not documented
\(fn PLIST TAG)" nil nil)
-(autoload (quote cl-remprop) "cl-extra" "\
+(autoload 'cl-remprop "cl-extra" "\
Remove from SYMBOL's plist the property PROPNAME and its value.
\(fn SYMBOL PROPNAME)" nil nil)
-(defalias (quote remprop) (quote cl-remprop))
+(defalias 'remprop 'cl-remprop)
-(defalias (quote cl-gethash) (quote gethash))
+(defalias 'cl-gethash 'gethash)
-(defalias (quote cl-puthash) (quote puthash))
+(defalias 'cl-puthash 'puthash)
-(defalias (quote cl-remhash) (quote remhash))
+(defalias 'cl-remhash 'remhash)
-(defalias (quote cl-clrhash) (quote clrhash))
+(defalias 'cl-clrhash 'clrhash)
-(defalias (quote cl-maphash) (quote maphash))
+(defalias 'cl-maphash 'maphash)
-(defalias (quote cl-make-hash-table) (quote make-hash-table))
+(defalias 'cl-make-hash-table 'make-hash-table)
-(defalias (quote cl-hash-table-p) (quote hash-table-p))
+(defalias 'cl-hash-table-p 'hash-table-p)
-(defalias (quote cl-hash-table-count) (quote hash-table-count))
+(defalias 'cl-hash-table-count 'hash-table-count)
-(autoload (quote cl-macroexpand-all) "cl-extra" "\
+(autoload 'cl-macroexpand-all "cl-extra" "\
Expand all macro calls through a Lisp FORM.
This also does some trivial optimizations to make the form prettier.
\(fn FORM &optional ENV)" nil nil)
-(autoload (quote cl-prettyexpand) "cl-extra" "\
+(autoload 'cl-prettyexpand "cl-extra" "\
Not documented
\(fn FORM &optional FULL)" nil nil)
;;;***
\f
-;;;### (autoloads (compiler-macroexpand define-compiler-macro ignore-errors
-;;;;;; assert check-type typep cl-struct-setf-expander defstruct
+;;;### (autoloads (compiler-macroexpand define-compiler-macro assert
+;;;;;; check-type typep deftype cl-struct-setf-expander defstruct
;;;;;; define-modify-macro callf2 callf letf* letf rotatef shiftf
;;;;;; remf cl-do-pop psetf setf get-setf-method defsetf define-setf-method
;;;;;; declare the locally multiple-value-setq multiple-value-bind
;;;;;; flet progv psetq do-all-symbols do-symbols dotimes dolist
;;;;;; do* do loop return-from return block etypecase typecase ecase
;;;;;; case load-time-value eval-when destructuring-bind function*
-;;;;;; defmacro* defun* gentemp gensym cl-compile-time-init) "cl-macs"
-;;;;;; "cl-macs.el" "6ebe05f6ba95a14ea35d74ef52c17882")
+;;;;;; defmacro* defun* gentemp gensym) "cl-macs" "cl-macs.el" "f6bd68f91847390d47f57b6aac6be023")
;;; Generated autoloads from cl-macs.el
-(autoload 'cl-compile-time-init "cl-macs" "\
-Not documented
-
-\(fn)" nil nil)
-
(autoload 'gensym "cl-macs" "\
Generate a new uninterned symbol.
The name is made by appending a number to PREFIX, default \"G\".
(autoload 'lexical-let* "cl-macs" "\
Like `let*', but lexically scoped.
-The main visible difference is that lambdas inside BODY will create
-lexical closures as in Common Lisp.
+The main visible difference is that lambdas inside BODY, and in
+successive bindings within BINDINGS, will create lexical closures
+as in Common Lisp. This is similar to the behavior of `let*' in
+Common Lisp.
\(fn VARLIST BODY)" nil (quote macro))
\(fn X NAME ACCESSOR PRED-FORM POS)" nil nil)
+(autoload 'deftype "cl-macs" "\
+Define NAME as a new data type.
+The type name can then be used in `typecase', `check-type', etc.
+
+\(fn NAME ARGLIST &rest BODY)" nil (quote macro))
+
(autoload 'typep "cl-macs" "\
Check that OBJECT is of type TYPE.
TYPE is a Common Lisp-style type specifier.
\(fn FORM &optional SHOW-ARGS STRING &rest ARGS)" nil (quote macro))
-(autoload 'ignore-errors "cl-macs" "\
-Execute BODY; if an error occurs, return nil.
-Otherwise, return result of last form in BODY.
-
-\(fn &rest BODY)" nil (quote macro))
-
(autoload 'define-compiler-macro "cl-macs" "\
Define a compiler-only macro.
This is like `defmacro', but macro expansion occurs only if the call to
;;;;;; find nsubstitute-if-not nsubstitute-if nsubstitute substitute-if-not
;;;;;; substitute-if substitute delete-duplicates remove-duplicates
;;;;;; delete-if-not delete-if delete* remove-if-not remove-if remove*
-;;;;;; replace fill reduce) "cl-seq" "cl-seq.el" "c972a97c053d4e001ac1d1012c315b28")
+;;;;;; replace fill reduce) "cl-seq" "cl-seq.el" "b6529074e320e8a9f65b2461474d0c6a")
;;; Generated autoloads from cl-seq.el
-(autoload (quote reduce) "cl-seq" "\
+(autoload 'reduce "cl-seq" "\
Reduce two-argument FUNCTION across SEQ.
Keywords supported: :start :end :from-end :initial-value :key
\(fn FUNCTION SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote fill) "cl-seq" "\
+(autoload 'fill "cl-seq" "\
Fill the elements of SEQ with ITEM.
Keywords supported: :start :end
\(fn SEQ ITEM [KEYWORD VALUE]...)" nil nil)
-(autoload (quote replace) "cl-seq" "\
+(autoload 'replace "cl-seq" "\
Replace the elements of SEQ1 with the elements of SEQ2.
SEQ1 is destructively modified, then returned.
\(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil)
-(autoload (quote remove*) "cl-seq" "\
+(autoload 'remove* "cl-seq" "\
Remove all occurrences of ITEM in SEQ.
This is a non-destructive function; it makes a copy of SEQ if necessary
to avoid corrupting the original SEQ.
\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote remove-if) "cl-seq" "\
+(autoload 'remove-if "cl-seq" "\
Remove all items satisfying PREDICATE in SEQ.
This is a non-destructive function; it makes a copy of SEQ if necessary
to avoid corrupting the original SEQ.
\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote remove-if-not) "cl-seq" "\
+(autoload 'remove-if-not "cl-seq" "\
Remove all items not satisfying PREDICATE in SEQ.
This is a non-destructive function; it makes a copy of SEQ if necessary
to avoid corrupting the original SEQ.
\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote delete*) "cl-seq" "\
+(autoload 'delete* "cl-seq" "\
Remove all occurrences of ITEM in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.
\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote delete-if) "cl-seq" "\
+(autoload 'delete-if "cl-seq" "\
Remove all items satisfying PREDICATE in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.
\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote delete-if-not) "cl-seq" "\
+(autoload 'delete-if-not "cl-seq" "\
Remove all items not satisfying PREDICATE in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.
\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote remove-duplicates) "cl-seq" "\
+(autoload 'remove-duplicates "cl-seq" "\
Return a copy of SEQ with all duplicate elements removed.
Keywords supported: :test :test-not :key :start :end :from-end
\(fn SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote delete-duplicates) "cl-seq" "\
+(autoload 'delete-duplicates "cl-seq" "\
Remove all duplicate elements from SEQ (destructively).
Keywords supported: :test :test-not :key :start :end :from-end
\(fn SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote substitute) "cl-seq" "\
+(autoload 'substitute "cl-seq" "\
Substitute NEW for OLD in SEQ.
This is a non-destructive function; it makes a copy of SEQ if necessary
to avoid corrupting the original SEQ.
\(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote substitute-if) "cl-seq" "\
+(autoload 'substitute-if "cl-seq" "\
Substitute NEW for all items satisfying PREDICATE in SEQ.
This is a non-destructive function; it makes a copy of SEQ if necessary
to avoid corrupting the original SEQ.
\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote substitute-if-not) "cl-seq" "\
+(autoload 'substitute-if-not "cl-seq" "\
Substitute NEW for all items not satisfying PREDICATE in SEQ.
This is a non-destructive function; it makes a copy of SEQ if necessary
to avoid corrupting the original SEQ.
\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote nsubstitute) "cl-seq" "\
+(autoload 'nsubstitute "cl-seq" "\
Substitute NEW for OLD in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.
\(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote nsubstitute-if) "cl-seq" "\
+(autoload 'nsubstitute-if "cl-seq" "\
Substitute NEW for all items satisfying PREDICATE in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.
\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote nsubstitute-if-not) "cl-seq" "\
+(autoload 'nsubstitute-if-not "cl-seq" "\
Substitute NEW for all items not satisfying PREDICATE in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.
\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote find) "cl-seq" "\
+(autoload 'find "cl-seq" "\
Find the first occurrence of ITEM in SEQ.
Return the matching ITEM, or nil if not found.
\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote find-if) "cl-seq" "\
+(autoload 'find-if "cl-seq" "\
Find the first item satisfying PREDICATE in SEQ.
Return the matching item, or nil if not found.
\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote find-if-not) "cl-seq" "\
+(autoload 'find-if-not "cl-seq" "\
Find the first item not satisfying PREDICATE in SEQ.
Return the matching item, or nil if not found.
\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote position) "cl-seq" "\
+(autoload 'position "cl-seq" "\
Find the first occurrence of ITEM in SEQ.
Return the index of the matching item, or nil if not found.
\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote position-if) "cl-seq" "\
+(autoload 'position-if "cl-seq" "\
Find the first item satisfying PREDICATE in SEQ.
Return the index of the matching item, or nil if not found.
\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote position-if-not) "cl-seq" "\
+(autoload 'position-if-not "cl-seq" "\
Find the first item not satisfying PREDICATE in SEQ.
Return the index of the matching item, or nil if not found.
\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote count) "cl-seq" "\
+(autoload 'count "cl-seq" "\
Count the number of occurrences of ITEM in SEQ.
Keywords supported: :test :test-not :key :start :end
\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote count-if) "cl-seq" "\
+(autoload 'count-if "cl-seq" "\
Count the number of items satisfying PREDICATE in SEQ.
Keywords supported: :key :start :end
\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote count-if-not) "cl-seq" "\
+(autoload 'count-if-not "cl-seq" "\
Count the number of items not satisfying PREDICATE in SEQ.
Keywords supported: :key :start :end
\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
-(autoload (quote mismatch) "cl-seq" "\
+(autoload 'mismatch "cl-seq" "\
Compare SEQ1 with SEQ2, return index of first mismatching element.
Return nil if the sequences match. If one sequence is a prefix of the
other, the return value indicates the end of the shorter sequence.
\(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil)
-(autoload (quote search) "cl-seq" "\
+(autoload 'search "cl-seq" "\
Search for SEQ1 as a subsequence of SEQ2.
Return the index of the leftmost element of the first match found;
return nil if there are no matches.
\(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil)
-(autoload (quote sort*) "cl-seq" "\
+(autoload 'sort* "cl-seq" "\
Sort the argument SEQ according to PREDICATE.
This is a destructive function; it reuses the storage of SEQ if possible.
\(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil)
-(autoload (quote stable-sort) "cl-seq" "\
+(autoload 'stable-sort "cl-seq" "\
Sort the argument SEQ stably according to PREDICATE.
This is a destructive function; it reuses the storage of SEQ if possible.
\(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil)
-(autoload (quote merge) "cl-seq" "\
+(autoload 'merge "cl-seq" "\
Destructively merge the two sequences to produce a new sequence.
TYPE is the sequence type to return, SEQ1 and SEQ2 are the two argument
sequences, and PREDICATE is a `less-than' predicate on the elements.
\(fn TYPE SEQ1 SEQ2 PREDICATE [KEYWORD VALUE]...)" nil nil)
-(autoload (quote member*) "cl-seq" "\
+(autoload 'member* "cl-seq" "\
Find the first occurrence of ITEM in LIST.
Return the sublist of LIST whose car is ITEM.
\(fn ITEM LIST [KEYWORD VALUE]...)" nil nil)
-(autoload (quote member-if) "cl-seq" "\
+(autoload 'member-if "cl-seq" "\
Find the first item satisfying PREDICATE in LIST.
Return the sublist of LIST whose car matches.
\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
-(autoload (quote member-if-not) "cl-seq" "\
+(autoload 'member-if-not "cl-seq" "\
Find the first item not satisfying PREDICATE in LIST.
Return the sublist of LIST whose car matches.
\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
-(autoload (quote cl-adjoin) "cl-seq" "\
+(autoload 'cl-adjoin "cl-seq" "\
Not documented
\(fn CL-ITEM CL-LIST &rest CL-KEYS)" nil nil)
-(autoload (quote assoc*) "cl-seq" "\
+(autoload 'assoc* "cl-seq" "\
Find the first item whose car matches ITEM in LIST.
Keywords supported: :test :test-not :key
\(fn ITEM LIST [KEYWORD VALUE]...)" nil nil)
-(autoload (quote assoc-if) "cl-seq" "\
+(autoload 'assoc-if "cl-seq" "\
Find the first item whose car satisfies PREDICATE in LIST.
Keywords supported: :key
\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
-(autoload (quote assoc-if-not) "cl-seq" "\
+(autoload 'assoc-if-not "cl-seq" "\
Find the first item whose car does not satisfy PREDICATE in LIST.
Keywords supported: :key
\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
-(autoload (quote rassoc*) "cl-seq" "\
+(autoload 'rassoc* "cl-seq" "\
Find the first item whose cdr matches ITEM in LIST.
Keywords supported: :test :test-not :key
\(fn ITEM LIST [KEYWORD VALUE]...)" nil nil)
-(autoload (quote rassoc-if) "cl-seq" "\
+(autoload 'rassoc-if "cl-seq" "\
Find the first item whose cdr satisfies PREDICATE in LIST.
Keywords supported: :key
\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
-(autoload (quote rassoc-if-not) "cl-seq" "\
+(autoload 'rassoc-if-not "cl-seq" "\
Find the first item whose cdr does not satisfy PREDICATE in LIST.
Keywords supported: :key
\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
-(autoload (quote union) "cl-seq" "\
+(autoload 'union "cl-seq" "\
Combine LIST1 and LIST2 using a set-union operation.
The result list contains all items that appear in either LIST1 or LIST2.
This is a non-destructive function; it makes a copy of the data if necessary
\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
-(autoload (quote nunion) "cl-seq" "\
+(autoload 'nunion "cl-seq" "\
Combine LIST1 and LIST2 using a set-union operation.
The result list contains all items that appear in either LIST1 or LIST2.
This is a destructive function; it reuses the storage of LIST1 and LIST2
\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
-(autoload (quote intersection) "cl-seq" "\
+(autoload 'intersection "cl-seq" "\
Combine LIST1 and LIST2 using a set-intersection operation.
The result list contains all items that appear in both LIST1 and LIST2.
This is a non-destructive function; it makes a copy of the data if necessary
\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
-(autoload (quote nintersection) "cl-seq" "\
+(autoload 'nintersection "cl-seq" "\
Combine LIST1 and LIST2 using a set-intersection operation.
The result list contains all items that appear in both LIST1 and LIST2.
This is a destructive function; it reuses the storage of LIST1 and LIST2
\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
-(autoload (quote set-difference) "cl-seq" "\
+(autoload 'set-difference "cl-seq" "\
Combine LIST1 and LIST2 using a set-difference operation.
The result list contains all items that appear in LIST1 but not LIST2.
This is a non-destructive function; it makes a copy of the data if necessary
\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
-(autoload (quote nset-difference) "cl-seq" "\
+(autoload 'nset-difference "cl-seq" "\
Combine LIST1 and LIST2 using a set-difference operation.
The result list contains all items that appear in LIST1 but not LIST2.
This is a destructive function; it reuses the storage of LIST1 and LIST2
\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
-(autoload (quote set-exclusive-or) "cl-seq" "\
+(autoload 'set-exclusive-or "cl-seq" "\
Combine LIST1 and LIST2 using a set-exclusive-or operation.
The result list contains all items that appear in exactly one of LIST1, LIST2.
This is a non-destructive function; it makes a copy of the data if necessary
\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
-(autoload (quote nset-exclusive-or) "cl-seq" "\
+(autoload 'nset-exclusive-or "cl-seq" "\
Combine LIST1 and LIST2 using a set-exclusive-or operation.
The result list contains all items that appear in exactly one of LIST1, LIST2.
This is a destructive function; it reuses the storage of LIST1 and LIST2
\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
-(autoload (quote subsetp) "cl-seq" "\
+(autoload 'subsetp "cl-seq" "\
Return true if LIST1 is a subset of LIST2.
I.e., if every element of LIST1 also appears in LIST2.
\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
-(autoload (quote subst-if) "cl-seq" "\
+(autoload 'subst-if "cl-seq" "\
Substitute NEW for elements matching PREDICATE in TREE (non-destructively).
Return a copy of TREE with all matching elements replaced by NEW.
\(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil)
-(autoload (quote subst-if-not) "cl-seq" "\
+(autoload 'subst-if-not "cl-seq" "\
Substitute NEW for elts not matching PREDICATE in TREE (non-destructively).
Return a copy of TREE with all non-matching elements replaced by NEW.
\(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil)
-(autoload (quote nsubst) "cl-seq" "\
+(autoload 'nsubst "cl-seq" "\
Substitute NEW for OLD everywhere in TREE (destructively).
Any element of TREE which is `eql' to OLD is changed to NEW (via a call
to `setcar').
\(fn NEW OLD TREE [KEYWORD VALUE]...)" nil nil)
-(autoload (quote nsubst-if) "cl-seq" "\
+(autoload 'nsubst-if "cl-seq" "\
Substitute NEW for elements matching PREDICATE in TREE (destructively).
Any element of TREE which matches is changed to NEW (via a call to `setcar').
\(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil)
-(autoload (quote nsubst-if-not) "cl-seq" "\
+(autoload 'nsubst-if-not "cl-seq" "\
Substitute NEW for elements not matching PREDICATE in TREE (destructively).
Any element of TREE which matches is changed to NEW (via a call to `setcar').
\(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil)
-(autoload (quote sublis) "cl-seq" "\
+(autoload 'sublis "cl-seq" "\
Perform substitutions indicated by ALIST in TREE (non-destructively).
Return a copy of TREE with all matching elements replaced.
\(fn ALIST TREE [KEYWORD VALUE]...)" nil nil)
-(autoload (quote nsublis) "cl-seq" "\
+(autoload 'nsublis "cl-seq" "\
Perform substitutions indicated by ALIST in TREE (destructively).
Any matching element of TREE is changed via a call to `setcar'.
\(fn ALIST TREE [KEYWORD VALUE]...)" nil nil)
-(autoload (quote tree-equal) "cl-seq" "\
+(autoload 'tree-equal "cl-seq" "\
Return t if trees TREE1 and TREE2 have `eql' leaves.
Atoms are compared by `eql'; cons cells are compared recursively.