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