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-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 ;;;;;;  "41a15289eda7e6ae03ac9edd86bbb1a6")
 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-labels "cl-macs" "\
 496 Make temporary function bindings.
 497 The bindings can be recursive.  Assumes the use of `lexical-binding'.
 498
 499 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil t)
 500
 501 (put 'cl-labels 'lisp-indent-function '1)
 502
 503 (autoload 'cl-macrolet "cl-macs" "\
 504 Make temporary macro definitions.
 505 This is like `cl-flet', but for macros instead of functions.
 506
 507 \(fn ((NAME ARGLIST BODY...) ...) FORM...)" nil t)
 508
 509 (put 'cl-macrolet 'lisp-indent-function '1)
 510
 511 (autoload 'cl-symbol-macrolet "cl-macs" "\
 512 Make symbol macro definitions.
 513 Within the body FORMs, references to the variable NAME will be replaced
 514 by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...).
 515
 516 \(fn ((NAME EXPANSION) ...) FORM...)" nil t)
 517
 518 (put 'cl-symbol-macrolet 'lisp-indent-function '1)
 519
 520 (autoload 'cl-multiple-value-bind "cl-macs" "\
 521 Collect multiple return values.
 522 FORM must return a list; the BODY is then executed with the first N elements
 523 of this list bound (`let'-style) to each of the symbols SYM in turn.  This
 524 is analogous to the Common Lisp `cl-multiple-value-bind' macro, using lists to
 525 simulate true multiple return values.  For compatibility, (cl-values A B C) is
 526 a synonym for (list A B C).
 527
 528 \(fn (SYM...) FORM BODY)" nil t)
 529
 530 (put 'cl-multiple-value-bind 'lisp-indent-function '2)
 531
 532 (autoload 'cl-multiple-value-setq "cl-macs" "\
 533 Collect multiple return values.
 534 FORM must return a list; the first N elements of this list are stored in
 535 each of the symbols SYM in turn.  This is analogous to the Common Lisp
 536 `cl-multiple-value-setq' macro, using lists to simulate true multiple return
 537 values.  For compatibility, (cl-values A B C) is a synonym for (list A B C).
 538
 539 \(fn (SYM...) FORM)" nil t)
 540
 541 (put 'cl-multiple-value-setq 'lisp-indent-function '1)
 542
 543 (autoload 'cl-locally "cl-macs" "\
 544
 545
 546 \(fn &rest BODY)" nil t)
 547
 548 (autoload 'cl-the "cl-macs" "\
 549
 550
 551 \(fn TYPE FORM)" nil t)
 552
 553 (put 'cl-the 'lisp-indent-function '1)
 554
 555 (autoload 'cl-declare "cl-macs" "\
 556 Declare SPECS about the current function while compiling.
 557 For instance
 558
 559   (cl-declare (warn 0))
 560
 561 will turn off byte-compile warnings in the function.
 562 See Info node `(cl)Declarations' for details.
 563
 564 \(fn &rest SPECS)" nil t)
 565
 566 (autoload 'cl-psetf "cl-macs" "\
 567 Set PLACEs to the values VALs in parallel.
 568 This is like `setf', except that all VAL forms are evaluated (in order)
 569 before assigning any PLACEs to the corresponding values.
 570
 571 \(fn PLACE VAL PLACE VAL ...)" nil t)
 572
 573 (autoload 'cl-remf "cl-macs" "\
 574 Remove TAG from property list PLACE.
 575 PLACE may be a symbol, or any generalized variable allowed by `setf'.
 576 The form returns true if TAG was found and removed, nil otherwise.
 577
 578 \(fn PLACE TAG)" nil t)
 579
 580 (autoload 'cl-shiftf "cl-macs" "\
 581 Shift left among PLACEs.
 582 Example: (cl-shiftf A B C) sets A to B, B to C, and returns the old A.
 583 Each PLACE may be a symbol, or any generalized variable allowed by `setf'.
 584
 585 \(fn PLACE... VAL)" nil t)
 586
 587 (autoload 'cl-rotatef "cl-macs" "\
 588 Rotate left among PLACEs.
 589 Example: (cl-rotatef A B C) sets A to B, B to C, and C to A.  It returns nil.
 590 Each PLACE may be a symbol, or any generalized variable allowed by `setf'.
 591
 592 \(fn PLACE...)" nil t)
 593
 594 (autoload 'cl-callf "cl-macs" "\
 595 Set PLACE to (FUNC PLACE ARGS...).
 596 FUNC should be an unquoted function name.  PLACE may be a symbol,
 597 or any generalized variable allowed by `setf'.
 598
 599 \(fn FUNC PLACE &rest ARGS)" nil t)
 600
 601 (put 'cl-callf 'lisp-indent-function '2)
 602
 603 (autoload 'cl-callf2 "cl-macs" "\
 604 Set PLACE to (FUNC ARG1 PLACE ARGS...).
 605 Like `cl-callf', but PLACE is the second argument of FUNC, not the first.
 606
 607 \(fn FUNC ARG1 PLACE ARGS...)" nil t)
 608
 609 (put 'cl-callf2 'lisp-indent-function '3)
 610
 611 (autoload 'cl-defstruct "cl-macs" "\
 612 Define a struct type.
 613 This macro defines a new data type called NAME that stores data
 614 in SLOTs.  It defines a `make-NAME' constructor, a `copy-NAME'
 615 copier, a `NAME-p' predicate, and slot accessors named `NAME-SLOT'.
 616 You can use the accessors to set the corresponding slots, via `setf'.
 617
 618 NAME may instead take the form (NAME OPTIONS...), where each
 619 OPTION is either a single keyword or (KEYWORD VALUE).
 620 See Info node `(cl)Structures' for a list of valid keywords.
 621
 622 Each SLOT may instead take the form (SLOT SLOT-OPTS...), where
 623 SLOT-OPTS are keyword-value pairs for that slot.  Currently, only
 624 one keyword is supported, `:read-only'.  If this has a non-nil
 625 value, that slot cannot be set via `setf'.
 626
 627 \(fn NAME SLOTS...)" nil t)
 628
 629 (put 'cl-defstruct 'doc-string-elt '2)
 630
 631 (autoload 'cl-deftype "cl-macs" "\
 632 Define NAME as a new data type.
 633 The type name can then be used in `cl-typecase', `cl-check-type', etc.
 634
 635 \(fn NAME ARGLIST &rest BODY)" nil t)
 636
 637 (put 'cl-deftype 'doc-string-elt '3)
 638
 639 (autoload 'cl-typep "cl-macs" "\
 640 Check that OBJECT is of type TYPE.
 641 TYPE is a Common Lisp-style type specifier.
 642
 643 \(fn OBJECT TYPE)" nil nil)
 644
 645 (autoload 'cl-check-type "cl-macs" "\
 646 Verify that FORM is of type TYPE; signal an error if not.
 647 STRING is an optional description of the desired type.
 648
 649 \(fn FORM TYPE &optional STRING)" nil t)
 650
 651 (autoload 'cl-assert "cl-macs" "\
 652 Verify that FORM returns non-nil; signal an error if not.
 653 Second arg SHOW-ARGS means to include arguments of FORM in message.
 654 Other args STRING and ARGS... are arguments to be passed to `error'.
 655 They are not evaluated unless the assertion fails.  If STRING is
 656 omitted, a default message listing FORM itself is used.
 657
 658 \(fn FORM &optional SHOW-ARGS STRING &rest ARGS)" nil t)
 659
 660 (autoload 'cl-define-compiler-macro "cl-macs" "\
 661 Define a compiler-only macro.
 662 This is like `defmacro', but macro expansion occurs only if the call to
 663 FUNC is compiled (i.e., not interpreted).  Compiler macros should be used
 664 for optimizing the way calls to FUNC are compiled; the form returned by
 665 BODY should do the same thing as a call to the normal function called
 666 FUNC, though possibly more efficiently.  Note that, like regular macros,
 667 compiler macros are expanded repeatedly until no further expansions are
 668 possible.  Unlike regular macros, BODY can decide to \"punt\" and leave the
 669 original function call alone by declaring an initial `&whole foo' parameter
 670 and then returning foo.
 671
 672 \(fn FUNC ARGS &rest BODY)" nil t)
 673
 674 (autoload 'cl-compiler-macroexpand "cl-macs" "\
 675
 676
 677 \(fn FORM)" nil nil)
 678
 679 (autoload 'cl-defsubst "cl-macs" "\
 680 Define NAME as a function.
 681 Like `defun', except the function is automatically declared `inline',
 682 ARGLIST allows full Common Lisp conventions, and BODY is implicitly
 683 surrounded by (cl-block NAME ...).
 684
 685 \(fn NAME ARGLIST [DOCSTRING] BODY...)" nil t)
 686
 687 (put 'cl-defsubst 'lisp-indent-function '2)
 688
 689 (autoload 'cl--compiler-macro-adjoin "cl-macs" "\
 690
 691
 692 \(fn FORM A LIST &rest KEYS)" nil nil)
 693
 694 (autoload 'cl--compiler-macro-list* "cl-macs" "\
 695
 696
 697 \(fn FORM ARG &rest OTHERS)" nil nil)
 698
 699 (autoload 'cl--compiler-macro-cXXr "cl-macs" "\
 700
 701
 702 \(fn FORM X)" nil nil)
 703
 704 ;;;***
 705 \f
 706 ;;;### (autoloads (cl-tree-equal cl-nsublis cl-sublis cl-nsubst-if-not
 707 ;;;;;;  cl-nsubst-if cl-nsubst cl-subst-if-not cl-subst-if cl-subsetp
 708 ;;;;;;  cl-nset-exclusive-or cl-set-exclusive-or cl-nset-difference
 709 ;;;;;;  cl-set-difference cl-nintersection cl-intersection cl-nunion
 710 ;;;;;;  cl-union cl-rassoc-if-not cl-rassoc-if cl-rassoc cl-assoc-if-not
 711 ;;;;;;  cl-assoc-if cl-assoc cl--adjoin cl-member-if-not cl-member-if
 712 ;;;;;;  cl-member cl-merge cl-stable-sort cl-sort cl-search cl-mismatch
 713 ;;;;;;  cl-count-if-not cl-count-if cl-count cl-position-if-not cl-position-if
 714 ;;;;;;  cl-position cl-find-if-not cl-find-if cl-find cl-nsubstitute-if-not
 715 ;;;;;;  cl-nsubstitute-if cl-nsubstitute cl-substitute-if-not cl-substitute-if
 716 ;;;;;;  cl-substitute cl-delete-duplicates cl-remove-duplicates cl-delete-if-not
 717 ;;;;;;  cl-delete-if cl-delete cl-remove-if-not cl-remove-if cl-remove
 718 ;;;;;;  cl-replace cl-fill cl-reduce) "cl-seq" "cl-seq.el" "b444601641dcbd14a23ca5182bc80ffa")
 719 ;;; Generated autoloads from cl-seq.el
 720
 721 (autoload 'cl-reduce "cl-seq" "\
 722 Reduce two-argument FUNCTION across SEQ.
 723
 724 Keywords supported:  :start :end :from-end :initial-value :key
 725
 726 \(fn FUNCTION SEQ [KEYWORD VALUE]...)" nil nil)
 727
 728 (autoload 'cl-fill "cl-seq" "\
 729 Fill the elements of SEQ with ITEM.
 730
 731 Keywords supported:  :start :end
 732
 733 \(fn SEQ ITEM [KEYWORD VALUE]...)" nil nil)
 734
 735 (autoload 'cl-replace "cl-seq" "\
 736 Replace the elements of SEQ1 with the elements of SEQ2.
 737 SEQ1 is destructively modified, then returned.
 738
 739 Keywords supported:  :start1 :end1 :start2 :end2
 740
 741 \(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil)
 742
 743 (autoload 'cl-remove "cl-seq" "\
 744 Remove all occurrences of ITEM in SEQ.
 745 This is a non-destructive function; it makes a copy of SEQ if necessary
 746 to avoid corrupting the original SEQ.
 747
 748 Keywords supported:  :test :test-not :key :count :start :end :from-end
 749
 750 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
 751
 752 (autoload 'cl-remove-if "cl-seq" "\
 753 Remove all items satisfying PREDICATE in SEQ.
 754 This is a non-destructive function; it makes a copy of SEQ if necessary
 755 to avoid corrupting the original SEQ.
 756
 757 Keywords supported:  :key :count :start :end :from-end
 758
 759 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 760
 761 (autoload 'cl-remove-if-not "cl-seq" "\
 762 Remove all items not satisfying PREDICATE in SEQ.
 763 This is a non-destructive function; it makes a copy of SEQ if necessary
 764 to avoid corrupting the original SEQ.
 765
 766 Keywords supported:  :key :count :start :end :from-end
 767
 768 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 769
 770 (autoload 'cl-delete "cl-seq" "\
 771 Remove all occurrences of ITEM in SEQ.
 772 This is a destructive function; it reuses the storage of SEQ whenever possible.
 773
 774 Keywords supported:  :test :test-not :key :count :start :end :from-end
 775
 776 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
 777
 778 (autoload 'cl-delete-if "cl-seq" "\
 779 Remove all items satisfying PREDICATE in SEQ.
 780 This is a destructive function; it reuses the storage of SEQ whenever possible.
 781
 782 Keywords supported:  :key :count :start :end :from-end
 783
 784 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 785
 786 (autoload 'cl-delete-if-not "cl-seq" "\
 787 Remove all items not 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-remove-duplicates "cl-seq" "\
 795 Return a copy of SEQ with all duplicate elements removed.
 796
 797 Keywords supported:  :test :test-not :key :start :end :from-end
 798
 799 \(fn SEQ [KEYWORD VALUE]...)" nil nil)
 800
 801 (autoload 'cl-delete-duplicates "cl-seq" "\
 802 Remove all duplicate elements from SEQ (destructively).
 803
 804 Keywords supported:  :test :test-not :key :start :end :from-end
 805
 806 \(fn SEQ [KEYWORD VALUE]...)" nil nil)
 807
 808 (autoload 'cl-substitute "cl-seq" "\
 809 Substitute NEW for OLD in SEQ.
 810 This is a non-destructive function; it makes a copy of SEQ if necessary
 811 to avoid corrupting the original SEQ.
 812
 813 Keywords supported:  :test :test-not :key :count :start :end :from-end
 814
 815 \(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil)
 816
 817 (autoload 'cl-substitute-if "cl-seq" "\
 818 Substitute NEW for all items satisfying PREDICATE in SEQ.
 819 This is a non-destructive function; it makes a copy of SEQ if necessary
 820 to avoid corrupting the original SEQ.
 821
 822 Keywords supported:  :key :count :start :end :from-end
 823
 824 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 825
 826 (autoload 'cl-substitute-if-not "cl-seq" "\
 827 Substitute NEW for all items not satisfying PREDICATE in SEQ.
 828 This is a non-destructive function; it makes a copy of SEQ if necessary
 829 to avoid corrupting the original SEQ.
 830
 831 Keywords supported:  :key :count :start :end :from-end
 832
 833 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 834
 835 (autoload 'cl-nsubstitute "cl-seq" "\
 836 Substitute NEW for OLD in SEQ.
 837 This is a destructive function; it reuses the storage of SEQ whenever possible.
 838
 839 Keywords supported:  :test :test-not :key :count :start :end :from-end
 840
 841 \(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil)
 842
 843 (autoload 'cl-nsubstitute-if "cl-seq" "\
 844 Substitute NEW for all items satisfying PREDICATE in SEQ.
 845 This is a destructive function; it reuses the storage of SEQ whenever possible.
 846
 847 Keywords supported:  :key :count :start :end :from-end
 848
 849 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 850
 851 (autoload 'cl-nsubstitute-if-not "cl-seq" "\
 852 Substitute NEW for all items not 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-find "cl-seq" "\
 860 Find the first occurrence of ITEM in SEQ.
 861 Return the matching ITEM, or nil if not found.
 862
 863 Keywords supported:  :test :test-not :key :start :end :from-end
 864
 865 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
 866
 867 (autoload 'cl-find-if "cl-seq" "\
 868 Find the first item satisfying PREDICATE in SEQ.
 869 Return the matching item, or nil if not found.
 870
 871 Keywords supported:  :key :start :end :from-end
 872
 873 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 874
 875 (autoload 'cl-find-if-not "cl-seq" "\
 876 Find the first item not 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-position "cl-seq" "\
 884 Find the first occurrence of ITEM in SEQ.
 885 Return the index of the matching item, or nil if not found.
 886
 887 Keywords supported:  :test :test-not :key :start :end :from-end
 888
 889 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
 890
 891 (autoload 'cl-position-if "cl-seq" "\
 892 Find the first item satisfying PREDICATE in SEQ.
 893 Return the index of the matching item, or nil if not found.
 894
 895 Keywords supported:  :key :start :end :from-end
 896
 897 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 898
 899 (autoload 'cl-position-if-not "cl-seq" "\
 900 Find the first item not 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-count "cl-seq" "\
 908 Count the number of occurrences of ITEM in SEQ.
 909
 910 Keywords supported:  :test :test-not :key :start :end
 911
 912 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
 913
 914 (autoload 'cl-count-if "cl-seq" "\
 915 Count the number of items satisfying PREDICATE in SEQ.
 916
 917 Keywords supported:  :key :start :end
 918
 919 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 920
 921 (autoload 'cl-count-if-not "cl-seq" "\
 922 Count the number of items not satisfying PREDICATE in SEQ.
 923
 924 Keywords supported:  :key :start :end
 925
 926 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 927
 928 (autoload 'cl-mismatch "cl-seq" "\
 929 Compare SEQ1 with SEQ2, return index of first mismatching element.
 930 Return nil if the sequences match.  If one sequence is a prefix of the
 931 other, the return value indicates the end of the shorter sequence.
 932
 933 Keywords supported:  :test :test-not :key :start1 :end1 :start2 :end2 :from-end
 934
 935 \(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil)
 936
 937 (autoload 'cl-search "cl-seq" "\
 938 Search for SEQ1 as a subsequence of SEQ2.
 939 Return the index of the leftmost element of the first match found;
 940 return nil if there are no matches.
 941
 942 Keywords supported:  :test :test-not :key :start1 :end1 :start2 :end2 :from-end
 943
 944 \(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil)
 945
 946 (autoload 'cl-sort "cl-seq" "\
 947 Sort the argument SEQ according to PREDICATE.
 948 This is a destructive function; it reuses the storage of SEQ if possible.
 949
 950 Keywords supported:  :key
 951
 952 \(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil)
 953
 954 (autoload 'cl-stable-sort "cl-seq" "\
 955 Sort the argument SEQ stably 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-merge "cl-seq" "\
 963 Destructively merge the two sequences to produce a new sequence.
 964 TYPE is the sequence type to return, SEQ1 and SEQ2 are the two argument
 965 sequences, and PREDICATE is a `less-than' predicate on the elements.
 966
 967 Keywords supported:  :key
 968
 969 \(fn TYPE SEQ1 SEQ2 PREDICATE [KEYWORD VALUE]...)" nil nil)
 970
 971 (autoload 'cl-member "cl-seq" "\
 972 Find the first occurrence of ITEM in LIST.
 973 Return the sublist of LIST whose car is ITEM.
 974
 975 Keywords supported:  :test :test-not :key
 976
 977 \(fn ITEM LIST [KEYWORD VALUE]...)" nil nil)
 978
 979 (put 'cl-member 'compiler-macro #'cl--compiler-macro-member)
 980
 981 (autoload 'cl-member-if "cl-seq" "\
 982 Find the first item satisfying PREDICATE in LIST.
 983 Return the sublist of LIST whose car matches.
 984
 985 Keywords supported:  :key
 986
 987 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
 988
 989 (autoload 'cl-member-if-not "cl-seq" "\
 990 Find the first item not 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--adjoin "cl-seq" "\
 998
 999
1000 \(fn CL-ITEM CL-LIST &rest CL-KEYS)" nil nil)
1001
1002 (autoload 'cl-assoc "cl-seq" "\
1003 Find the first item whose car matches ITEM in LIST.
1004
1005 Keywords supported:  :test :test-not :key
1006
1007 \(fn ITEM LIST [KEYWORD VALUE]...)" nil nil)
1008
1009 (put 'cl-assoc 'compiler-macro #'cl--compiler-macro-assoc)
1010
1011 (autoload 'cl-assoc-if "cl-seq" "\
1012 Find the first item whose car satisfies PREDICATE in LIST.
1013
1014 Keywords supported:  :key
1015
1016 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
1017
1018 (autoload 'cl-assoc-if-not "cl-seq" "\
1019 Find the first item whose car does not satisfy PREDICATE in LIST.
1020
1021 Keywords supported:  :key
1022
1023 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
1024
1025 (autoload 'cl-rassoc "cl-seq" "\
1026 Find the first item whose cdr matches ITEM in LIST.
1027
1028 Keywords supported:  :test :test-not :key
1029
1030 \(fn ITEM LIST [KEYWORD VALUE]...)" nil nil)
1031
1032 (autoload 'cl-rassoc-if "cl-seq" "\
1033 Find the first item whose cdr satisfies PREDICATE in LIST.
1034
1035 Keywords supported:  :key
1036
1037 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
1038
1039 (autoload 'cl-rassoc-if-not "cl-seq" "\
1040 Find the first item whose cdr does not satisfy PREDICATE in LIST.
1041
1042 Keywords supported:  :key
1043
1044 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
1045
1046 (autoload 'cl-union "cl-seq" "\
1047 Combine LIST1 and LIST2 using a set-union operation.
1048 The resulting list contains all items that appear in either LIST1 or LIST2.
1049 This is a non-destructive function; it makes a copy of the data if necessary
1050 to avoid corrupting the original LIST1 and LIST2.
1051
1052 Keywords supported:  :test :test-not :key
1053
1054 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1055
1056 (autoload 'cl-nunion "cl-seq" "\
1057 Combine LIST1 and LIST2 using a set-union operation.
1058 The resulting list contains all items that appear in either LIST1 or LIST2.
1059 This is a destructive function; it reuses the storage of LIST1 and LIST2
1060 whenever possible.
1061
1062 Keywords supported:  :test :test-not :key
1063
1064 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1065
1066 (autoload 'cl-intersection "cl-seq" "\
1067 Combine LIST1 and LIST2 using a set-intersection operation.
1068 The resulting list contains all items that appear in both LIST1 and LIST2.
1069 This is a non-destructive function; it makes a copy of the data if necessary
1070 to avoid corrupting the original LIST1 and LIST2.
1071
1072 Keywords supported:  :test :test-not :key
1073
1074 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1075
1076 (autoload 'cl-nintersection "cl-seq" "\
1077 Combine LIST1 and LIST2 using a set-intersection operation.
1078 The resulting list contains all items that appear in both LIST1 and LIST2.
1079 This is a destructive function; it reuses the storage of LIST1 and LIST2
1080 whenever possible.
1081
1082 Keywords supported:  :test :test-not :key
1083
1084 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1085
1086 (autoload 'cl-set-difference "cl-seq" "\
1087 Combine LIST1 and LIST2 using a set-difference operation.
1088 The resulting list contains all items that appear in LIST1 but not LIST2.
1089 This is a non-destructive function; it makes a copy of the data if necessary
1090 to avoid corrupting the original LIST1 and LIST2.
1091
1092 Keywords supported:  :test :test-not :key
1093
1094 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1095
1096 (autoload 'cl-nset-difference "cl-seq" "\
1097 Combine LIST1 and LIST2 using a set-difference operation.
1098 The resulting list contains all items that appear in LIST1 but not LIST2.
1099 This is a destructive function; it reuses the storage of LIST1 and LIST2
1100 whenever possible.
1101
1102 Keywords supported:  :test :test-not :key
1103
1104 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1105
1106 (autoload 'cl-set-exclusive-or "cl-seq" "\
1107 Combine LIST1 and LIST2 using a set-exclusive-or operation.
1108 The resulting list contains all items appearing in exactly one of LIST1, LIST2.
1109 This is a non-destructive function; it makes a copy of the data if necessary
1110 to avoid corrupting the original LIST1 and LIST2.
1111
1112 Keywords supported:  :test :test-not :key
1113
1114 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1115
1116 (autoload 'cl-nset-exclusive-or "cl-seq" "\
1117 Combine LIST1 and LIST2 using a set-exclusive-or operation.
1118 The resulting list contains all items appearing in exactly one of LIST1, LIST2.
1119 This is a destructive function; it reuses the storage of LIST1 and LIST2
1120 whenever possible.
1121
1122 Keywords supported:  :test :test-not :key
1123
1124 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1125
1126 (autoload 'cl-subsetp "cl-seq" "\
1127 Return true if LIST1 is a subset of LIST2.
1128 I.e., if every element of LIST1 also appears in LIST2.
1129
1130 Keywords supported:  :test :test-not :key
1131
1132 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1133
1134 (autoload 'cl-subst-if "cl-seq" "\
1135 Substitute NEW for elements matching PREDICATE in TREE (non-destructively).
1136 Return a copy of TREE with all matching elements replaced by NEW.
1137
1138 Keywords supported:  :key
1139
1140 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil)
1141
1142 (autoload 'cl-subst-if-not "cl-seq" "\
1143 Substitute NEW for elts not matching PREDICATE in TREE (non-destructively).
1144 Return a copy of TREE with all non-matching elements replaced by NEW.
1145
1146 Keywords supported:  :key
1147
1148 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil)
1149
1150 (autoload 'cl-nsubst "cl-seq" "\
1151 Substitute NEW for OLD everywhere in TREE (destructively).
1152 Any element of TREE which is `eql' to OLD is changed to NEW (via a call
1153 to `setcar').
1154
1155 Keywords supported:  :test :test-not :key
1156
1157 \(fn NEW OLD TREE [KEYWORD VALUE]...)" nil nil)
1158
1159 (autoload 'cl-nsubst-if "cl-seq" "\
1160 Substitute NEW for elements matching PREDICATE in TREE (destructively).
1161 Any element of TREE which matches is changed to NEW (via a call to `setcar').
1162
1163 Keywords supported:  :key
1164
1165 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil)
1166
1167 (autoload 'cl-nsubst-if-not "cl-seq" "\
1168 Substitute NEW for elements not 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-sublis "cl-seq" "\
1176 Perform substitutions indicated by ALIST in TREE (non-destructively).
1177 Return a copy of TREE with all matching elements replaced.
1178
1179 Keywords supported:  :test :test-not :key
1180
1181 \(fn ALIST TREE [KEYWORD VALUE]...)" nil nil)
1182
1183 (autoload 'cl-nsublis "cl-seq" "\
1184 Perform substitutions indicated by ALIST in TREE (destructively).
1185 Any matching element of TREE is changed via a call to `setcar'.
1186
1187 Keywords supported:  :test :test-not :key
1188
1189 \(fn ALIST TREE [KEYWORD VALUE]...)" nil nil)
1190
1191 (autoload 'cl-tree-equal "cl-seq" "\
1192 Return t if trees TREE1 and TREE2 have `eql' leaves.
1193 Atoms are compared by `eql'; cons cells are compared recursively.
1194
1195 Keywords supported:  :test :test-not :key
1196
1197 \(fn TREE1 TREE2 [KEYWORD VALUE]...)" nil nil)
1198
1199 ;;;***
1200 \f
1201 ;; Local Variables:
1202 ;; version-control: never
1203 ;; no-byte-compile: t
1204 ;; no-update-autoloads: t
1205 ;; coding: utf-8
1206 ;; End:
1207 ;;; cl-loaddefs.el ends here