code.delx.au - gnu-emacs/blob - lisp/emacs-lisp/cl-loaddefs.el

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