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