code.delx.au - gnu-emacs/blob - lisp/emacs-lisp/cl-loaddefs.el

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