cl-loaddefs.el 40.5 KB
Newer Older
Stefan Monnier's avatar
Stefan Monnier committed
1 2 3 4 5 6 7 8 9 10 11 12
;;; cl-loaddefs.el --- automatically extracted autoloads
;;
;;; Code:


;;;### (autoloads (cl-prettyexpand cl-macroexpand-all cl-remprop
;;;;;;  cl-do-remf cl-set-getf getf get* tailp list-length nreconc
;;;;;;  revappend concatenate subseq cl-float-limits random-state-p
;;;;;;  make-random-state random* signum rem* mod* round* truncate*
;;;;;;  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
13
;;;;;;  cl-mapcar-many equalp coerce) "cl-extra" "cl-extra.el" "d93072a26c59f663a92b10df8bc28187")
Stefan Monnier's avatar
Stefan Monnier committed
14 15
;;; Generated autoloads from cl-extra.el

Glenn Morris's avatar
Glenn Morris committed
16
(autoload 'coerce "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
17 18 19 20 21
Coerce OBJECT to type TYPE.
TYPE is a Common Lisp type specifier.

\(fn OBJECT TYPE)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
22
(autoload 'equalp "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
23 24 25 26 27 28 29
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
strings case-insensitively.

\(fn X Y)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
30
(autoload 'cl-mapcar-many "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
31 32 33 34
Not documented

\(fn CL-FUNC CL-SEQS)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
35
(autoload 'map "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
36 37 38 39 40
Map a FUNCTION across one or more SEQUENCEs, returning a sequence.
TYPE is the sequence type to return.

\(fn TYPE FUNCTION SEQUENCE...)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
41
(autoload 'maplist "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
42 43 44 45 46 47
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)

Glenn Morris's avatar
Glenn Morris committed
48
(autoload 'mapl "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
49 50 51 52
Like `maplist', but does not accumulate values returned by the function.

\(fn FUNCTION LIST...)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
53
(autoload 'mapcan "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
54 55 56 57
Like `mapcar', but nconc's together the values returned by the function.

\(fn FUNCTION SEQUENCE...)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
58
(autoload 'mapcon "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
59 60 61 62
Like `maplist', but nconc's together the values returned by the function.

\(fn FUNCTION LIST...)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
63
(autoload 'some "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
64 65 66 67 68
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)

Glenn Morris's avatar
Glenn Morris committed
69
(autoload 'every "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
70 71 72 73
Return true if PREDICATE is true of every element of SEQ or SEQs.

\(fn PREDICATE SEQ...)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
74
(autoload 'notany "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
75 76 77 78
Return true if PREDICATE is false of every element of SEQ or SEQs.

\(fn PREDICATE SEQ...)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
79
(autoload 'notevery "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
80 81 82 83
Return true if PREDICATE is false of some element of SEQ or SEQs.

\(fn PREDICATE SEQ...)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
84
(defalias 'cl-map-keymap 'map-keymap)
Stefan Monnier's avatar
Stefan Monnier committed
85

Glenn Morris's avatar
Glenn Morris committed
86
(autoload 'cl-map-keymap-recursively "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
87 88 89 90
Not documented

\(fn CL-FUNC-REC CL-MAP &optional CL-BASE)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
91
(autoload 'cl-map-intervals "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
92 93 94 95
Not documented

\(fn CL-FUNC &optional CL-WHAT CL-PROP CL-START CL-END)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
96
(autoload 'cl-map-overlays "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
97 98 99 100
Not documented

\(fn CL-FUNC &optional CL-BUFFER CL-START CL-END CL-ARG)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
101
(autoload 'cl-set-frame-visible-p "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
102 103 104 105
Not documented

\(fn FRAME VAL)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
106
(autoload 'cl-progv-before "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
107 108 109 110
Not documented

\(fn SYMS VALUES)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
111
(autoload 'gcd "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
112 113 114 115
Return the greatest common divisor of the arguments.

\(fn &rest ARGS)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
116
(autoload 'lcm "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
117 118 119 120
Return the least common multiple of the arguments.

\(fn &rest ARGS)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
121
(autoload 'isqrt "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
122 123 124 125
Return the integer square root of the argument.

\(fn X)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
126
(autoload 'floor* "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
127 128 129 130 131
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)

Glenn Morris's avatar
Glenn Morris committed
132
(autoload 'ceiling* "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
133 134 135 136 137
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)

Glenn Morris's avatar
Glenn Morris committed
138
(autoload 'truncate* "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
139 140 141 142 143
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)

Glenn Morris's avatar
Glenn Morris committed
144
(autoload 'round* "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
145 146 147 148 149
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)

Glenn Morris's avatar
Glenn Morris committed
150
(autoload 'mod* "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
151 152 153 154
The remainder of X divided by Y, with the same sign as Y.

\(fn X Y)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
155
(autoload 'rem* "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
156 157 158 159
The remainder of X divided by Y, with the same sign as X.

\(fn X Y)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
160
(autoload 'signum "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
161 162 163 164
Return 1 if X is positive, -1 if negative, 0 if zero.

\(fn X)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
165
(autoload 'random* "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
166 167 168 169 170
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)

Glenn Morris's avatar
Glenn Morris committed
171
(autoload 'make-random-state "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
172 173 174 175 176
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)

Glenn Morris's avatar
Glenn Morris committed
177
(autoload 'random-state-p "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
178 179 180 181
Return t if OBJECT is a random-state object.

\(fn OBJECT)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
182
(autoload 'cl-float-limits "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
183 184 185 186
Not documented

\(fn)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
187
(autoload 'subseq "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
188 189 190 191 192 193
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)

Glenn Morris's avatar
Glenn Morris committed
194
(autoload 'concatenate "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
195 196 197 198
Concatenate, into a sequence of type TYPE, the argument SEQUENCEs.

\(fn TYPE SEQUENCE...)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
199
(autoload 'revappend "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
200 201 202 203
Equivalent to (append (reverse X) Y).

\(fn X Y)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
204
(autoload 'nreconc "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
205 206 207 208
Equivalent to (nconc (nreverse X) Y).

\(fn X Y)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
209
(autoload 'list-length "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
210 211 212 213
Return the length of list X.  Return nil if list is circular.

\(fn X)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
214
(autoload 'tailp "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
215 216 217 218
Return true if SUBLIST is a tail of LIST.

\(fn SUBLIST LIST)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
219
(autoload 'get* "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
220 221 222 223
Return the value of SYMBOL's PROPNAME property, or DEFAULT if none.

\(fn SYMBOL PROPNAME &optional DEFAULT)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
224
(autoload 'getf "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
225 226 227 228 229
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)

Glenn Morris's avatar
Glenn Morris committed
230
(autoload 'cl-set-getf "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
231 232 233 234
Not documented

\(fn PLIST TAG VAL)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
235
(autoload 'cl-do-remf "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
236 237 238 239
Not documented

\(fn PLIST TAG)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
240
(autoload 'cl-remprop "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
241 242 243 244
Remove from SYMBOL's plist the property PROPNAME and its value.

\(fn SYMBOL PROPNAME)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
245
(defalias 'remprop 'cl-remprop)
Stefan Monnier's avatar
Stefan Monnier committed
246

Glenn Morris's avatar
Glenn Morris committed
247
(defalias 'cl-gethash 'gethash)
Stefan Monnier's avatar
Stefan Monnier committed
248

Glenn Morris's avatar
Glenn Morris committed
249
(defalias 'cl-puthash 'puthash)
Stefan Monnier's avatar
Stefan Monnier committed
250

Glenn Morris's avatar
Glenn Morris committed
251
(defalias 'cl-remhash 'remhash)
Stefan Monnier's avatar
Stefan Monnier committed
252

Glenn Morris's avatar
Glenn Morris committed
253
(defalias 'cl-clrhash 'clrhash)
Stefan Monnier's avatar
Stefan Monnier committed
254

Glenn Morris's avatar
Glenn Morris committed
255
(defalias 'cl-maphash 'maphash)
Stefan Monnier's avatar
Stefan Monnier committed
256

Glenn Morris's avatar
Glenn Morris committed
257
(defalias 'cl-make-hash-table 'make-hash-table)
Stefan Monnier's avatar
Stefan Monnier committed
258

Glenn Morris's avatar
Glenn Morris committed
259
(defalias 'cl-hash-table-p 'hash-table-p)
Stefan Monnier's avatar
Stefan Monnier committed
260

Glenn Morris's avatar
Glenn Morris committed
261
(defalias 'cl-hash-table-count 'hash-table-count)
Stefan Monnier's avatar
Stefan Monnier committed
262

Glenn Morris's avatar
Glenn Morris committed
263
(autoload 'cl-macroexpand-all "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
264 265 266 267 268
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)

Glenn Morris's avatar
Glenn Morris committed
269
(autoload 'cl-prettyexpand "cl-extra" "\
Stefan Monnier's avatar
Stefan Monnier committed
270 271 272 273 274 275
Not documented

\(fn FORM &optional FULL)" nil nil)

;;;***

Glenn Morris's avatar
Glenn Morris committed
276 277
;;;### (autoloads (defsubst* compiler-macroexpand define-compiler-macro
;;;;;;  assert check-type typep deftype cl-struct-setf-expander defstruct
278 279 280 281 282 283 284
;;;;;;  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
;;;;;;  lexical-let* lexical-let symbol-macrolet macrolet labels
;;;;;;  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*
Andreas Schwab's avatar
Andreas Schwab committed
285
;;;;;;  defmacro* defun* gentemp gensym) "cl-macs" "cl-macs.el" "49b7d96626dd8ba5d39551909edbd4c7")
Stefan Monnier's avatar
Stefan Monnier committed
286 287
;;; Generated autoloads from cl-macs.el

Glenn Morris's avatar
Glenn Morris committed
288
(autoload 'gensym "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
289 290 291 292 293
Generate a new uninterned symbol.
The name is made by appending a number to PREFIX, default \"G\".

\(fn &optional PREFIX)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
294
(autoload 'gentemp "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
295 296 297 298 299
Generate a new interned symbol with a unique name.
The name is made by appending a number to PREFIX, default \"G\".

\(fn &optional PREFIX)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
300
(autoload 'defun* "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
301 302 303 304 305 306
Define NAME as a function.
Like normal `defun', except ARGLIST allows full Common Lisp conventions,
and BODY is implicitly surrounded by (block NAME ...).

\(fn NAME ARGLIST [DOCSTRING] BODY...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
307
(autoload 'defmacro* "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
308 309 310 311 312 313
Define NAME as a macro.
Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
and BODY is implicitly surrounded by (block NAME ...).

\(fn NAME ARGLIST [DOCSTRING] BODY...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
314
(autoload 'function* "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
315 316 317 318 319 320
Introduce a function.
Like normal `function', except that if argument is a lambda form,
its argument list allows full Common Lisp conventions.

\(fn FUNC)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
321
(autoload 'destructuring-bind "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
322 323 324 325
Not documented

\(fn ARGS EXPR &rest BODY)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
326
(autoload 'eval-when "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
327 328 329 330 331 332 333
Control when BODY is evaluated.
If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
If `load' is in WHEN, BODY is evaluated when loaded after top-level compile.
If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level.

\(fn (WHEN...) BODY...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
334
(autoload 'load-time-value "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
335 336 337 338 339
Like `progn', but evaluates the body at load time.
The result of the body appears to the compiler as a quoted constant.

\(fn FORM &optional READ-ONLY)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
340
(autoload 'case "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
341 342 343 344 345 346 347 348 349 350
Eval EXPR and choose among clauses on that value.
Each clause looks like (KEYLIST BODY...).  EXPR is evaluated and compared
against each key in each KEYLIST; the corresponding BODY is evaluated.
If no clause succeeds, case returns nil.  A single atom may be used in
place of a KEYLIST of one atom.  A KEYLIST of t or `otherwise' is
allowed only in the final clause, and matches if no other keys match.
Key values are compared by `eql'.

\(fn EXPR (KEYLIST BODY...)...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
351
(autoload 'ecase "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
352 353 354 355 356
Like `case', but error if no case fits.
`otherwise'-clauses are not allowed.

\(fn EXPR (KEYLIST BODY...)...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
357
(autoload 'typecase "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
358 359 360 361 362 363 364 365
Evals EXPR, chooses among clauses on that value.
Each clause looks like (TYPE BODY...).  EXPR is evaluated and, if it
satisfies TYPE, the corresponding BODY is evaluated.  If no clause succeeds,
typecase returns nil.  A TYPE of t or `otherwise' is allowed only in the
final clause, and matches if no other keys match.

\(fn EXPR (TYPE BODY...)...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
366
(autoload 'etypecase "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
367 368 369 370 371
Like `typecase', but error if no case fits.
`otherwise'-clauses are not allowed.

\(fn EXPR (TYPE BODY...)...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
372
(autoload 'block "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
373 374 375 376 377 378 379 380 381 382 383
Define a lexically-scoped block named NAME.
NAME may be any symbol.  Code inside the BODY forms can call `return-from'
to jump prematurely out of the block.  This differs from `catch' and `throw'
in two respects:  First, the NAME is an unevaluated symbol rather than a
quoted symbol or other form; and second, NAME is lexically rather than
dynamically scoped:  Only references to it within BODY will work.  These
references may appear inside macro expansions, but not inside functions
called from BODY.

\(fn NAME &rest BODY)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
384
(autoload 'return "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
385 386 387 388 389
Return from the block named nil.
This is equivalent to `(return-from nil RESULT)'.

\(fn &optional RESULT)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
390
(autoload 'return-from "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
391 392 393 394 395 396 397 398
Return from the block named NAME.
This jump out to the innermost enclosing `(block NAME ...)' form,
returning RESULT from that form (or nil if RESULT is omitted).
This is compatible with Common Lisp, but note that `defun' and
`defmacro' do not create implicit blocks as they do in Common Lisp.

\(fn NAME &optional RESULT)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
399
(autoload 'loop "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414
The Common Lisp `loop' macro.
Valid clauses are:
  for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM,
  for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR,
  for VAR across ARRAY, repeat NUM, with VAR = INIT, while COND, until COND,
  always COND, never COND, thereis COND, collect EXPR into VAR,
  append EXPR into VAR, nconc EXPR into VAR, sum EXPR into VAR,
  count EXPR into VAR, maximize EXPR into VAR, minimize EXPR into VAR,
  if COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
  unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
  do EXPRS..., initially EXPRS..., finally EXPRS..., return EXPR,
  finally return EXPR, named NAME.

\(fn CLAUSE...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
415
(autoload 'do "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
416 417 418 419
The Common Lisp `do' loop.

\(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
420
(autoload 'do* "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
421 422 423 424
The Common Lisp `do*' loop.

\(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
425
(autoload 'dolist "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
426 427 428 429 430 431
Loop over a list.
Evaluate BODY with VAR bound to each `car' from LIST, in turn.
Then evaluate RESULT to get return value, default nil.

\(fn (VAR LIST [RESULT]) BODY...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
432
(autoload 'dotimes "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
433 434 435 436 437 438 439
Loop a certain number of times.
Evaluate BODY with VAR bound to successive integers from 0, inclusive,
to COUNT, exclusive.  Then evaluate RESULT to get return value, default
nil.

\(fn (VAR COUNT [RESULT]) BODY...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
440
(autoload 'do-symbols "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
441 442 443 444 445 446
Loop over all symbols.
Evaluate BODY with VAR bound to each interned symbol, or to each symbol
from OBARRAY.

\(fn (VAR [OBARRAY [RESULT]]) BODY...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
447
(autoload 'do-all-symbols "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
448 449 450 451
Not documented

\(fn SPEC &rest BODY)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
452
(autoload 'psetq "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
453 454 455 456 457 458
Set SYMs to the values VALs in parallel.
This is like `setq', except that all VAL forms are evaluated (in order)
before assigning any symbols SYM to the corresponding values.

\(fn SYM VAL SYM VAL ...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
459
(autoload 'progv "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
460 461 462 463 464 465 466 467 468
Bind SYMBOLS to VALUES dynamically in BODY.
The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
Each symbol in the first list is bound to the corresponding value in the
second list (or made unbound if VALUES is shorter than SYMBOLS); then the
BODY forms are executed and their result is returned.  This is much like
a `let' form, except that the list of symbols can be computed at run-time.

\(fn SYMBOLS VALUES &rest BODY)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
469
(autoload 'flet "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
470 471 472 473 474 475 476 477
Make temporary function definitions.
This is an analogue of `let' that operates on the function cell of FUNC
rather than its value cell.  The FORMs are evaluated with the specified
function definitions in place, then the definitions are undone (the FUNCs
go back to their previous definitions, or lack thereof).

\(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
478
(autoload 'labels "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
479 480 481 482 483 484
Make temporary function bindings.
This is like `flet', except the bindings are lexical instead of dynamic.
Unlike `flet', this macro is fully compliant with the Common Lisp standard.

\(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
485
(autoload 'macrolet "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
486 487 488 489 490
Make temporary macro definitions.
This is like `flet', but for macros instead of functions.

\(fn ((NAME ARGLIST BODY...) ...) FORM...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
491
(autoload 'symbol-macrolet "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
492 493 494 495 496 497
Make symbol macro definitions.
Within the body FORMs, references to the variable NAME will be replaced
by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...).

\(fn ((NAME EXPANSION) ...) FORM...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
498
(autoload 'lexical-let "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
499 500 501 502 503 504
Like `let', but lexically scoped.
The main visible difference is that lambdas inside BODY will create
lexical closures as in Common Lisp.

\(fn VARLIST BODY)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
505
(autoload 'lexical-let* "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
506
Like `let*', but lexically scoped.
Juanma Barranquero's avatar
Update.  
Juanma Barranquero committed
507 508 509 510
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.
Stefan Monnier's avatar
Stefan Monnier committed
511 512 513

\(fn VARLIST BODY)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
514
(autoload 'multiple-value-bind "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
515 516 517 518 519 520 521 522 523
Collect multiple return values.
FORM must return a list; the BODY is then executed with the first N elements
of this list bound (`let'-style) to each of the symbols SYM in turn.  This
is analogous to the Common Lisp `multiple-value-bind' macro, using lists to
simulate true multiple return values.  For compatibility, (values A B C) is
a synonym for (list A B C).

\(fn (SYM...) FORM BODY)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
524
(autoload 'multiple-value-setq "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
525 526 527 528 529 530 531 532
Collect multiple return values.
FORM must return a list; the first N elements of this list are stored in
each of the symbols SYM in turn.  This is analogous to the Common Lisp
`multiple-value-setq' macro, using lists to simulate true multiple return
values.  For compatibility, (values A B C) is a synonym for (list A B C).

\(fn (SYM...) FORM)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
533
(autoload 'locally "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
534 535 536 537
Not documented

\(fn &rest BODY)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
538
(autoload 'the "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
539 540 541 542
Not documented

\(fn TYPE FORM)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
543
(autoload 'declare "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
544 545 546 547
Not documented

\(fn &rest SPECS)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
548
(autoload 'define-setf-method "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
549 550 551 552 553 554 555 556 557 558
Define a `setf' method.
This method shows how to handle `setf's to places of the form (NAME ARGS...).
The argument forms ARGS are bound according to ARGLIST, as if NAME were
going to be expanded as a macro, then the BODY forms are executed and must
return a list of five elements: a temporary-variables list, a value-forms
list, a store-variables list (of length one), a store-form, and an access-
form.  See `defsetf' for a simpler way to define most setf-methods.

\(fn NAME ARGLIST BODY...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
559
(autoload 'defsetf "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
560
Define a `setf' method.
Stefan Monnier's avatar
Stefan Monnier committed
561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579
This macro is an easy-to-use substitute for `define-setf-method' that works
well for simple place forms.  In the simple `defsetf' form, `setf's of
the form (setf (NAME ARGS...) VAL) are transformed to function or macro
calls of the form (FUNC ARGS... VAL).  Example:

  (defsetf aref aset)

Alternate form: (defsetf NAME ARGLIST (STORE) BODY...).
Here, the above `setf' call is expanded by binding the argument forms ARGS
according to ARGLIST, binding the value form VAL to STORE, then executing
BODY, which must return a Lisp form that does the necessary `setf' operation.
Actually, ARGLIST and STORE may be bound to temporary variables which are
introduced automatically to preserve proper execution order of the arguments.
Example:

  (defsetf nth (n x) (v) (list 'setcar (list 'nthcdr n x) v))

\(fn NAME [FUNC | ARGLIST (STORE) BODY...])" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
580
(autoload 'get-setf-method "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
581 582 583 584 585 586
Return a list of five values describing the setf-method for PLACE.
PLACE may be any Lisp form which can appear as the PLACE argument to
a macro like `setf' or `incf'.

\(fn PLACE &optional ENV)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
587
(autoload 'setf "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
588 589 590 591 592 593 594 595
Set each PLACE to the value of its VAL.
This is a generalized version of `setq'; the PLACEs may be symbolic
references such as (car x) or (aref x i), as well as plain symbols.
For example, (setf (cadar x) y) is equivalent to (setcar (cdar x) y).
The return value is the last VAL in the list.

\(fn PLACE VAL PLACE VAL ...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
596
(autoload 'psetf "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
597 598 599 600 601 602
Set PLACEs to the values VALs in parallel.
This is like `setf', except that all VAL forms are evaluated (in order)
before assigning any PLACEs to the corresponding values.

\(fn PLACE VAL PLACE VAL ...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
603
(autoload 'cl-do-pop "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
604 605 606 607
Not documented

\(fn PLACE)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
608
(autoload 'remf "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
609 610 611 612 613 614
Remove TAG from property list PLACE.
PLACE may be a symbol, or any generalized variable allowed by `setf'.
The form returns true if TAG was found and removed, nil otherwise.

\(fn PLACE TAG)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
615
(autoload 'shiftf "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
616 617 618 619 620 621
Shift left among PLACEs.
Example: (shiftf A B C) sets A to B, B to C, and returns the old A.
Each PLACE may be a symbol, or any generalized variable allowed by `setf'.

\(fn PLACE... VAL)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
622
(autoload 'rotatef "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
623 624 625 626 627 628
Rotate left among PLACEs.
Example: (rotatef A B C) sets A to B, B to C, and C to A.  It returns nil.
Each PLACE may be a symbol, or any generalized variable allowed by `setf'.

\(fn PLACE...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
629
(autoload 'letf "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
630 631 632 633 634 635 636 637 638 639 640
Temporarily bind to PLACEs.
This is the analogue of `let', but with generalized variables (in the
sense of `setf') for the PLACEs.  Each PLACE is set to the corresponding
VALUE, then the BODY forms are executed.  On exit, either normally or
because of a `throw' or error, the PLACEs are set back to their original
values.  Note that this macro is *not* available in Common Lisp.
As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
the PLACE is not modified before executing BODY.

\(fn ((PLACE VALUE) ...) BODY...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
641
(autoload 'letf* "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
642 643 644 645 646 647 648 649 650 651 652
Temporarily bind to PLACEs.
This is the analogue of `let*', but with generalized variables (in the
sense of `setf') for the PLACEs.  Each PLACE is set to the corresponding
VALUE, then the BODY forms are executed.  On exit, either normally or
because of a `throw' or error, the PLACEs are set back to their original
values.  Note that this macro is *not* available in Common Lisp.
As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
the PLACE is not modified before executing BODY.

\(fn ((PLACE VALUE) ...) BODY...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
653
(autoload 'callf "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
654 655 656 657 658 659
Set PLACE to (FUNC PLACE ARGS...).
FUNC should be an unquoted function name.  PLACE may be a symbol,
or any generalized variable allowed by `setf'.

\(fn FUNC PLACE ARGS...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
660
(autoload 'callf2 "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
661 662 663 664 665
Set PLACE to (FUNC ARG1 PLACE ARGS...).
Like `callf', but PLACE is the second argument of FUNC, not the first.

\(fn FUNC ARG1 PLACE ARGS...)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
666
(autoload 'define-modify-macro "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
667 668 669 670 671 672
Define a `setf'-like modify macro.
If NAME is called, it combines its PLACE argument with the other arguments
from ARGLIST using FUNC: (define-modify-macro incf (&optional (n 1)) +)

\(fn NAME ARGLIST FUNC &optional DOC)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
673
(autoload 'defstruct "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
674
Define a struct type.
675 676 677 678
This macro defines a new data type called NAME that stores data
in SLOTs.  It defines a `make-NAME' constructor, a `copy-NAME'
copier, a `NAME-p' predicate, and slot accessors named `NAME-SLOT'.
You can use the accessors to set the corresponding slots, via `setf'.
Stefan Monnier's avatar
Stefan Monnier committed
679

680 681 682 683 684 685 686 687 688 689
NAME may instead take the form (NAME OPTIONS...), where each
OPTION is either a single keyword or (KEYWORD VALUE).
See Info node `(cl)Structures' for a list of valid keywords.

Each SLOT may instead take the form (SLOT SLOT-OPTS...), where
SLOT-OPTS are keyword-value pairs for that slot.  Currently, only
one keyword is supported, `:read-only'.  If this has a non-nil
value, that slot cannot be set via `setf'.

\(fn NAME SLOTS...)" nil (quote macro))
Stefan Monnier's avatar
Stefan Monnier committed
690

Glenn Morris's avatar
Glenn Morris committed
691
(autoload 'cl-struct-setf-expander "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
692 693 694 695
Not documented

\(fn X NAME ACCESSOR PRED-FORM POS)" nil nil)

696 697 698 699 700 701
(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))

Glenn Morris's avatar
Glenn Morris committed
702
(autoload 'typep "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
703 704 705 706 707
Check that OBJECT is of type TYPE.
TYPE is a Common Lisp-style type specifier.

\(fn OBJECT TYPE)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
708
(autoload 'check-type "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
709 710 711 712 713
Verify that FORM is of type TYPE; signal an error if not.
STRING is an optional description of the desired type.

\(fn FORM TYPE &optional STRING)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
714
(autoload 'assert "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
715 716 717 718 719 720 721 722
Verify that FORM returns non-nil; signal an error if not.
Second arg SHOW-ARGS means to include arguments of FORM in message.
Other args STRING and ARGS... are arguments to be passed to `error'.
They are not evaluated unless the assertion fails.  If STRING is
omitted, a default message listing FORM itself is used.

\(fn FORM &optional SHOW-ARGS STRING &rest ARGS)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
723
(autoload 'define-compiler-macro "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
724 725 726 727 728 729 730 731 732 733 734 735 736
Define a compiler-only macro.
This is like `defmacro', but macro expansion occurs only if the call to
FUNC is compiled (i.e., not interpreted).  Compiler macros should be used
for optimizing the way calls to FUNC are compiled; the form returned by
BODY should do the same thing as a call to the normal function called
FUNC, though possibly more efficiently.  Note that, like regular macros,
compiler macros are expanded repeatedly until no further expansions are
possible.  Unlike regular macros, BODY can decide to \"punt\" and leave the
original function call alone by declaring an initial `&whole foo' parameter
and then returning foo.

\(fn FUNC ARGS &rest BODY)" nil (quote macro))

Glenn Morris's avatar
Glenn Morris committed
737
(autoload 'compiler-macroexpand "cl-macs" "\
Stefan Monnier's avatar
Stefan Monnier committed
738 739 740 741
Not documented

\(fn FORM)" nil nil)

Glenn Morris's avatar
Glenn Morris committed
742 743 744 745 746 747 748 749
(autoload 'defsubst* "cl-macs" "\
Define NAME as a function.
Like `defun', except the function is automatically declared `inline',
ARGLIST allows full Common Lisp conventions, and BODY is implicitly
surrounded by (block NAME ...).

\(fn NAME ARGLIST [DOCSTRING] BODY...)" nil (quote macro))

Stefan Monnier's avatar
Stefan Monnier committed
750 751 752 753 754 755 756 757 758 759 760 761
;;;***

;;;### (autoloads (tree-equal nsublis sublis nsubst-if-not nsubst-if
;;;;;;  nsubst subst-if-not subst-if subsetp nset-exclusive-or set-exclusive-or
;;;;;;  nset-difference set-difference nintersection intersection
;;;;;;  nunion union rassoc-if-not rassoc-if rassoc* assoc-if-not
;;;;;;  assoc-if assoc* cl-adjoin member-if-not member-if member*
;;;;;;  merge stable-sort sort* search mismatch count-if-not count-if
;;;;;;  count position-if-not position-if position find-if-not find-if
;;;;;;  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*
762
;;;;;;  replace fill reduce) "cl-seq" "cl-seq.el" "ec3ea1c77742734db8496272fe5721be")
Stefan Monnier's avatar
Stefan Monnier committed
763 764
;;; Generated autoloads from cl-seq.el

765
(autoload 'reduce "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
766 767 768 769 770 771
Reduce two-argument FUNCTION across SEQ.

Keywords supported:  :start :end :from-end :initial-value :key

\(fn FUNCTION SEQ [KEYWORD VALUE]...)" nil nil)

772
(autoload 'fill "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
773 774 775 776 777 778
Fill the elements of SEQ with ITEM.

Keywords supported:  :start :end

\(fn SEQ ITEM [KEYWORD VALUE]...)" nil nil)

779
(autoload 'replace "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
780 781 782 783 784 785 786
Replace the elements of SEQ1 with the elements of SEQ2.
SEQ1 is destructively modified, then returned.

Keywords supported:  :start1 :end1 :start2 :end2

\(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil)

787
(autoload 'remove* "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
788 789 790 791 792 793 794 795
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.

Keywords supported:  :test :test-not :key :count :start :end :from-end

\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)

796
(autoload 'remove-if "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
797 798 799 800 801 802 803 804
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.

Keywords supported:  :key :count :start :end :from-end

\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)

805
(autoload 'remove-if-not "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
806 807 808 809 810 811 812 813
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.

Keywords supported:  :key :count :start :end :from-end

\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)

814
(autoload 'delete* "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
815 816 817 818 819 820 821
Remove all occurrences of ITEM in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.

Keywords supported:  :test :test-not :key :count :start :end :from-end

\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)

822
(autoload 'delete-if "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
823 824 825 826 827 828 829
Remove all items satisfying PREDICATE in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.

Keywords supported:  :key :count :start :end :from-end

\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)

830
(autoload 'delete-if-not "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
831 832 833 834 835 836 837
Remove all items not satisfying PREDICATE in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.

Keywords supported:  :key :count :start :end :from-end

\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)

838
(autoload 'remove-duplicates "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
839 840 841 842 843 844
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)

845
(autoload 'delete-duplicates "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
846 847 848 849 850 851
Remove all duplicate elements from SEQ (destructively).

Keywords supported:  :test :test-not :key :start :end :from-end

\(fn SEQ [KEYWORD VALUE]...)" nil nil)

852
(autoload 'substitute "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
853 854 855 856 857 858 859 860
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.

Keywords supported:  :test :test-not :key :count :start :end :from-end

\(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil)

861
(autoload 'substitute-if "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
862 863 864 865 866 867 868 869
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.

Keywords supported:  :key :count :start :end :from-end

\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)

870
(autoload 'substitute-if-not "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
871 872 873 874 875 876 877 878
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.

Keywords supported:  :key :count :start :end :from-end

\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)

879
(autoload 'nsubstitute "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
880 881 882 883 884 885 886
Substitute NEW for OLD in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.

Keywords supported:  :test :test-not :key :count :start :end :from-end

\(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil)

887
(autoload 'nsubstitute-if "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
888 889 890 891 892 893 894
Substitute NEW for all items satisfying PREDICATE in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.

Keywords supported:  :key :count :start :end :from-end

\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)

895
(autoload 'nsubstitute-if-not "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
896 897 898 899 900 901 902
Substitute NEW for all items not satisfying PREDICATE in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.

Keywords supported:  :key :count :start :end :from-end

\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)

903
(autoload 'find "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
904 905 906 907 908 909 910
Find the first occurrence of ITEM in SEQ.
Return the matching ITEM, or nil if not found.

Keywords supported:  :test :test-not :key :start :end :from-end

\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)

911
(autoload 'find-if "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
912 913 914 915 916 917 918
Find the first item satisfying PREDICATE in SEQ.
Return the matching item, or nil if not found.

Keywords supported:  :key :start :end :from-end

\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)

919
(autoload 'find-if-not "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
920 921 922 923 924 925 926
Find the first item not satisfying PREDICATE in SEQ.
Return the matching item, or nil if not found.

Keywords supported:  :key :start :end :from-end

\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)

927
(autoload 'position "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
928 929 930 931 932 933 934
Find the first occurrence of ITEM in SEQ.
Return the index of the matching item, or nil if not found.

Keywords supported:  :test :test-not :key :start :end :from-end

\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)

935
(autoload 'position-if "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
936 937 938 939 940 941 942
Find the first item satisfying PREDICATE in SEQ.
Return the index of the matching item, or nil if not found.

Keywords supported:  :key :start :end :from-end

\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)

943
(autoload 'position-if-not "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
944 945 946 947 948 949 950
Find the first item not satisfying PREDICATE in SEQ.
Return the index of the matching item, or nil if not found.

Keywords supported:  :key :start :end :from-end

\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)

951
(autoload 'count "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
952 953 954 955 956 957
Count the number of occurrences of ITEM in SEQ.

Keywords supported:  :test :test-not :key :start :end

\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)

958
(autoload 'count-if "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
959 960 961 962 963 964
Count the number of items satisfying PREDICATE in SEQ.

Keywords supported:  :key :start :end

\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)

965
(autoload 'count-if-not "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
966 967 968 969 970 971
Count the number of items not satisfying PREDICATE in SEQ.

Keywords supported:  :key :start :end

\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)

972
(autoload 'mismatch "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
973 974 975 976 977 978 979 980
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.

Keywords supported:  :test :test-not :key :start1 :end1 :start2 :end2 :from-end

\(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil)

981
(autoload 'search "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
982 983 984 985 986 987 988 989
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.

Keywords supported:  :test :test-not :key :start1 :end1 :start2 :end2 :from-end

\(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil)

990
(autoload 'sort* "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
991 992 993 994 995 996 997
Sort the argument SEQ according to PREDICATE.
This is a destructive function; it reuses the storage of SEQ if possible.

Keywords supported:  :key

\(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil)

998
(autoload 'stable-sort "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
999 1000 1001 1002 1003 1004 1005
Sort the argument SEQ stably according to PREDICATE.
This is a destructive function; it reuses the storage of SEQ if possible.

Keywords supported:  :key

\(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil)

1006
(autoload 'merge "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
1007 1008 1009 1010 1011 1012 1013 1014
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.

Keywords supported:  :key

\(fn TYPE SEQ1 SEQ2 PREDICATE [KEYWORD VALUE]...)" nil nil)

1015
(autoload 'member* "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
1016 1017 1018 1019 1020 1021 1022
Find the first occurrence of ITEM in LIST.
Return the sublist of LIST whose car is ITEM.

Keywords supported:  :test :test-not :key

\(fn ITEM LIST [KEYWORD VALUE]...)" nil nil)

1023
(autoload 'member-if "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
1024 1025 1026 1027 1028 1029 1030
Find the first item satisfying PREDICATE in LIST.
Return the sublist of LIST whose car matches.

Keywords supported:  :key

\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)

1031
(autoload 'member-if-not "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
1032 1033 1034 1035 1036 1037 1038
Find the first item not satisfying PREDICATE in LIST.
Return the sublist of LIST whose car matches.

Keywords supported:  :key

\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)

1039
(autoload 'cl-adjoin "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
1040 1041 1042 1043
Not documented

\(fn CL-ITEM CL-LIST &rest CL-KEYS)" nil nil)

1044
(autoload 'assoc* "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
1045 1046 1047 1048 1049 1050
Find the first item whose car matches ITEM in LIST.

Keywords supported:  :test :test-not :key

\(fn ITEM LIST [KEYWORD VALUE]...)" nil nil)

1051
(autoload 'assoc-if "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
1052 1053 1054 1055 1056 1057
Find the first item whose car satisfies PREDICATE in LIST.

Keywords supported:  :key

\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)

1058
(autoload 'assoc-if-not "cl-seq" "\
Stefan Monnier's avatar
Stefan Monnier committed
1059 1060 1061 1062 1063 1064
Find the first item whose car does not satisfy PREDICATE in LIST.

Keywords supported:  :key

\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)

1065
(autoload 'rassoc* "cl-seq" "\