lisp/emacs-lisp/cl-loaddefs.el

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