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