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