lisp/emacs-lisp/cl-loaddefs.el

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