Mercurial > hg > xemacs-beta

comparison lisp/cl/cl-defs.el @ 0:376386a54a3c r19-14

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import from CVS: tag r19-14
author cvs
date Mon, 13 Aug 2007 08:45:50 +0200
parents
children 489f57a838ef
comparison
equal deleted inserted replaced
-1:000000000000 0:376386a54a3c
1
2 ;;;### (autoloads (cl-macroexpand-all cl-prettyexpand cl-progv-before hash-table-count hash-table-p cl-puthash cl-hash-lookup make-hash-table cl-do-remf cl-set-getf getf get* tailp list-length nreconc revappend notevery notany every some map cl-mapcar-many concatenate random-state-p make-random-state random* signum rem* mod* round* truncate* ceiling* floor* isqrt lcm gcd cl-float-limits cl-set-frame-visible-p cl-map-overlays cl-map-intervals cl-map-keymap-recursively cl-map-keymap mapcon mapcan mapl mapc maplist equalp coerce) "cl-extra" "cl/cl-extra.el" (12636 41267))
3 ;;; Generated autoloads from cl/cl-extra.el
4
5 (autoload 'coerce "cl-extra" "\
6 Coerce OBJECT to type TYPE.
7 TYPE is a Common Lisp type specifier." nil nil)
8
9 (autoload 'equalp "cl-extra" "\
10 T if two Lisp objects have similar structures and contents.
11 This is like `equal', except that it accepts numerically equal
12 numbers of different types (float vs. integer), and also compares
13 strings case-insensitively." nil nil)
14
15 (autoload 'maplist "cl-extra" "\
16 Map FUNC to each sublist of LIST or LISTS.
17 Like `mapcar', except applies to lists and their cdr's rather than to
18 the elements themselves." nil nil)
19
20 (autoload 'mapc "cl-extra" "\
21 Like `mapcar', but does not accumulate values returned by the function." nil nil)
22
23 (autoload 'mapl "cl-extra" "\
24 Like `maplist', but does not accumulate values returned by the function." nil nil)
25
26 (autoload 'mapcan "cl-extra" "\
27 Like `mapcar', but nconc's together the values returned by the function." nil nil)
28
29 (autoload 'mapcon "cl-extra" "\
30 Like `maplist', but nconc's together the values returned by the function." nil nil)
31
32 (autoload 'cl-map-keymap "cl-extra" nil nil nil)
33
34 (autoload 'cl-map-keymap-recursively "cl-extra" nil nil nil)
35
36 (autoload 'cl-map-intervals "cl-extra" nil nil nil)
37
38 (autoload 'cl-map-overlays "cl-extra" nil nil nil)
39
40 (autoload 'cl-set-frame-visible-p "cl-extra" nil nil nil)
41
42 (autoload 'cl-float-limits "cl-extra" nil nil nil)
43
44 (autoload 'gcd "cl-extra" "\
45 Return the greatest common divisor of the arguments." nil nil)
46
47 (autoload 'lcm "cl-extra" "\
48 Return the least common multiple of the arguments." nil nil)
49
50 (autoload 'isqrt "cl-extra" "\
51 Return the integer square root of the argument." nil nil)
52
53 (autoload 'floor* "cl-extra" "\
54 Return a list of the floor of X and the fractional part of X.
55 With two arguments, return floor and remainder of their quotient." nil nil)
56
57 (autoload 'ceiling* "cl-extra" "\
58 Return a list of the ceiling of X and the fractional part of X.
59 With two arguments, return ceiling and remainder of their quotient." nil nil)
60
61 (autoload 'truncate* "cl-extra" "\
62 Return a list of the integer part of X and the fractional part of X.
63 With two arguments, return truncation and remainder of their quotient." nil nil)
64
65 (autoload 'round* "cl-extra" "\
66 Return a list of X rounded to the nearest integer and the remainder.
67 With two arguments, return rounding and remainder of their quotient." nil nil)
68
69 (autoload 'mod* "cl-extra" "\
70 The remainder of X divided by Y, with the same sign as Y." nil nil)
71
72 (autoload 'rem* "cl-extra" "\
73 The remainder of X divided by Y, with the same sign as X." nil nil)
74
75 (autoload 'signum "cl-extra" "\
76 Return 1 if A is positive, -1 if negative, 0 if zero." nil nil)
77
78 (autoload 'random* "cl-extra" "\
79 Return a random nonnegative number less than LIM, an integer or float.
80 Optional second arg STATE is a random-state object." nil nil)
81
82 (autoload 'make-random-state "cl-extra" "\
83 Return a copy of random-state STATE, or of `*random-state*' if omitted.
84 If STATE is t, return a new state object seeded from the time of day." nil nil)
85
86 (autoload 'random-state-p "cl-extra" "\
87 Return t if OBJECT is a random-state object." nil nil)
88
89 (autoload 'concatenate "cl-extra" "\
90 Concatenate, into a sequence of type TYPE, the argument SEQUENCES." nil nil)
91
92 (autoload 'cl-mapcar-many "cl-extra" nil nil nil)
93
94 (autoload 'map "cl-extra" "\
95 Map a function across one or more sequences, returning a sequence.
96 TYPE is the sequence type to return, FUNC is the function, and SEQS
97 are the argument sequences." nil nil)
98
99 (autoload 'some "cl-extra" "\
100 Return true if PREDICATE is true of any element of SEQ or SEQs.
101 If so, return the true (non-nil) value returned by PREDICATE." nil nil)
102
103 (autoload 'every "cl-extra" "\
104 Return true if PREDICATE is true of every element of SEQ or SEQs." nil nil)
105
106 (autoload 'notany "cl-extra" "\
107 Return true if PREDICATE is false of every element of SEQ or SEQs." nil nil)
108
109 (autoload 'notevery "cl-extra" "\
110 Return true if PREDICATE is false of some element of SEQ or SEQs." nil nil)
111
112 (autoload 'revappend "cl-extra" "\
113 Equivalent to (append (reverse X) Y)." nil nil)
114
115 (autoload 'nreconc "cl-extra" "\
116 Equivalent to (nconc (nreverse X) Y)." nil nil)
117
118 (autoload 'list-length "cl-extra" "\
119 Return the length of a list. Return nil if list is circular." nil nil)
120
121 (autoload 'tailp "cl-extra" "\
122 Return true if SUBLIST is a tail of LIST." nil nil)
123
124 (autoload 'get* "cl-extra" "\
125 Return the value of SYMBOL's PROPNAME property, or DEFAULT if none." nil nil)
126
127 (autoload 'getf "cl-extra" "\
128 Search PROPLIST for property PROPNAME; return its value or DEFAULT.
129 PROPLIST is a list of the sort returned by `symbol-plist'." nil nil)
130
131 (autoload 'cl-set-getf "cl-extra" nil nil nil)
132
133 (autoload 'cl-do-remf "cl-extra" nil nil nil)
134
135 (autoload 'make-hash-table "cl-extra" "\
136 Make an empty Common Lisp-style hash-table.
137 If :test is `eq', this can use Lucid Emacs built-in hash-tables.
138 In non-Lucid Emacs, or with non-`eq' test, this internally uses a-lists.
139 Keywords supported: :test :size
140 The Common Lisp keywords :rehash-size and :rehash-threshold are ignored." nil nil)
141
142 (autoload 'cl-hash-lookup "cl-extra" nil nil nil)
143
144 (autoload 'cl-puthash "cl-extra" nil nil nil)
145
146 (autoload 'hash-table-p "cl-extra" "\
147 Return t if OBJECT is a hash table." nil nil)
148
149 (autoload 'hash-table-count "cl-extra" "\
150 Return the number of entries in HASH-TABLE." nil nil)
151
152 (autoload 'cl-progv-before "cl-extra" nil nil nil)
153
154 (autoload 'cl-prettyexpand "cl-extra" nil nil nil)
155
156 (autoload 'cl-macroexpand-all "cl-extra" "\
157 Expand all macro calls through a Lisp FORM.
158 This also does some trivial optimizations to make the form prettier." nil nil)
159
160 ;;;***
161
162 ;;;### (autoloads (tree-equal nsublis sublis nsubst-if-not nsubst-if nsubst subst-if-not subst-if subsetp nset-exclusive-or set-exclusive-or nset-difference set-difference nintersection intersection nunion union rassoc-if-not rassoc-if rassoc* assoc-if-not assoc-if assoc* cl-adjoin member-if-not member-if member* merge stable-sort sort* search mismatch count-if-not count-if count position-if-not position-if position find-if-not find-if find nsubstitute-if-not nsubstitute-if nsubstitute substitute-if-not substitute-if substitute delete-duplicates remove-duplicates delete-if-not delete-if delete* remove-if-not remove-if remove* remove remq replace fill reduce) "cl-seq" "cl/cl-seq.el" (12559 39909))
163 ;;; Generated autoloads from cl/cl-seq.el
164
165 (autoload 'reduce "cl-seq" "\
166 Reduce two-argument FUNCTION across SEQUENCE.
167 Keywords supported: :start :end :from-end :initial-value :key" nil nil)
168
169 (autoload 'fill "cl-seq" "\
170 Fill the elements of SEQ with ITEM.
171 Keywords supported: :start :end" nil nil)
172
173 (autoload 'replace "cl-seq" "\
174 Replace the elements of SEQ1 with the elements of SEQ2.
175 SEQ1 is destructively modified, then returned.
176 Keywords supported: :start1 :end1 :start2 :end2" nil nil)
177
178 (autoload 'remq "cl-seq" nil nil nil)
179
180 (autoload 'remove "cl-seq" nil nil nil)
181
182 (autoload 'remove* "cl-seq" "\
183 Remove all occurrences of ITEM in SEQ.
184 This is a non-destructive function; it makes a copy of SEQ if necessary
185 to avoid corrupting the original SEQ.
186 Keywords supported: :test :test-not :key :count :start :end :from-end" nil nil)
187
188 (autoload 'remove-if "cl-seq" "\
189 Remove all items satisfying PREDICATE in SEQ.
190 This is a non-destructive function; it makes a copy of SEQ if necessary
191 to avoid corrupting the original SEQ.
192 Keywords supported: :key :count :start :end :from-end" nil nil)
193
194 (autoload 'remove-if-not "cl-seq" "\
195 Remove all items not satisfying PREDICATE in SEQ.
196 This is a non-destructive function; it makes a copy of SEQ if necessary
197 to avoid corrupting the original SEQ.
198 Keywords supported: :key :count :start :end :from-end" nil nil)
199
200 (autoload 'delete* "cl-seq" "\
201 Remove all occurrences of ITEM in SEQ.
202 This is a destructive function; it reuses the storage of SEQ whenever possible.
203 Keywords supported: :test :test-not :key :count :start :end :from-end" nil nil)
204
205 (autoload 'delete-if "cl-seq" "\
206 Remove all items satisfying PREDICATE in SEQ.
207 This is a destructive function; it reuses the storage of SEQ whenever possible.
208 Keywords supported: :key :count :start :end :from-end" nil nil)
209
210 (autoload 'delete-if-not "cl-seq" "\
211 Remove all items not satisfying PREDICATE in SEQ.
212 This is a destructive function; it reuses the storage of SEQ whenever possible.
213 Keywords supported: :key :count :start :end :from-end" nil nil)
214
215 (autoload 'remove-duplicates "cl-seq" "\
216 Return a copy of SEQ with all duplicate elements removed.
217 Keywords supported: :test :test-not :key :start :end :from-end" nil nil)
218
219 (autoload 'delete-duplicates "cl-seq" "\
220 Remove all duplicate elements from SEQ (destructively).
221 Keywords supported: :test :test-not :key :start :end :from-end" nil nil)
222
223 (autoload 'substitute "cl-seq" "\
224 Substitute NEW for OLD in SEQ.
225 This is a non-destructive function; it makes a copy of SEQ if necessary
226 to avoid corrupting the original SEQ.
227 Keywords supported: :test :test-not :key :count :start :end :from-end" nil nil)
228
229 (autoload 'substitute-if "cl-seq" "\
230 Substitute NEW for all items satisfying PREDICATE in SEQ.
231 This is a non-destructive function; it makes a copy of SEQ if necessary
232 to avoid corrupting the original SEQ.
233 Keywords supported: :key :count :start :end :from-end" nil nil)
234
235 (autoload 'substitute-if-not "cl-seq" "\
236 Substitute NEW for all items not satisfying PREDICATE in SEQ.
237 This is a non-destructive function; it makes a copy of SEQ if necessary
238 to avoid corrupting the original SEQ.
239 Keywords supported: :key :count :start :end :from-end" nil nil)
240
241 (autoload 'nsubstitute "cl-seq" "\
242 Substitute NEW for OLD in SEQ.
243 This is a destructive function; it reuses the storage of SEQ whenever possible.
244 Keywords supported: :test :test-not :key :count :start :end :from-end" nil nil)
245
246 (autoload 'nsubstitute-if "cl-seq" "\
247 Substitute NEW for all items satisfying PREDICATE in SEQ.
248 This is a destructive function; it reuses the storage of SEQ whenever possible.
249 Keywords supported: :key :count :start :end :from-end" nil nil)
250
251 (autoload 'nsubstitute-if-not "cl-seq" "\
252 Substitute NEW for all items not satisfying PREDICATE in SEQ.
253 This is a destructive function; it reuses the storage of SEQ whenever possible.
254 Keywords supported: :key :count :start :end :from-end" nil nil)
255
256 (autoload 'find "cl-seq" "\
257 Find the first occurrence of ITEM in LIST.
258 Return the matching ITEM, or nil if not found.
259 Keywords supported: :test :test-not :key :start :end :from-end" nil nil)
260
261 (autoload 'find-if "cl-seq" "\
262 Find the first item satisfying PREDICATE in LIST.
263 Return the matching ITEM, or nil if not found.
264 Keywords supported: :key :start :end :from-end" nil nil)
265
266 (autoload 'find-if-not "cl-seq" "\
267 Find the first item not satisfying PREDICATE in LIST.
268 Return the matching ITEM, or nil if not found.
269 Keywords supported: :key :start :end :from-end" nil nil)
270
271 (autoload 'position "cl-seq" "\
272 Find the first occurrence of ITEM in LIST.
273 Return the index of the matching item, or nil if not found.
274 Keywords supported: :test :test-not :key :start :end :from-end" nil nil)
275
276 (autoload 'position-if "cl-seq" "\
277 Find the first item satisfying PREDICATE in LIST.
278 Return the index of the matching item, or nil if not found.
279 Keywords supported: :key :start :end :from-end" nil nil)
280
281 (autoload 'position-if-not "cl-seq" "\
282 Find the first item not satisfying PREDICATE in LIST.
283 Return the index of the matching item, or nil if not found.
284 Keywords supported: :key :start :end :from-end" nil nil)
285
286 (autoload 'count "cl-seq" "\
287 Count the number of occurrences of ITEM in LIST.
288 Keywords supported: :test :test-not :key :start :end" nil nil)
289
290 (autoload 'count-if "cl-seq" "\
291 Count the number of items satisfying PREDICATE in LIST.
292 Keywords supported: :key :start :end" nil nil)
293
294 (autoload 'count-if-not "cl-seq" "\
295 Count the number of items not satisfying PREDICATE in LIST.
296 Keywords supported: :key :start :end" nil nil)
297
298 (autoload 'mismatch "cl-seq" "\
299 Compare SEQ1 with SEQ2, return index of first mismatching element.
300 Return nil if the sequences match. If one sequence is a prefix of the
301 other, the return value indicates the end of the shorted sequence.
302 Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end" nil nil)
303
304 (autoload 'search "cl-seq" "\
305 Search for SEQ1 as a subsequence of SEQ2.
306 Return the index of the leftmost element of the first match found;
307 return nil if there are no matches.
308 Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end" nil nil)
309
310 (autoload 'sort* "cl-seq" "\
311 Sort the argument SEQUENCE according to PREDICATE.
312 This is a destructive function; it reuses the storage of SEQUENCE if possible.
313 Keywords supported: :key" nil nil)
314
315 (autoload 'stable-sort "cl-seq" "\
316 Sort the argument SEQUENCE stably according to PREDICATE.
317 This is a destructive function; it reuses the storage of SEQUENCE if possible.
318 Keywords supported: :key" nil nil)
319
320 (autoload 'merge "cl-seq" "\
321 Destructively merge the two sequences to produce a new sequence.
322 TYPE is the sequence type to return, SEQ1 and SEQ2 are the two
323 argument sequences, and PRED is a `less-than' predicate on the elements.
324 Keywords supported: :key" nil nil)
325
326 (autoload 'member* "cl-seq" "\
327 Find the first occurrence of ITEM in LIST.
328 Return the sublist of LIST whose car is ITEM.
329 Keywords supported: :test :test-not :key" nil nil)
330
331 (autoload 'member-if "cl-seq" "\
332 Find the first item satisfying PREDICATE in LIST.
333 Return the sublist of LIST whose car matches.
334 Keywords supported: :key" nil nil)
335
336 (autoload 'member-if-not "cl-seq" "\
337 Find the first item not satisfying PREDICATE in LIST.
338 Return the sublist of LIST whose car matches.
339 Keywords supported: :key" nil nil)
340
341 (autoload 'cl-adjoin "cl-seq" nil nil nil)
342
343 (autoload 'assoc* "cl-seq" "\
344 Find the first item whose car matches ITEM in LIST.
345 Keywords supported: :test :test-not :key" nil nil)
346
347 (autoload 'assoc-if "cl-seq" "\
348 Find the first item whose car satisfies PREDICATE in LIST.
349 Keywords supported: :key" nil nil)
350
351 (autoload 'assoc-if-not "cl-seq" "\
352 Find the first item whose car does not satisfy PREDICATE in LIST.
353 Keywords supported: :key" nil nil)
354
355 (autoload 'rassoc* "cl-seq" "\
356 Find the first item whose cdr matches ITEM in LIST.
357 Keywords supported: :test :test-not :key" nil nil)
358
359 (autoload 'rassoc-if "cl-seq" "\
360 Find the first item whose cdr satisfies PREDICATE in LIST.
361 Keywords supported: :key" nil nil)
362
363 (autoload 'rassoc-if-not "cl-seq" "\
364 Find the first item whose cdr does not satisfy PREDICATE in LIST.
365 Keywords supported: :key" nil nil)
366
367 (autoload 'union "cl-seq" "\
368 Combine LIST1 and LIST2 using a set-union operation.
369 The result list contains all items that appear in either LIST1 or LIST2.
370 This is a non-destructive function; it makes a copy of the data if necessary
371 to avoid corrupting the original LIST1 and LIST2.
372 Keywords supported: :test :test-not :key" nil nil)
373
374 (autoload 'nunion "cl-seq" "\
375 Combine LIST1 and LIST2 using a set-union operation.
376 The result list contains all items that appear in either LIST1 or LIST2.
377 This is a destructive function; it reuses the storage of LIST1 and LIST2
378 whenever possible.
379 Keywords supported: :test :test-not :key" nil nil)
380
381 (autoload 'intersection "cl-seq" "\
382 Combine LIST1 and LIST2 using a set-intersection operation.
383 The result list contains all items that appear in both LIST1 and LIST2.
384 This is a non-destructive function; it makes a copy of the data if necessary
385 to avoid corrupting the original LIST1 and LIST2.
386 Keywords supported: :test :test-not :key" nil nil)
387
388 (autoload 'nintersection "cl-seq" "\
389 Combine LIST1 and LIST2 using a set-intersection operation.
390 The result list contains all items that appear in both LIST1 and LIST2.
391 This is a destructive function; it reuses the storage of LIST1 and LIST2
392 whenever possible.
393 Keywords supported: :test :test-not :key" nil nil)
394
395 (autoload 'set-difference "cl-seq" "\
396 Combine LIST1 and LIST2 using a set-difference operation.
397 The result list contains all items that appear in LIST1 but not LIST2.
398 This is a non-destructive function; it makes a copy of the data if necessary
399 to avoid corrupting the original LIST1 and LIST2.
400 Keywords supported: :test :test-not :key" nil nil)
401
402 (autoload 'nset-difference "cl-seq" "\
403 Combine LIST1 and LIST2 using a set-difference operation.
404 The result list contains all items that appear in LIST1 but not LIST2.
405 This is a destructive function; it reuses the storage of LIST1 and LIST2
406 whenever possible.
407 Keywords supported: :test :test-not :key" nil nil)
408
409 (autoload 'set-exclusive-or "cl-seq" "\
410 Combine LIST1 and LIST2 using a set-exclusive-or operation.
411 The result list contains all items that appear in exactly one of LIST1, LIST2.
412 This is a non-destructive function; it makes a copy of the data if necessary
413 to avoid corrupting the original LIST1 and LIST2.
414 Keywords supported: :test :test-not :key" nil nil)
415
416 (autoload 'nset-exclusive-or "cl-seq" "\
417 Combine LIST1 and LIST2 using a set-exclusive-or operation.
418 The result list contains all items that appear in exactly one of LIST1, LIST2.
419 This is a destructive function; it reuses the storage of LIST1 and LIST2
420 whenever possible.
421 Keywords supported: :test :test-not :key" nil nil)
422
423 (autoload 'subsetp "cl-seq" "\
424 True if LIST1 is a subset of LIST2.
425 I.e., if every element of LIST1 also appears in LIST2.
426 Keywords supported: :test :test-not :key" nil nil)
427
428 (autoload 'subst-if "cl-seq" "\
429 Substitute NEW for elements matching PREDICATE in TREE (non-destructively).
430 Return a copy of TREE with all matching elements replaced by NEW.
431 Keywords supported: :key" nil nil)
432
433 (autoload 'subst-if-not "cl-seq" "\
434 Substitute NEW for elts not matching PREDICATE in TREE (non-destructively).
435 Return a copy of TREE with all non-matching elements replaced by NEW.
436 Keywords supported: :key" nil nil)
437
438 (autoload 'nsubst "cl-seq" "\
439 Substitute NEW for OLD everywhere in TREE (destructively).
440 Any element of TREE which is `eql' to OLD is changed to NEW (via a call
441 to `setcar').
442 Keywords supported: :test :test-not :key" nil nil)
443
444 (autoload 'nsubst-if "cl-seq" "\
445 Substitute NEW for elements matching PREDICATE in TREE (destructively).
446 Any element of TREE which matches is changed to NEW (via a call to `setcar').
447 Keywords supported: :key" nil nil)
448
449 (autoload 'nsubst-if-not "cl-seq" "\
450 Substitute NEW for elements not matching PREDICATE in TREE (destructively).
451 Any element of TREE which matches is changed to NEW (via a call to `setcar').
452 Keywords supported: :key" nil nil)
453
454 (autoload 'sublis "cl-seq" "\
455 Perform substitutions indicated by ALIST in TREE (non-destructively).
456 Return a copy of TREE with all matching elements replaced.
457 Keywords supported: :test :test-not :key" nil nil)
458
459 (autoload 'nsublis "cl-seq" "\
460 Perform substitutions indicated by ALIST in TREE (destructively).
461 Any matching element of TREE is changed via a call to `setcar'.
462 Keywords supported: :test :test-not :key" nil nil)
463
464 (autoload 'tree-equal "cl-seq" "\
465 T if trees X and Y have `eql' leaves.
466 Atoms are compared by `eql'; cons cells are compared recursively.
467 Keywords supported: :test :test-not :key" nil nil)
468
469 ;;;***
470
471 ;;;### (autoloads (cl-compile-time-init compiler-macroexpand cl-struct-setf-expander get-setf-method cl-do-pop typep gentemp gensym) "cl-macs" "cl/cl-macs.el" (12559 39909))
472 ;;; Generated autoloads from cl/cl-macs.el
473
474 (autoload 'gensym "cl-macs" "\
475 Generate a new uninterned symbol.
476 The name is made by appending a number to PREFIX, default \"G\"." nil nil)
477
478 (autoload 'gentemp "cl-macs" "\
479 Generate a new interned symbol with a unique name.
480 The name is made by appending a number to PREFIX, default \"G\"." nil nil)
481
482 (autoload 'typep "cl-macs" "\
483 Check that OBJECT is of type TYPE.
484 TYPE is a Common Lisp-style type specifier." nil nil)
485
486 (autoload 'cl-do-pop "cl-macs" nil nil nil)
487
488 (autoload 'get-setf-method "cl-macs" "\
489 Return a list of five values describing the setf-method for PLACE.
490 PLACE may be any Lisp form which can appear as the PLACE argument to
491 a macro like `setf' or `incf'." nil nil)
492
493 (autoload 'cl-struct-setf-expander "cl-macs" nil nil nil)
494
495 (autoload 'compiler-macroexpand "cl-macs" nil nil nil)
496
497 (autoload 'cl-compile-time-init "cl-macs" nil nil nil)
498
499 ;;;***
500
501 ;;;### (autoloads (define-compiler-macro ignore-errors assert check-type defstruct callf2 callf letf* letf rotatef shiftf remf psetf setf define-modify-macro defsetf define-setf-method declare the locally multiple-value-setq multiple-value-bind lexical-let* lexical-let symbol-macrolet macrolet labels flet progv psetq do-all-symbols do-symbols dotimes dolist do* do loop return-from return block etypecase typecase ecase case load-time-value eval-when destructuring-bind function* defmacro* defun*) "cl-macs" "cl/cl-macs.el" (12559 39909))
502 ;;; Generated autoloads from cl/cl-macs.el
503
504 (autoload 'defun* "cl-macs" "\
505 (defun* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a function.
506 Like normal `defun', except ARGLIST allows full Common Lisp conventions,
507 and BODY is implicitly surrounded by (block NAME ...)." nil 'macro)
508
509 (autoload 'defmacro* "cl-macs" "\
510 (defmacro* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a macro.
511 Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
512 and BODY is implicitly surrounded by (block NAME ...)." nil 'macro)
513
514 (autoload 'function* "cl-macs" "\
515 (function* SYMBOL-OR-LAMBDA): introduce a function.
516 Like normal `function', except that if argument is a lambda form, its
517 ARGLIST allows full Common Lisp conventions." nil 'macro)
518
519 (autoload 'destructuring-bind "cl-macs" nil nil 'macro)
520
521 (autoload 'eval-when "cl-macs" "\
522 (eval-when (WHEN...) BODY...): control when BODY is evaluated.
523 If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
524 If `load' is in WHEN, BODY is evaluated when loaded after top-level compile.
525 If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level." nil 'macro)
526
527 (autoload 'load-time-value "cl-macs" "\
528 Like `progn', but evaluates the body at load time.
529 The result of the body appears to the compiler as a quoted constant." nil 'macro)
530
531 (autoload 'case "cl-macs" "\
532 (case EXPR CLAUSES...): evals EXPR, chooses from CLAUSES on that value.
533 Each clause looks like (KEYLIST BODY...). EXPR is evaluated and compared
534 against each key in each KEYLIST; the corresponding BODY is evaluated.
535 If no clause succeeds, case returns nil. A single atom may be used in
536 place of a KEYLIST of one atom. A KEYLIST of `t' or `otherwise' is
537 allowed only in the final clause, and matches if no other keys match.
538 Key values are compared by `eql'." nil 'macro)
539
540 (autoload 'ecase "cl-macs" "\
541 (ecase EXPR CLAUSES...): like `case', but error if no case fits.
542 `otherwise'-clauses are not allowed." nil 'macro)
543
544 (autoload 'typecase "cl-macs" "\
545 (typecase EXPR CLAUSES...): evals EXPR, chooses from CLAUSES on that value.
546 Each clause looks like (TYPE BODY...). EXPR is evaluated and, if it
547 satisfies TYPE, the corresponding BODY is evaluated. If no clause succeeds,
548 typecase returns nil. A TYPE of `t' or `otherwise' is allowed only in the
549 final clause, and matches if no other keys match." nil 'macro)
550
551 (autoload 'etypecase "cl-macs" "\
552 (etypecase EXPR CLAUSES...): like `typecase', but error if no case fits.
553 `otherwise'-clauses are not allowed." nil 'macro)
554
555 (autoload 'block "cl-macs" "\
556 (block NAME BODY...): define a lexically-scoped block named NAME.
557 NAME may be any symbol. Code inside the BODY forms can call `return-from'
558 to jump prematurely out of the block. This differs from `catch' and `throw'
559 in two respects: First, the NAME is an unevaluated symbol rather than a
560 quoted symbol or other form; and second, NAME is lexically rather than
561 dynamically scoped: Only references to it within BODY will work. These
562 references may appear inside macro expansions, but not inside functions
563 called from BODY." nil 'macro)
564
565 (autoload 'return "cl-macs" "\
566 (return [RESULT]): return from the block named nil.
567 This is equivalent to `(return-from nil RESULT)'." nil 'macro)
568
569 (autoload 'return-from "cl-macs" "\
570 (return-from NAME [RESULT]): return from the block named NAME.
571 This jump out to the innermost enclosing `(block NAME ...)' form,
572 returning RESULT from that form (or nil if RESULT is omitted).
573 This is compatible with Common Lisp, but note that `defun' and
574 `defmacro' do not create implicit blocks as they do in Common Lisp." nil 'macro)
575
576 (autoload 'loop "cl-macs" "\
577 (loop CLAUSE...): The Common Lisp `loop' macro.
578 Valid clauses are:
579 for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM,
580 for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR,
581 for VAR across ARRAY, repeat NUM, with VAR = INIT, while COND, until COND,
582 always COND, never COND, thereis COND, collect EXPR into VAR,
583 append EXPR into VAR, nconc EXPR into VAR, sum EXPR into VAR,
584 count EXPR into VAR, maximize EXPR into VAR, minimize EXPR into VAR,
585 if COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
586 unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
587 do EXPRS..., initially EXPRS..., finally EXPRS..., return EXPR,
588 finally return EXPR, named NAME." nil 'macro)
589
590 (autoload 'do "cl-macs" "\
591 The Common Lisp `do' loop.
592 Format is: (do ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil 'macro)
593
594 (autoload 'do* "cl-macs" "\
595 The Common Lisp `do*' loop.
596 Format is: (do* ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil 'macro)
597
598 (autoload 'dolist "cl-macs" "\
599 (dolist (VAR LIST [RESULT]) BODY...): loop over a list.
600 Evaluate BODY with VAR bound to each `car' from LIST, in turn.
601 Then evaluate RESULT to get return value, default nil." nil 'macro)
602
603 (autoload 'dotimes "cl-macs" "\
604 (dotimes (VAR COUNT [RESULT]) BODY...): loop a certain number of times.
605 Evaluate BODY with VAR bound to successive integers from 0, inclusive,
606 to COUNT, exclusive. Then evaluate RESULT to get return value, default
607 nil." nil 'macro)
608
609 (autoload 'do-symbols "cl-macs" "\
610 (dosymbols (VAR [OBARRAY [RESULT]]) BODY...): loop over all symbols.
611 Evaluate BODY with VAR bound to each interned symbol, or to each symbol
612 from OBARRAY." nil 'macro)
613
614 (autoload 'do-all-symbols "cl-macs" nil nil 'macro)
615
616 (autoload 'psetq "cl-macs" "\
617 (psetq SYM VAL SYM VAL ...): set SYMs to the values VALs in parallel.
618 This is like `setq', except that all VAL forms are evaluated (in order)
619 before assigning any symbols SYM to the corresponding values." nil 'macro)
620
621 (autoload 'progv "cl-macs" "\
622 (progv SYMBOLS VALUES BODY...): bind SYMBOLS to VALUES dynamically in BODY.
623 The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
624 Each SYMBOL in the first list is bound to the corresponding VALUE in the
625 second list (or made unbound if VALUES is shorter than SYMBOLS); then the
626 BODY forms are executed and their result is returned. This is much like
627 a `let' form, except that the list of symbols can be computed at run-time." nil 'macro)
628
629 (autoload 'flet "cl-macs" "\
630 (flet ((FUNC ARGLIST BODY...) ...) FORM...): make temporary function defns.
631 This is an analogue of `let' that operates on the function cell of FUNC
632 rather than its value cell. The FORMs are evaluated with the specified
633 function definitions in place, then the definitions are undone (the FUNCs
634 go back to their previous definitions, or lack thereof)." nil 'macro)
635
636 (autoload 'labels "cl-macs" nil nil 'macro)
637
638 (autoload 'macrolet "cl-macs" "\
639 (macrolet ((NAME ARGLIST BODY...) ...) FORM...): make temporary macro defns.
640 This is like `flet', but for macros instead of functions." nil 'macro)
641
642 (autoload 'symbol-macrolet "cl-macs" "\
643 (symbol-macrolet ((NAME EXPANSION) ...) FORM...): make symbol macro defns.
644 Within the body FORMs, references to the variable NAME will be replaced
645 by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...)." nil 'macro)
646
647 (autoload 'lexical-let "cl-macs" "\
648 (lexical-let BINDINGS BODY...): like `let', but lexically scoped.
649 The main visible difference is that lambdas inside BODY will create
650 lexical closures as in Common Lisp." nil 'macro)
651
652 (autoload 'lexical-let* "cl-macs" "\
653 (lexical-let* BINDINGS BODY...): like `let*', but lexically scoped.
654 The main visible difference is that lambdas inside BODY will create
655 lexical closures as in Common Lisp." nil 'macro)
656
657 (autoload 'multiple-value-bind "cl-macs" "\
658 (multiple-value-bind (SYM SYM...) FORM BODY): collect multiple return values.
659 FORM must return a list; the BODY is then executed with the first N elements
660 of this list bound (`let'-style) to each of the symbols SYM in turn. This
661 is analogous to the Common Lisp `multiple-value-bind' macro, using lists to
662 simulate true multiple return values. For compatibility, (values A B C) is
663 a synonym for (list A B C)." nil 'macro)
664
665 (autoload 'multiple-value-setq "cl-macs" "\
666 (multiple-value-setq (SYM SYM...) FORM): collect multiple return values.
667 FORM must return a list; the first N elements of this list are stored in
668 each of the symbols SYM in turn. This is analogous to the Common Lisp
669 `multiple-value-setq' macro, using lists to simulate true multiple return
670 values. For compatibility, (values A B C) is a synonym for (list A B C)." nil 'macro)
671
672 (autoload 'locally "cl-macs" nil nil 'macro)
673
674 (autoload 'the "cl-macs" nil nil 'macro)
675
676 (autoload 'declare "cl-macs" nil nil 'macro)
677
678 (autoload 'define-setf-method "cl-macs" "\
679 (define-setf-method NAME ARGLIST BODY...): define a `setf' method.
680 This method shows how to handle `setf's to places of the form (NAME ARGS...).
681 The argument forms ARGS are bound according to ARGLIST, as if NAME were
682 going to be expanded as a macro, then the BODY forms are executed and must
683 return a list of five elements: a temporary-variables list, a value-forms
684 list, a store-variables list (of length one), a store-form, and an access-
685 form. See `defsetf' for a simpler way to define most setf-methods." nil 'macro)
686
687 (autoload 'defsetf "cl-macs" "\
688 (defsetf NAME FUNC): define a `setf' method.
689 This macro is an easy-to-use substitute for `define-setf-method' that works
690 well for simple place forms. In the simple `defsetf' form, `setf's of
691 the form (setf (NAME ARGS...) VAL) are transformed to function or macro
692 calls of the form (FUNC ARGS... VAL). Example: (defsetf aref aset).
693 Alternate form: (defsetf NAME ARGLIST (STORE) BODY...).
694 Here, the above `setf' call is expanded by binding the argument forms ARGS
695 according to ARGLIST, binding the value form VAL to STORE, then executing
696 BODY, which must return a Lisp form that does the necessary `setf' operation.
697 Actually, ARGLIST and STORE may be bound to temporary variables which are
698 introduced automatically to preserve proper execution order of the arguments.
699 Example: (defsetf nth (n x) (v) (list 'setcar (list 'nthcdr n x) v))." nil 'macro)
700
701 (autoload 'define-modify-macro "cl-macs" "\
702 (define-modify-macro NAME ARGLIST FUNC): define a `setf'-like modify macro.
703 If NAME is called, it combines its PLACE argument with the other arguments
704 from ARGLIST using FUNC: (define-modify-macro incf (&optional (n 1)) +)" nil 'macro)
705
706 (autoload 'setf "cl-macs" "\
707 (setf PLACE VAL PLACE VAL ...): set each PLACE to the value of its VAL.
708 This is a generalized version of `setq'; the PLACEs may be symbolic
709 references such as (car x) or (aref x i), as well as plain symbols.
710 For example, (setf (cadar x) y) is equivalent to (setcar (cdar x) y).
711 The return value is the last VAL in the list." nil 'macro)
712
713 (autoload 'psetf "cl-macs" "\
714 (psetf PLACE VAL PLACE VAL ...): set PLACEs to the values VALs in parallel.
715 This is like `setf', except that all VAL forms are evaluated (in order)
716 before assigning any PLACEs to the corresponding values." nil 'macro)
717
718 (autoload 'remf "cl-macs" "\
719 (remf PLACE TAG): remove TAG from property list PLACE.
720 PLACE may be a symbol, or any generalized variable allowed by `setf'.
721 The form returns true if TAG was found and removed, nil otherwise." nil 'macro)
722
723 (autoload 'shiftf "cl-macs" "\
724 (shiftf PLACE PLACE... VAL): shift left among PLACEs.
725 Example: (shiftf A B C) sets A to B, B to C, and returns the old A.
726 Each PLACE may be a symbol, or any generalized variable allowed by `setf'." nil 'macro)
727
728 (autoload 'rotatef "cl-macs" "\
729 (rotatef PLACE...): rotate left among PLACEs.
730 Example: (rotatef A B C) sets A to B, B to C, and C to A. It returns nil.
731 Each PLACE may be a symbol, or any generalized variable allowed by `setf'." nil 'macro)
732
733 (autoload 'letf "cl-macs" "\
734 (letf ((PLACE VALUE) ...) BODY...): temporarily bind to PLACEs.
735 This is the analogue of `let', but with generalized variables (in the
736 sense of `setf') for the PLACEs. Each PLACE is set to the corresponding
737 VALUE, then the BODY forms are executed. On exit, either normally or
738 because of a `throw' or error, the PLACEs are set back to their original
739 values. Note that this macro is *not* available in Common Lisp.
740 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
741 the PLACE is not modified before executing BODY." nil 'macro)
742
743 (autoload 'letf* "cl-macs" "\
744 (letf* ((PLACE VALUE) ...) BODY...): temporarily bind to PLACEs.
745 This is the analogue of `let*', but with generalized variables (in the
746 sense of `setf') for the PLACEs. Each PLACE is set to the corresponding
747 VALUE, then the BODY forms are executed. On exit, either normally or
748 because of a `throw' or error, the PLACEs are set back to their original
749 values. Note that this macro is *not* available in Common Lisp.
750 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
751 the PLACE is not modified before executing BODY." nil 'macro)
752
753 (autoload 'callf "cl-macs" "\
754 (callf FUNC PLACE ARGS...): set PLACE to (FUNC PLACE ARGS...).
755 FUNC should be an unquoted function name. PLACE may be a symbol,
756 or any generalized variable allowed by `setf'." nil 'macro)
757
758 (autoload 'callf2 "cl-macs" "\
759 (callf2 FUNC ARG1 PLACE ARGS...): set PLACE to (FUNC ARG1 PLACE ARGS...).
760 Like `callf', but PLACE is the second argument of FUNC, not the first." nil 'macro)
761
762 (autoload 'defstruct "cl-macs" "\
763 (defstruct (NAME OPTIONS...) (SLOT SLOT-OPTS...)...): define a struct type.
764 This macro defines a new Lisp data type called NAME, which contains data
765 stored in SLOTs. This defines a `make-NAME' constructor, a `copy-NAME'
766 copier, a `NAME-p' predicate, and setf-able `NAME-SLOT' accessors." nil 'macro)
767
768 (autoload 'check-type "cl-macs" "\
769 Verify that FORM is of type TYPE; signal an error if not.
770 STRING is an optional description of the desired type." nil 'macro)
771
772 (autoload 'assert "cl-macs" "\
773 Verify that FORM returns non-nil; signal an error if not.
774 Second arg SHOW-ARGS means to include arguments of FORM in message.
775 Other args STRING and ARGS... are arguments to be passed to `error'.
776 They are not evaluated unless the assertion fails. If STRING is
777 omitted, a default message listing FORM itself is used." nil 'macro)
778
779 (autoload 'ignore-errors "cl-macs" "\
780 Execute FORMS; if an error occurs, return nil.
781 Otherwise, return result of last FORM." nil 'macro)
782
783 (autoload 'define-compiler-macro "cl-macs" "\
784 (define-compiler-macro FUNC ARGLIST BODY...): Define a compiler-only macro.
785 This is like `defmacro', but macro expansion occurs only if the call to
786 FUNC is compiled (i.e., not interpreted). Compiler macros should be used
787 for optimizing the way calls to FUNC are compiled; the form returned by
788 BODY should do the same thing as a call to the normal function called
789 FUNC, though possibly more efficiently. Note that, like regular macros,
790 compiler macros are expanded repeatedly until no further expansions are
791 possible. Unlike regular macros, BODY can decide to \"punt\" and leave the
792 original function call alone by declaring an initial `&whole foo' parameter
793 and then returning foo." nil 'macro)
794
795 ;;;***