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