lisp/emacs-lisp/cl-loaddefs.el

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