lisp/emacs-lisp/cl-loaddefs.el

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