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