lisp/emacs-lisp/cl-loaddefs.el

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