|
0
|
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 ;;;***
|
