code.delx.au - gnu-emacs/blob - 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" "c5730f2a706cb1efc5fec0a790d3ca72")
  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" "3b4d4e869f81f0b07ab3aa08f5478c2e")
 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 are:
 421   for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM,
 422   for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR,
 423   for VAR across ARRAY, repeat NUM, with VAR = INIT, while COND, until COND,
 424   always COND, never COND, thereis COND, collect EXPR into VAR,
 425   append EXPR into VAR, nconc EXPR into VAR, sum EXPR into VAR,
 426   count EXPR into VAR, maximize EXPR into VAR, minimize EXPR into VAR,
 427   if COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
 428   unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
 429   do EXPRS..., initially EXPRS..., finally EXPRS..., return EXPR,
 430   finally return EXPR, named NAME.
 431
 432 \(fn CLAUSE...)" nil t)
 433
 434 (autoload 'cl-do "cl-macs" "\
 435 The Common Lisp `do' loop.
 436
 437 \(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil t)
 438
 439 (put 'cl-do 'lisp-indent-function '2)
 440
 441 (autoload 'cl-do* "cl-macs" "\
 442 The Common Lisp `do*' loop.
 443
 444 \(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil t)
 445
 446 (put 'cl-do* 'lisp-indent-function '2)
 447
 448 (autoload 'cl-dolist "cl-macs" "\
 449 Loop over a list.
 450 Evaluate BODY with VAR bound to each `car' from LIST, in turn.
 451 Then evaluate RESULT to get return value, default nil.
 452 An implicit nil block is established around the loop.
 453
 454 \(fn (VAR LIST [RESULT]) BODY...)" nil t)
 455
 456 (put 'cl-dolist 'lisp-indent-function '1)
 457
 458 (autoload 'cl-dotimes "cl-macs" "\
 459 Loop a certain number of times.
 460 Evaluate BODY with VAR bound to successive integers from 0, inclusive,
 461 to COUNT, exclusive.  Then evaluate RESULT to get return value, default
 462 nil.
 463
 464 \(fn (VAR COUNT [RESULT]) BODY...)" nil t)
 465
 466 (put 'cl-dotimes 'lisp-indent-function '1)
 467
 468 (autoload 'cl-tagbody "cl-macs" "\
 469 Execute statements while providing for control transfers to labels.
 470 Each element of LABELS-OR-STMTS can be either a label (integer or symbol)
 471 or a `cons' cell, in which case it's taken to be a statement.
 472 This distinction is made before performing macroexpansion.
 473 Statements are executed in sequence left to right, discarding any return value,
 474 stopping only when reaching the end of LABELS-OR-STMTS.
 475 Any statement can transfer control at any time to the statements that follow
 476 one of the labels with the special form (go LABEL).
 477 Labels have lexical scope and dynamic extent.
 478
 479 \(fn &rest LABELS-OR-STMTS)" nil t)
 480
 481 (autoload 'cl-do-symbols "cl-macs" "\
 482 Loop over all symbols.
 483 Evaluate BODY with VAR bound to each interned symbol, or to each symbol
 484 from OBARRAY.
 485
 486 \(fn (VAR [OBARRAY [RESULT]]) BODY...)" nil t)
 487
 488 (put 'cl-do-symbols 'lisp-indent-function '1)
 489
 490 (autoload 'cl-do-all-symbols "cl-macs" "\
 491 Like `cl-do-symbols', but use the default obarray.
 492
 493 \(fn (VAR [RESULT]) BODY...)" nil t)
 494
 495 (put 'cl-do-all-symbols 'lisp-indent-function '1)
 496
 497 (autoload 'cl-psetq "cl-macs" "\
 498 Set SYMs to the values VALs in parallel.
 499 This is like `setq', except that all VAL forms are evaluated (in order)
 500 before assigning any symbols SYM to the corresponding values.
 501
 502 \(fn SYM VAL SYM VAL ...)" nil t)
 503
 504 (autoload 'cl-progv "cl-macs" "\
 505 Bind SYMBOLS to VALUES dynamically in BODY.
 506 The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
 507 Each symbol in the first list is bound to the corresponding value in the
 508 second list (or to nil if VALUES is shorter than SYMBOLS); then the
 509 BODY forms are executed and their result is returned.  This is much like
 510 a `let' form, except that the list of symbols can be computed at run-time.
 511
 512 \(fn SYMBOLS VALUES &rest BODY)" nil t)
 513
 514 (put 'cl-progv 'lisp-indent-function '2)
 515
 516 (autoload 'cl-flet "cl-macs" "\
 517 Make local function definitions.
 518 Like `cl-labels' but the definitions are not recursive.
 519
 520 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil t)
 521
 522 (put 'cl-flet 'lisp-indent-function '1)
 523
 524 (autoload 'cl-flet* "cl-macs" "\
 525 Make local function definitions.
 526 Like `cl-flet' but the definitions can refer to previous ones.
 527
 528 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil t)
 529
 530 (put 'cl-flet* 'lisp-indent-function '1)
 531
 532 (autoload 'cl-labels "cl-macs" "\
 533 Make temporary function bindings.
 534 The bindings can be recursive and the scoping is lexical, but capturing them
 535 in closures will only work if `lexical-binding' is in use.
 536
 537 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil t)
 538
 539 (put 'cl-labels 'lisp-indent-function '1)
 540
 541 (autoload 'cl-macrolet "cl-macs" "\
 542 Make temporary macro definitions.
 543 This is like `cl-flet', but for macros instead of functions.
 544
 545 \(fn ((NAME ARGLIST BODY...) ...) FORM...)" nil t)
 546
 547 (put 'cl-macrolet 'lisp-indent-function '1)
 548
 549 (autoload 'cl-symbol-macrolet "cl-macs" "\
 550 Make symbol macro definitions.
 551 Within the body FORMs, references to the variable NAME will be replaced
 552 by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...).
 553
 554 \(fn ((NAME EXPANSION) ...) FORM...)" nil t)
 555
 556 (put 'cl-symbol-macrolet 'lisp-indent-function '1)
 557
 558 (autoload 'cl-multiple-value-bind "cl-macs" "\
 559 Collect multiple return values.
 560 FORM must return a list; the BODY is then executed with the first N elements
 561 of this list bound (`let'-style) to each of the symbols SYM in turn.  This
 562 is analogous to the Common Lisp `cl-multiple-value-bind' macro, using lists to
 563 simulate true multiple return values.  For compatibility, (cl-values A B C) is
 564 a synonym for (list A B C).
 565
 566 \(fn (SYM...) FORM BODY)" nil t)
 567
 568 (put 'cl-multiple-value-bind 'lisp-indent-function '2)
 569
 570 (autoload 'cl-multiple-value-setq "cl-macs" "\
 571 Collect multiple return values.
 572 FORM must return a list; the first N elements of this list are stored in
 573 each of the symbols SYM in turn.  This is analogous to the Common Lisp
 574 `cl-multiple-value-setq' macro, using lists to simulate true multiple return
 575 values.  For compatibility, (cl-values A B C) is a synonym for (list A B C).
 576
 577 \(fn (SYM...) FORM)" nil t)
 578
 579 (put 'cl-multiple-value-setq 'lisp-indent-function '1)
 580
 581 (autoload 'cl-locally "cl-macs" "\
 582 Equivalent to `progn'.
 583
 584 \(fn &rest BODY)" nil t)
 585
 586 (autoload 'cl-the "cl-macs" "\
 587 At present this ignores _TYPE and is simply equivalent to FORM.
 588
 589 \(fn TYPE FORM)" nil t)
 590
 591 (put 'cl-the 'lisp-indent-function '1)
 592
 593 (autoload 'cl-declare "cl-macs" "\
 594 Declare SPECS about the current function while compiling.
 595 For instance
 596
 597   (cl-declare (warn 0))
 598
 599 will turn off byte-compile warnings in the function.
 600 See Info node `(cl)Declarations' for details.
 601
 602 \(fn &rest SPECS)" nil t)
 603
 604 (autoload 'cl-psetf "cl-macs" "\
 605 Set PLACEs to the values VALs in parallel.
 606 This is like `setf', except that all VAL forms are evaluated (in order)
 607 before assigning any PLACEs to the corresponding values.
 608
 609 \(fn PLACE VAL PLACE VAL ...)" nil t)
 610
 611 (autoload 'cl-remf "cl-macs" "\
 612 Remove TAG from property list PLACE.
 613 PLACE may be a symbol, or any generalized variable allowed by `setf'.
 614 The form returns true if TAG was found and removed, nil otherwise.
 615
 616 \(fn PLACE TAG)" nil t)
 617
 618 (autoload 'cl-shiftf "cl-macs" "\
 619 Shift left among PLACEs.
 620 Example: (cl-shiftf A B C) sets A to B, B to C, and returns the old A.
 621 Each PLACE may be a symbol, or any generalized variable allowed by `setf'.
 622
 623 \(fn PLACE... VAL)" nil t)
 624
 625 (autoload 'cl-rotatef "cl-macs" "\
 626 Rotate left among PLACEs.
 627 Example: (cl-rotatef A B C) sets A to B, B to C, and C to A.  It returns nil.
 628 Each PLACE may be a symbol, or any generalized variable allowed by `setf'.
 629
 630 \(fn PLACE...)" nil t)
 631
 632 (autoload 'cl-letf "cl-macs" "\
 633 Temporarily bind to PLACEs.
 634 This is the analogue of `let', but with generalized variables (in the
 635 sense of `setf') for the PLACEs.  Each PLACE is set to the corresponding
 636 VALUE, then the BODY forms are executed.  On exit, either normally or
 637 because of a `throw' or error, the PLACEs are set back to their original
 638 values.  Note that this macro is *not* available in Common Lisp.
 639 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
 640 the PLACE is not modified before executing BODY.
 641
 642 \(fn ((PLACE VALUE) ...) BODY...)" nil t)
 643
 644 (put 'cl-letf 'lisp-indent-function '1)
 645
 646 (autoload 'cl-letf* "cl-macs" "\
 647 Temporarily bind to PLACEs.
 648 Like `cl-letf' but where the bindings are performed one at a time,
 649 rather than all at the end (i.e. like `let*' rather than like `let').
 650
 651 \(fn BINDINGS &rest BODY)" nil t)
 652
 653 (put 'cl-letf* 'lisp-indent-function '1)
 654
 655 (autoload 'cl-callf "cl-macs" "\
 656 Set PLACE to (FUNC PLACE ARGS...).
 657 FUNC should be an unquoted function name.  PLACE may be a symbol,
 658 or any generalized variable allowed by `setf'.
 659
 660 \(fn FUNC PLACE &rest ARGS)" nil t)
 661
 662 (put 'cl-callf 'lisp-indent-function '2)
 663
 664 (autoload 'cl-callf2 "cl-macs" "\
 665 Set PLACE to (FUNC ARG1 PLACE ARGS...).
 666 Like `cl-callf', but PLACE is the second argument of FUNC, not the first.
 667
 668 \(fn FUNC ARG1 PLACE ARGS...)" nil t)
 669
 670 (put 'cl-callf2 'lisp-indent-function '3)
 671
 672 (autoload 'cl-defstruct "cl-macs" "\
 673 Define a struct type.
 674 This macro defines a new data type called NAME that stores data
 675 in SLOTs.  It defines a `make-NAME' constructor, a `copy-NAME'
 676 copier, a `NAME-p' predicate, and slot accessors named `NAME-SLOT'.
 677 You can use the accessors to set the corresponding slots, via `setf'.
 678
 679 NAME may instead take the form (NAME OPTIONS...), where each
 680 OPTION is either a single keyword or (KEYWORD VALUE) where
 681 KEYWORD can be one of :conc-name, :constructor, :copier, :predicate,
 682 :type, :named, :initial-offset, :print-function, or :include.
 683
 684 Each SLOT may instead take the form (SLOT SLOT-OPTS...), where
 685 SLOT-OPTS are keyword-value pairs for that slot.  Currently, only
 686 one keyword is supported, `:read-only'.  If this has a non-nil
 687 value, that slot cannot be set via `setf'.
 688
 689 \(fn NAME SLOTS...)" nil t)
 690
 691 (put 'cl-defstruct 'doc-string-elt '2)
 692
 693 (put 'cl-defstruct 'lisp-indent-function '1)
 694
 695 (autoload 'cl-deftype "cl-macs" "\
 696 Define NAME as a new data type.
 697 The type name can then be used in `cl-typecase', `cl-check-type', etc.
 698
 699 \(fn NAME ARGLIST &rest BODY)" nil t)
 700
 701 (put 'cl-deftype 'doc-string-elt '3)
 702
 703 (autoload 'cl-typep "cl-macs" "\
 704 Check that OBJECT is of type TYPE.
 705 TYPE is a Common Lisp-style type specifier.
 706
 707 \(fn OBJECT TYPE)" nil nil)
 708
 709 (autoload 'cl-check-type "cl-macs" "\
 710 Verify that FORM is of type TYPE; signal an error if not.
 711 STRING is an optional description of the desired type.
 712
 713 \(fn FORM TYPE &optional STRING)" nil t)
 714
 715 (autoload 'cl-assert "cl-macs" "\
 716 Verify that FORM returns non-nil; signal an error if not.
 717 Second arg SHOW-ARGS means to include arguments of FORM in message.
 718 Other args STRING and ARGS... are arguments to be passed to `error'.
 719 They are not evaluated unless the assertion fails.  If STRING is
 720 omitted, a default message listing FORM itself is used.
 721
 722 \(fn FORM &optional SHOW-ARGS STRING &rest ARGS)" nil t)
 723
 724 (autoload 'cl-define-compiler-macro "cl-macs" "\
 725 Define a compiler-only macro.
 726 This is like `defmacro', but macro expansion occurs only if the call to
 727 FUNC is compiled (i.e., not interpreted).  Compiler macros should be used
 728 for optimizing the way calls to FUNC are compiled; the form returned by
 729 BODY should do the same thing as a call to the normal function called
 730 FUNC, though possibly more efficiently.  Note that, like regular macros,
 731 compiler macros are expanded repeatedly until no further expansions are
 732 possible.  Unlike regular macros, BODY can decide to \"punt\" and leave the
 733 original function call alone by declaring an initial `&whole foo' parameter
 734 and then returning foo.
 735
 736 \(fn FUNC ARGS &rest BODY)" nil t)
 737
 738 (autoload 'cl-compiler-macroexpand "cl-macs" "\
 739 Like `macroexpand', but for compiler macros.
 740 Expands FORM repeatedly until no further expansion is possible.
 741 Returns FORM unchanged if it has no compiler macro, or if it has a
 742 macro that returns its `&whole' argument.
 743
 744 \(fn FORM)" nil nil)
 745
 746 (autoload 'cl-defsubst "cl-macs" "\
 747 Define NAME as a function.
 748 Like `defun', except the function is automatically declared `inline',
 749 ARGLIST allows full Common Lisp conventions, and BODY is implicitly
 750 surrounded by (cl-block NAME ...).
 751
 752 \(fn NAME ARGLIST [DOCSTRING] BODY...)" nil t)
 753
 754 (put 'cl-defsubst 'lisp-indent-function '2)
 755
 756 (autoload 'cl--compiler-macro-adjoin "cl-macs" "\
 757
 758
 759 \(fn FORM A LIST &rest KEYS)" nil nil)
 760
 761 ;;;***
 762 \f
 763 ;;;### (autoloads (cl-tree-equal cl-nsublis cl-sublis cl-nsubst-if-not
 764 ;;;;;;  cl-nsubst-if cl-nsubst cl-subst-if-not cl-subst-if cl-subsetp
 765 ;;;;;;  cl-nset-exclusive-or cl-set-exclusive-or cl-nset-difference
 766 ;;;;;;  cl-set-difference cl-nintersection cl-intersection cl-nunion
 767 ;;;;;;  cl-union cl-rassoc-if-not cl-rassoc-if cl-rassoc cl-assoc-if-not
 768 ;;;;;;  cl-assoc-if cl-assoc cl--adjoin cl-member-if-not cl-member-if
 769 ;;;;;;  cl-member cl-merge cl-stable-sort cl-sort cl-search cl-mismatch
 770 ;;;;;;  cl-count-if-not cl-count-if cl-count cl-position-if-not cl-position-if
 771 ;;;;;;  cl-position cl-find-if-not cl-find-if cl-find cl-nsubstitute-if-not
 772 ;;;;;;  cl-nsubstitute-if cl-nsubstitute cl-substitute-if-not cl-substitute-if
 773 ;;;;;;  cl-substitute cl-delete-duplicates cl-remove-duplicates cl-delete-if-not
 774 ;;;;;;  cl-delete-if cl-delete cl-remove-if-not cl-remove-if cl-remove
 775 ;;;;;;  cl-replace cl-fill cl-reduce) "cl-seq" "cl-seq.el" "51a70dea9cbc225165a50135956609aa")
 776 ;;; Generated autoloads from cl-seq.el
 777
 778 (autoload 'cl-reduce "cl-seq" "\
 779 Reduce two-argument FUNCTION across SEQ.
 780
 781 Keywords supported:  :start :end :from-end :initial-value :key
 782
 783 \(fn FUNCTION SEQ [KEYWORD VALUE]...)" nil nil)
 784
 785 (autoload 'cl-fill "cl-seq" "\
 786 Fill the elements of SEQ with ITEM.
 787
 788 Keywords supported:  :start :end
 789
 790 \(fn SEQ ITEM [KEYWORD VALUE]...)" nil nil)
 791
 792 (autoload 'cl-replace "cl-seq" "\
 793 Replace the elements of SEQ1 with the elements of SEQ2.
 794 SEQ1 is destructively modified, then returned.
 795
 796 Keywords supported:  :start1 :end1 :start2 :end2
 797
 798 \(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil)
 799
 800 (autoload 'cl-remove "cl-seq" "\
 801 Remove all occurrences of ITEM in SEQ.
 802 This is a non-destructive function; it makes a copy of SEQ if necessary
 803 to avoid corrupting the original SEQ.
 804
 805 Keywords supported:  :test :test-not :key :count :start :end :from-end
 806
 807 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
 808
 809 (autoload 'cl-remove-if "cl-seq" "\
 810 Remove all items satisfying PREDICATE in SEQ.
 811 This is a non-destructive function; it makes a copy of SEQ if necessary
 812 to avoid corrupting the original SEQ.
 813
 814 Keywords supported:  :key :count :start :end :from-end
 815
 816 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 817
 818 (autoload 'cl-remove-if-not "cl-seq" "\
 819 Remove all items not satisfying PREDICATE in SEQ.
 820 This is a non-destructive function; it makes a copy of SEQ if necessary
 821 to avoid corrupting the original SEQ.
 822
 823 Keywords supported:  :key :count :start :end :from-end
 824
 825 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 826
 827 (autoload 'cl-delete "cl-seq" "\
 828 Remove all occurrences of ITEM in SEQ.
 829 This is a destructive function; it reuses the storage of SEQ whenever possible.
 830
 831 Keywords supported:  :test :test-not :key :count :start :end :from-end
 832
 833 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
 834
 835 (autoload 'cl-delete-if "cl-seq" "\
 836 Remove all items satisfying PREDICATE in SEQ.
 837 This is a destructive function; it reuses the storage of SEQ whenever possible.
 838
 839 Keywords supported:  :key :count :start :end :from-end
 840
 841 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 842
 843 (autoload 'cl-delete-if-not "cl-seq" "\
 844 Remove all items not satisfying PREDICATE in SEQ.
 845 This is a destructive function; it reuses the storage of SEQ whenever possible.
 846
 847 Keywords supported:  :key :count :start :end :from-end
 848
 849 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 850
 851 (autoload 'cl-remove-duplicates "cl-seq" "\
 852 Return a copy of SEQ with all duplicate elements removed.
 853
 854 Keywords supported:  :test :test-not :key :start :end :from-end
 855
 856 \(fn SEQ [KEYWORD VALUE]...)" nil nil)
 857
 858 (autoload 'cl-delete-duplicates "cl-seq" "\
 859 Remove all duplicate elements from SEQ (destructively).
 860
 861 Keywords supported:  :test :test-not :key :start :end :from-end
 862
 863 \(fn SEQ [KEYWORD VALUE]...)" nil nil)
 864
 865 (autoload 'cl-substitute "cl-seq" "\
 866 Substitute NEW for OLD in SEQ.
 867 This is a non-destructive function; it makes a copy of SEQ if necessary
 868 to avoid corrupting the original SEQ.
 869
 870 Keywords supported:  :test :test-not :key :count :start :end :from-end
 871
 872 \(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil)
 873
 874 (autoload 'cl-substitute-if "cl-seq" "\
 875 Substitute NEW for all items satisfying PREDICATE in SEQ.
 876 This is a non-destructive function; it makes a copy of SEQ if necessary
 877 to avoid corrupting the original SEQ.
 878
 879 Keywords supported:  :key :count :start :end :from-end
 880
 881 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 882
 883 (autoload 'cl-substitute-if-not "cl-seq" "\
 884 Substitute NEW for all items not satisfying PREDICATE in SEQ.
 885 This is a non-destructive function; it makes a copy of SEQ if necessary
 886 to avoid corrupting the original SEQ.
 887
 888 Keywords supported:  :key :count :start :end :from-end
 889
 890 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 891
 892 (autoload 'cl-nsubstitute "cl-seq" "\
 893 Substitute NEW for OLD in SEQ.
 894 This is a destructive function; it reuses the storage of SEQ whenever possible.
 895
 896 Keywords supported:  :test :test-not :key :count :start :end :from-end
 897
 898 \(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil)
 899
 900 (autoload 'cl-nsubstitute-if "cl-seq" "\
 901 Substitute NEW for all items satisfying PREDICATE in SEQ.
 902 This is a destructive function; it reuses the storage of SEQ whenever possible.
 903
 904 Keywords supported:  :key :count :start :end :from-end
 905
 906 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 907
 908 (autoload 'cl-nsubstitute-if-not "cl-seq" "\
 909 Substitute NEW for all items not satisfying PREDICATE in SEQ.
 910 This is a destructive function; it reuses the storage of SEQ whenever possible.
 911
 912 Keywords supported:  :key :count :start :end :from-end
 913
 914 \(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 915
 916 (autoload 'cl-find "cl-seq" "\
 917 Find the first occurrence of ITEM in SEQ.
 918 Return the matching ITEM, or nil if not found.
 919
 920 Keywords supported:  :test :test-not :key :start :end :from-end
 921
 922 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
 923
 924 (autoload 'cl-find-if "cl-seq" "\
 925 Find the first item satisfying PREDICATE in SEQ.
 926 Return the matching item, or nil if not found.
 927
 928 Keywords supported:  :key :start :end :from-end
 929
 930 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 931
 932 (autoload 'cl-find-if-not "cl-seq" "\
 933 Find the first item not satisfying PREDICATE in SEQ.
 934 Return the matching item, or nil if not found.
 935
 936 Keywords supported:  :key :start :end :from-end
 937
 938 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 939
 940 (autoload 'cl-position "cl-seq" "\
 941 Find the first occurrence of ITEM in SEQ.
 942 Return the index of the matching item, or nil if not found.
 943
 944 Keywords supported:  :test :test-not :key :start :end :from-end
 945
 946 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
 947
 948 (autoload 'cl-position-if "cl-seq" "\
 949 Find the first item satisfying PREDICATE in SEQ.
 950 Return the index of the matching item, or nil if not found.
 951
 952 Keywords supported:  :key :start :end :from-end
 953
 954 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 955
 956 (autoload 'cl-position-if-not "cl-seq" "\
 957 Find the first item not satisfying PREDICATE in SEQ.
 958 Return the index of the matching item, or nil if not found.
 959
 960 Keywords supported:  :key :start :end :from-end
 961
 962 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 963
 964 (autoload 'cl-count "cl-seq" "\
 965 Count the number of occurrences of ITEM in SEQ.
 966
 967 Keywords supported:  :test :test-not :key :start :end
 968
 969 \(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil)
 970
 971 (autoload 'cl-count-if "cl-seq" "\
 972 Count the number of items satisfying PREDICATE in SEQ.
 973
 974 Keywords supported:  :key :start :end
 975
 976 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 977
 978 (autoload 'cl-count-if-not "cl-seq" "\
 979 Count the number of items not satisfying PREDICATE in SEQ.
 980
 981 Keywords supported:  :key :start :end
 982
 983 \(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil)
 984
 985 (autoload 'cl-mismatch "cl-seq" "\
 986 Compare SEQ1 with SEQ2, return index of first mismatching element.
 987 Return nil if the sequences match.  If one sequence is a prefix of the
 988 other, the return value indicates the end of the shorter sequence.
 989
 990 Keywords supported:  :test :test-not :key :start1 :end1 :start2 :end2 :from-end
 991
 992 \(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil)
 993
 994 (autoload 'cl-search "cl-seq" "\
 995 Search for SEQ1 as a subsequence of SEQ2.
 996 Return the index of the leftmost element of the first match found;
 997 return nil if there are no matches.
 998
 999 Keywords supported:  :test :test-not :key :start1 :end1 :start2 :end2 :from-end
1000
1001 \(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil)
1002
1003 (autoload 'cl-sort "cl-seq" "\
1004 Sort the argument SEQ according to PREDICATE.
1005 This is a destructive function; it reuses the storage of SEQ if possible.
1006
1007 Keywords supported:  :key
1008
1009 \(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil)
1010
1011 (autoload 'cl-stable-sort "cl-seq" "\
1012 Sort the argument SEQ stably according to PREDICATE.
1013 This is a destructive function; it reuses the storage of SEQ if possible.
1014
1015 Keywords supported:  :key
1016
1017 \(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil)
1018
1019 (autoload 'cl-merge "cl-seq" "\
1020 Destructively merge the two sequences to produce a new sequence.
1021 TYPE is the sequence type to return, SEQ1 and SEQ2 are the two argument
1022 sequences, and PREDICATE is a `less-than' predicate on the elements.
1023
1024 Keywords supported:  :key
1025
1026 \(fn TYPE SEQ1 SEQ2 PREDICATE [KEYWORD VALUE]...)" nil nil)
1027
1028 (autoload 'cl-member "cl-seq" "\
1029 Find the first occurrence of ITEM in LIST.
1030 Return the sublist of LIST whose car is ITEM.
1031
1032 Keywords supported:  :test :test-not :key
1033
1034 \(fn ITEM LIST [KEYWORD VALUE]...)" nil nil)
1035
1036 (eval-and-compile (put 'cl-member 'compiler-macro #'cl--compiler-macro-member))
1037
1038 (autoload 'cl-member-if "cl-seq" "\
1039 Find the first item satisfying PREDICATE in LIST.
1040 Return the sublist of LIST whose car matches.
1041
1042 Keywords supported:  :key
1043
1044 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
1045
1046 (autoload 'cl-member-if-not "cl-seq" "\
1047 Find the first item not satisfying PREDICATE in LIST.
1048 Return the sublist of LIST whose car matches.
1049
1050 Keywords supported:  :key
1051
1052 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
1053
1054 (autoload 'cl--adjoin "cl-seq" "\
1055
1056
1057 \(fn CL-ITEM CL-LIST &rest CL-KEYS)" nil nil)
1058
1059 (autoload 'cl-assoc "cl-seq" "\
1060 Find the first item whose car matches ITEM in LIST.
1061
1062 Keywords supported:  :test :test-not :key
1063
1064 \(fn ITEM LIST [KEYWORD VALUE]...)" nil nil)
1065
1066 (eval-and-compile (put 'cl-assoc 'compiler-macro #'cl--compiler-macro-assoc))
1067
1068 (autoload 'cl-assoc-if "cl-seq" "\
1069 Find the first item whose car satisfies PREDICATE in LIST.
1070
1071 Keywords supported:  :key
1072
1073 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
1074
1075 (autoload 'cl-assoc-if-not "cl-seq" "\
1076 Find the first item whose car does not satisfy PREDICATE in LIST.
1077
1078 Keywords supported:  :key
1079
1080 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
1081
1082 (autoload 'cl-rassoc "cl-seq" "\
1083 Find the first item whose cdr matches ITEM in LIST.
1084
1085 Keywords supported:  :test :test-not :key
1086
1087 \(fn ITEM LIST [KEYWORD VALUE]...)" nil nil)
1088
1089 (autoload 'cl-rassoc-if "cl-seq" "\
1090 Find the first item whose cdr satisfies PREDICATE in LIST.
1091
1092 Keywords supported:  :key
1093
1094 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
1095
1096 (autoload 'cl-rassoc-if-not "cl-seq" "\
1097 Find the first item whose cdr does not satisfy PREDICATE in LIST.
1098
1099 Keywords supported:  :key
1100
1101 \(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil)
1102
1103 (autoload 'cl-union "cl-seq" "\
1104 Combine LIST1 and LIST2 using a set-union operation.
1105 The resulting list contains all items that appear in either LIST1 or LIST2.
1106 This is a non-destructive function; it makes a copy of the data if necessary
1107 to avoid corrupting the original LIST1 and LIST2.
1108
1109 Keywords supported:  :test :test-not :key
1110
1111 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1112
1113 (autoload 'cl-nunion "cl-seq" "\
1114 Combine LIST1 and LIST2 using a set-union operation.
1115 The resulting list contains all items that appear in either LIST1 or LIST2.
1116 This is a destructive function; it reuses the storage of LIST1 and LIST2
1117 whenever possible.
1118
1119 Keywords supported:  :test :test-not :key
1120
1121 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1122
1123 (autoload 'cl-intersection "cl-seq" "\
1124 Combine LIST1 and LIST2 using a set-intersection operation.
1125 The resulting list contains all items that appear in both LIST1 and LIST2.
1126 This is a non-destructive function; it makes a copy of the data if necessary
1127 to avoid corrupting the original LIST1 and LIST2.
1128
1129 Keywords supported:  :test :test-not :key
1130
1131 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1132
1133 (autoload 'cl-nintersection "cl-seq" "\
1134 Combine LIST1 and LIST2 using a set-intersection operation.
1135 The resulting list contains all items that appear in both LIST1 and LIST2.
1136 This is a destructive function; it reuses the storage of LIST1 and LIST2
1137 whenever possible.
1138
1139 Keywords supported:  :test :test-not :key
1140
1141 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1142
1143 (autoload 'cl-set-difference "cl-seq" "\
1144 Combine LIST1 and LIST2 using a set-difference operation.
1145 The resulting list contains all items that appear in LIST1 but not LIST2.
1146 This is a non-destructive function; it makes a copy of the data if necessary
1147 to avoid corrupting the original LIST1 and LIST2.
1148
1149 Keywords supported:  :test :test-not :key
1150
1151 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1152
1153 (autoload 'cl-nset-difference "cl-seq" "\
1154 Combine LIST1 and LIST2 using a set-difference operation.
1155 The resulting list contains all items that appear in LIST1 but not LIST2.
1156 This is a destructive function; it reuses the storage of LIST1 and LIST2
1157 whenever possible.
1158
1159 Keywords supported:  :test :test-not :key
1160
1161 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1162
1163 (autoload 'cl-set-exclusive-or "cl-seq" "\
1164 Combine LIST1 and LIST2 using a set-exclusive-or operation.
1165 The resulting list contains all items appearing in exactly one of LIST1, LIST2.
1166 This is a non-destructive function; it makes a copy of the data if necessary
1167 to avoid corrupting the original LIST1 and LIST2.
1168
1169 Keywords supported:  :test :test-not :key
1170
1171 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1172
1173 (autoload 'cl-nset-exclusive-or "cl-seq" "\
1174 Combine LIST1 and LIST2 using a set-exclusive-or operation.
1175 The resulting list contains all items appearing in exactly one of LIST1, LIST2.
1176 This is a destructive function; it reuses the storage of LIST1 and LIST2
1177 whenever possible.
1178
1179 Keywords supported:  :test :test-not :key
1180
1181 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1182
1183 (autoload 'cl-subsetp "cl-seq" "\
1184 Return true if LIST1 is a subset of LIST2.
1185 I.e., if every element of LIST1 also appears in LIST2.
1186
1187 Keywords supported:  :test :test-not :key
1188
1189 \(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil)
1190
1191 (autoload 'cl-subst-if "cl-seq" "\
1192 Substitute NEW for elements matching PREDICATE in TREE (non-destructively).
1193 Return a copy of TREE with all matching elements replaced by NEW.
1194
1195 Keywords supported:  :key
1196
1197 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil)
1198
1199 (autoload 'cl-subst-if-not "cl-seq" "\
1200 Substitute NEW for elts not matching PREDICATE in TREE (non-destructively).
1201 Return a copy of TREE with all non-matching elements replaced by NEW.
1202
1203 Keywords supported:  :key
1204
1205 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil)
1206
1207 (autoload 'cl-nsubst "cl-seq" "\
1208 Substitute NEW for OLD everywhere in TREE (destructively).
1209 Any element of TREE which is `eql' to OLD is changed to NEW (via a call
1210 to `setcar').
1211
1212 Keywords supported:  :test :test-not :key
1213
1214 \(fn NEW OLD TREE [KEYWORD VALUE]...)" nil nil)
1215
1216 (autoload 'cl-nsubst-if "cl-seq" "\
1217 Substitute NEW for elements matching PREDICATE in TREE (destructively).
1218 Any element of TREE which matches is changed to NEW (via a call to `setcar').
1219
1220 Keywords supported:  :key
1221
1222 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil)
1223
1224 (autoload 'cl-nsubst-if-not "cl-seq" "\
1225 Substitute NEW for elements not matching PREDICATE in TREE (destructively).
1226 Any element of TREE which matches is changed to NEW (via a call to `setcar').
1227
1228 Keywords supported:  :key
1229
1230 \(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil)
1231
1232 (autoload 'cl-sublis "cl-seq" "\
1233 Perform substitutions indicated by ALIST in TREE (non-destructively).
1234 Return a copy of TREE with all matching elements replaced.
1235
1236 Keywords supported:  :test :test-not :key
1237
1238 \(fn ALIST TREE [KEYWORD VALUE]...)" nil nil)
1239
1240 (autoload 'cl-nsublis "cl-seq" "\
1241 Perform substitutions indicated by ALIST in TREE (destructively).
1242 Any matching element of TREE is changed via a call to `setcar'.
1243
1244 Keywords supported:  :test :test-not :key
1245
1246 \(fn ALIST TREE [KEYWORD VALUE]...)" nil nil)
1247
1248 (autoload 'cl-tree-equal "cl-seq" "\
1249 Return t if trees TREE1 and TREE2 have `eql' leaves.
1250 Atoms are compared by `eql'; cons cells are compared recursively.
1251
1252 Keywords supported:  :test :test-not :key
1253
1254 \(fn TREE1 TREE2 [KEYWORD VALUE]...)" nil nil)
1255
1256 ;;;***
1257 \f
1258 ;; Local Variables:
1259 ;; version-control: never
1260 ;; no-byte-compile: t
1261 ;; no-update-autoloads: t
1262 ;; coding: utf-8
1263 ;; End:
1264 ;;; cl-loaddefs.el ends here