| blob | c86b24ffe2bf63486c5556adbccbff3fea505af3 |
1 ;;; cl.el --- Common-Lisp extensions for GNU Emacs Lisp.
3 ;; Copyright (C) 1987, 1988, 1989 Free Software Foundation, Inc.
5 ;; Author: Cesar Quiroz <quiroz@cs.rochester.edu>
6 ;; Keywords: extensions
10 ;; This file is part of GNU Emacs.
12 ;; GNU Emacs is distributed in the hope that it will be useful,
13 ;; but WITHOUT ANY WARRANTY. No author or distributor
14 ;; accepts responsibility to anyone for the consequences of using it
15 ;; or for whether it serves any particular purpose or works at all,
16 ;; unless he says so in writing. Refer to the GNU Emacs General Public
17 ;; License for full details.
19 ;; Everyone is granted permission to copy, modify and redistribute
20 ;; GNU Emacs, but only under the conditions described in the
21 ;; GNU Emacs General Public License. A copy of this license is
22 ;; supposed to have been given to you along with GNU Emacs so you
23 ;; can know your rights and responsibilities. It should be in a
24 ;; file named COPYING. Among other things, the copyright notice
25 ;; and this notice must be preserved on all copies.
27 ;;; Commentary:
29 ;;;; These are extensions to Emacs Lisp that provide some form of
30 ;;;; Common Lisp compatibility, beyond what is already built-in
31 ;;;; in Emacs Lisp.
32 ;;;;
33 ;;;; When developing them, I had the code spread among several files.
34 ;;;; This file 'cl.el' is a concatenation of those original files,
35 ;;;; minus some declarations that became redundant. The marks between
36 ;;;; the original files can be found easily, as they are lines that
37 ;;;; begin with four semicolons (as this does). The names of the
38 ;;;; original parts follow the four semicolons in uppercase, those
39 ;;;; names are GLOBAL, SYMBOLS, LISTS, SEQUENCES, CONDITIONALS,
40 ;;;; ITERATIONS, MULTIPLE VALUES, ARITH, SETF and DEFSTRUCT. If you
41 ;;;; add functions to this file, you might want to put them in a place
42 ;;;; that is compatible with the division above (or invent your own
43 ;;;; categories).
44 ;;;;
45 ;;;; To compile this file, make sure you load it first. This is
46 ;;;; because many things are implemented as macros and now that all
47 ;;;; the files are concatenated together one cannot ensure that
48 ;;;; declaration always precedes use.
49 ;;;;
50 \f
51 ;;;; GLOBAL
52 ;;;; This file provides utilities and declarations that are global
53 ;;;; to Common Lisp and so might be used by more than one of the
54 ;;;; other libraries. Especially, I intend to keep here some
55 ;;;; utilities that help parsing/destructuring some difficult calls.
56 ;;;;
57 ;;;;
58 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
59 ;;;; (quiroz@cs.rochester.edu)
61 ;;; Too many pieces of the rest of this package use psetq. So it is unwise to
62 ;;; use here anything but plain Emacs Lisp! There is a neater recursive form
63 ;;; for the algorithm that deals with the bodies.
65 ;;; Code:
68 "(psetq {var value }...) => nil
69 Like setq, but all the values are computed before any assignment is made."
73 length))
75 '())
88 setqs))))))
89 setqs))))))
90 \f
91 ;;; utilities
92 ;;;
93 ;;; pair-with-newsyms takes a list and returns a list of lists of the
94 ;;; form (newsym form), such that a let* can then bind the evaluation
95 ;;; of the forms to the newsyms. The idea is to guarantee correct
96 ;;; order of evaluation of the subforms of a setf. It also returns a
97 ;;; list of the newsyms generated, in the corresponding order.
100 "PAIR-WITH-NEWSYMS OLDFORMS
101 The top-level components of the list oldforms are paired with fresh
102 symbols, the pairings list and the newsyms list are returned."
112 "Merge two lists EVENS and ODDS, taking elts from each list alternatingly.
113 EVENS and ODDS are two lists. ZIP-LISTS constructs a new list, whose
114 even numbered elements (0,2,...) come from EVENS and whose odd numbered
115 elements (1,3,...) come from ODDS.
116 The construction stops when the shorter list is exhausted."
128 "Extract even and odd elements of LIST into two separate lists.
129 The argument LIST is separated in two strands, the even and the odd
130 numbered elements. Numbering starts with 0, so the first element
131 belongs in EVENS. No check is made that there is an even number of
132 elements to start with."
142 \f
144 "(reassemble-argslists ARGSLISTS) => a list of lists
145 ARGSLISTS is a list of sequences. Return a list of lists, the first
146 sublist being all the entries coming from ELT 0 of the original
147 sublists, the next those coming from ELT 1 and so on, until the
148 shortest list is exhausted."
152 ;; capture all the elements at index i
155 argslists)
156 result)))))
158 \f
159 ;;; Checking that a list of symbols contains no duplicates is a common
160 ;;; task when checking the legality of some macros. The check for 'eq
161 ;;; pairs can be too expensive, as it is quadratic on the length of
162 ;;; the list. I use a 4-pass, linear, counting approach. It surely
163 ;;; loses on small lists (less than 5 elements?), but should win for
164 ;;; larger lists. The fourth pass could be eliminated.
165 ;;; 10 dec 1986. Emacs Lisp has no REMPROP, so I just eliminated the
166 ;;; 4th pass.
168 "Find all symbols appearing more than once in LIST.
169 Return a list of all such duplicates; nil if there are no duplicates."
172 )
173 ;; check validity
177 ;; pass 1: mark
180 ;; pass 2: count
183 ;; pass 3: collect
187 ;; pass 4: unmark. eliminated.
188 ;; (dolist (x list) (remprop x propname))
189 ;; return result
190 duplicates))
192 ;;;; end of cl-global.el
193 \f
194 ;;;; SYMBOLS
195 ;;;; This file provides the gentemp function, which generates fresh
196 ;;;; symbols, plus some other minor Common Lisp symbol tools.
197 ;;;;
198 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
199 ;;;; (quiroz@cs.rochester.edu)
201 ;;; Keywords. There are no packages in Emacs Lisp, so this is only a
202 ;;; kludge around to let things be "as if" a keyword package was around.
205 "Make symbol X a keyword (symbol whose value is itself).
206 Optional second arg DOCSTRING is a documentation string for it."
213 "Return t if SYM is a keyword."
215 ;; looks like one, make sure value is right
217 nil))
220 "Return a keyword that is naturally associated with symbol SYM.
221 If SYM is keyword, the value is SYM.
222 Otherwise it is a keyword whose name is `:' followed by SYM's name."
224 sym)
230 \f
231 ;;; Temporary symbols.
232 ;;;
241 "Generate a fresh interned symbol.
242 There are two optional arguments, PREFIX and OBLIST. PREFIX is the string
243 that begins the new name, OBLIST is the obarray used to search for old
244 names. The defaults are just right, YOU SHOULD NEVER NEED THESE ARGUMENTS
245 IN YOUR OWN CODE."
257 newsymbol))
258 \f
266 "Generate a fresh uninterned symbol.
267 Optional arg PREFIX is the string that begins the new name. Most people
268 take just the default, except when debugging needs suggest otherwise."
278 newsymbol))
280 ;;;; end of cl-symbols.el
281 \f
282 ;;;; CONDITIONALS
283 ;;;; This file provides some of the conditional constructs of
284 ;;;; Common Lisp. Total compatibility is again impossible, as the
285 ;;;; 'if' form is different in both languages, so only a good
286 ;;;; approximation is desired.
287 ;;;;
288 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
289 ;;;; (quiroz@cs.rochester.edu)
291 ;;; indentation info
297 ;;; WHEN and UNLESS
298 ;;; These two forms are simplified ifs, with a single branch.
301 "(when CONDITION . BODY) => evaluate BODY if CONDITION is true."
305 "(unless CONDITION . BODY) => evaluate BODY if CONDITION is false."
307 \f
308 ;;; CASE and ECASE
309 ;;; CASE selects among several clauses, based on the value (evaluated)
310 ;;; of a expression and a list of (unevaluated) key values. ECASE is
311 ;;; the same, but signals an error if no clause is activated.
314 "(case EXPR . CASES) => evals EXPR, chooses from CASES on that value.
315 EXPR -> any form
316 CASES -> list of clauses, non empty
317 CLAUSE -> HEAD . BODY
318 HEAD -> t = catch all, must be last clause
319 -> otherwise = same as t
320 -> nil = illegal
321 -> atom = activated if (eql EXPR HEAD)
322 -> list of atoms = activated if (memq EXPR HEAD)
323 BODY -> list of forms, implicit PROGN is built around it.
324 EXPR is evaluated only once."
327 ;; convert case into a cond inside a let
333 "(ecase EXPR . CASES) => like `case', but error if no case fits.
334 `t'-clauses are not allowed."
337 ;; check that no 't clause is present.
338 ;; case-clausify would put one such at the beginning of clauses
341 ;; insert error-catching clause
345 "ecase on %s = %s failed to take any branch"
348 clauses))
349 ;; generate code as usual
354 \f
356 "CASE-CLAUSIFY CASES NEWSYM => clauses for a 'cond'
357 Converts the CASES of a [e]case macro into cond clauses to be
358 evaluated inside a let that binds NEWSYM. Returns the clauses in
359 reverse order."
367 ;; construct a cond-clause according to the head
373 ;; check it is the last clause
376 ;; accept this clause as a 't' for cond
381 result)))
385 result)))
387 ;; catch-all for this parser
391 ;;;; end of cl-conditionals.el
392 \f
393 ;;;; ITERATIONS
394 ;;;; This file provides simple iterative macros (a la Common Lisp)
395 ;;;; constructed on the basis of let, let* and while, which are the
396 ;;;; primitive binding/iteration constructs of Emacs Lisp
397 ;;;;
398 ;;;; The Common Lisp iterations use to have a block named nil
399 ;;;; wrapped around them, and allow declarations at the beginning
400 ;;;; of their bodies and you can return a value using (return ...).
401 ;;;; Nothing of the sort exists in Emacs Lisp, so I haven't tried
402 ;;;; to imitate these behaviors.
403 ;;;;
404 ;;;; Other than the above, the semantics of Common Lisp are
405 ;;;; correctly reproduced to the extent this was reasonable.
406 ;;;;
407 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
408 ;;;; (quiroz@cs.rochester.edu)
410 ;;; some lisp-indentation information
418 \f
420 "(do STEPFORMS ENDFORMS . BODY): Iterate BODY, stepping some local
421 variables. STEPFORMS must be a list of symbols or lists. In the second
422 case, the lists must start with a symbol and contain up to two more forms.
423 In the STEPFORMS, a symbol is the same as a (symbol). The other two forms
424 are the initial value (def. NIL) and the form to step (def. itself).
426 The values used by initialization and stepping are computed in parallel.
427 The ENDFORMS are a list (CONDITION . ENDBODY). If the CONDITION evaluates
428 to true in any iteration, ENDBODY is evaluated and the last form in it is
429 returned.
431 The BODY (which may be empty) is evaluated at every iteration, with the
432 symbols of the STEPFORMS bound to the initial or stepped values."
434 ;; check the syntax of the macro
437 ;; construct emacs-lisp equivalent
447 \f
449 "`do*' is to `do' as `let*' is to `let'.
450 STEPFORMS must be a list of symbols or lists. In the second case, the
451 lists must start with a symbol and contain up to two more forms. In the
452 STEPFORMS, a symbol is the same as a (symbol). The other two forms are
453 the initial value (def. NIL) and the form to step (def. itself).
455 Initializations and steppings are done in the sequence they are written.
457 The ENDFORMS are a list (CONDITION . ENDBODY). If the CONDITION evaluates
458 to true in any iteration, ENDBODY is evaluated and the last form in it is
459 returned.
461 The BODY (which may be empty) is evaluated at every iteration, with
462 the symbols of the STEPFORMS bound to the initial or stepped values."
463 ;; check the syntax of the macro
466 ;; construct emacs-lisp equivalent
476 \f
477 ;;; DO and DO* share the syntax checking functions that follow.
480 "True if FORMS is a valid stepforms for the do[*] macro (q.v.)"
492 "symbol or (symbol [init [step]])"
494 forms)))
497 "True if FORMS is a valid endforms for the do[*] macro (q.v.)"
503 "Returns a list of the initializations (for do) in FORMS
504 (a stepforms, see the do macro).
505 FORMS is assumed syntactically valid."
513 forms))
515 ;;; There used to be a reason to deal with DO differently than with
516 ;;; DO*. The writing of PSETQ has made it largely unnecessary.
519 "EXTRACT-DO-STEPS FORMS => an s-expr.
520 FORMS is the stepforms part of a DO macro (q.v.). This function constructs
521 an s-expression that does the stepping at the end of an iteration."
525 "EXTRACT-DO*-STEPS FORMS => an s-expr.
526 FORMS is the stepforms part of a DO* macro (q.v.). This function constructs
527 an s-expression that does the stepping at the end of an iteration."
531 "Separate only the forms that cause stepping."
534 entry ;to explore each form in turn
535 )
541 result))))
544 \f
545 ;;; Other iterative constructs
548 "(dolist (VAR LIST [RESULTFORM]) . BODY): do BODY for each elt of LIST.
549 The RESULTFORM defaults to nil. The VAR is bound to successive elements
550 of the value of LIST and remains bound (to the nil value) when the
551 RESULTFORM is evaluated."
552 ;; check sanity
563 ;; generate code
571 listform)
574 resultform))))
577 "(dotimes (VAR COUNTFORM [RESULTFORM]) . BODY): Repeat BODY, counting in VAR.
578 The COUNTFORM should return a positive integer. The VAR is bound to
579 successive integers from 0 to COUNTFORM - 1 and the BODY is repeated for
580 each of them. At the end, the RESULTFORM is evaluated and its value
581 returned. During this last evaluation, the VAR is still bound, and its
582 value is the number of times the iteration occurred. An omitted RESULTFORM
583 defaults to nil."
584 ;; check sanity
595 ;; generate code
606 body))))
607 \f
609 "(do_symbols (VAR [OBARRAY [RESULTFORM]]) . BODY)
610 The VAR is bound to each of the symbols in OBARRAY (def. obarray) and
611 the BODY is repeatedly performed for each of those bindings. At the
612 end, RESULTFORM (def. nil) is evaluated and its value returned.
613 During this last evaluation, the VAR is still bound and its value is nil.
614 See also the function `mapatoms'."
615 ;; check sanity
626 ;; generate code
634 oblist)
637 resultform))))
641 "(do-all-symbols (VAR [RESULTFORM]) . BODY)
642 Is the same as (do-symbols (VAR obarray RESULTFORM) . BODY)."
644 'do-symbols
646 body))
647 \f
649 "(loop . BODY) repeats BODY indefinitely and does not return.
650 Normally BODY uses `throw' or `signal' to cause an exit.
651 The forms in BODY should be lists, as non-lists are reserved for new features."
652 ;; check that the body doesn't have atomic forms
655 ;; ok, it is a list, check for atomic components
660 body)
661 ;; build the infinite loop
664 ;;;; end of cl-iterations.el
665 \f
666 ;;;; LISTS
667 ;;;; This file provides some of the lists machinery of Common-Lisp
668 ;;;; in a way compatible with Emacs Lisp. Especially, see the the
669 ;;;; typical c[ad]*r functions.
670 ;;;;
671 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
672 ;;;; (quiroz@cs.rochester.edu)
688 "Generate code for (<accessor> FORM), where <accessor> is one of the named
689 list accessors: first, second, ..., tenth, rest."
712 ))))
714 ;;; Synonyms for list functions
716 "Synonym for `car'"
721 "Return the second element of the list LIST."
726 "Return the third element of the list LIST."
731 "Return the fourth element of the list LIST."
736 "Return the fifth element of the list LIST."
741 "Return the sixth element of the list LIST."
746 "Return the seventh element of the list LIST."
751 "Return the eighth element of the list LIST."
756 "Return the ninth element of the list LIST."
761 "Return the tenth element of the list LIST."
766 "Synonym for `cdr'"
769 \f
771 "t if X is nil, nil if X is a cons; error otherwise."
778 "Returns the last link in the list LIST."
786 "Returns the length of a non-circular list, or `nil' for a circular one."
802 \f
804 "Return a new list like LIST but sans the last N elements.
805 N defaults to 1. If the list doesn't have N elements, nil is returned."
810 "Return a new list containing the first arguments consed onto the last arg.
811 Thus, (list* 1 2 3 '(a b)) returns (1 2 3 a b)."
813 arg
818 front)))
821 "Return a list which contains ITEM but is otherwise like LIST.
822 If ITEM occurs in LIST, the value is LIST. Otherwise it is (cons ITEM LIST).
823 When comparing ITEM against elements, `eql' is used."
825 list
829 "Return a new list like LIST but sans SUBLIST.
830 SUBLIST must be one of the links in LIST; otherwise the value is LIST itself."
836 \f
837 ;;; The popular c[ad]*r functions and other list accessors.
839 ;;; To implement this efficiently, a new byte compile handler is used to
840 ;;; generate the minimal code, saving one function call.
843 "Generate code for a (c[ad]+r argument). This realizes the various
844 combinations of car and cdr whose names are supported in this implementation.
845 To use this functionality for a given function,just give its name a
846 'byte-compile property of 'byte-compile-ca*d*r"
853 ;; SEQ is a list of byte-car and byte-cdr in the correct order.
862 ;; the rest of this code doesn't change the stack depth!
868 "Return the car of the car of X."
873 "Return the car of the cdr of X."
878 "Return the cdr of the car of X."
883 "Return the cdr of the cdr of X."
888 "Return the car of the car of the car of X."
893 "Return the car of the car of the cdr of X."
898 "Return the car of the cdr of the car of X."
903 "Return the cdr of the car of the car of X."
908 "Return the car of the cdr of the cdr of X."
913 "Return the cdr of the car of the cdr of X."
918 "Return the cdr of the cdr of the car of X."
923 "Return the cdr of the cdr of the cdr of X."
928 "Return the car of the car of the car of the car of X."
933 "Return the car of the car of the car of the cdr of X."
938 "Return the car of the car of the cdr of the car of X."
943 "Return the car of the cdr of the car of the car of X."
948 "Return the cdr of the car of the car of the car of X."
953 "Return the car of the car of the cdr of the cdr of X."
958 "Return the car of the cdr of the car of the cdr of X."
963 "Return the cdr of the car of the car of the cdr of X."
968 "Return the car of the cdr of the cdr of the car of X."
973 "Return the cdr of the car of the cdr of the car of X."
978 "Return the cdr of the cdr of the car of the car of X."
983 "Return the car of the cdr of the cdr of the cdr of X."
988 "Return the cdr of the cdr of the car of the cdr of X."
993 "Return the cdr of the car of the cdr of the cdr of X."
998 "Return the cdr of the cdr of the cdr of the car of X."
1003 "Return the cdr of the cdr of the cdr of the cdr of X."
1006 \f
1007 ;;; some inverses of the accessors are needed for setf purposes
1010 "Set (nth N LIST) to NEWVAL. Returns NEWVAL."
1014 "(setnthcdr N LIST NEWVAL) => NEWVAL
1015 As a side effect, sets the Nth cdr of LIST to NEWVAL."
1021 newval)
1024 \f
1025 ;;; A-lists machinery
1028 "Return a new alist with KEY paired with ITEM; otherwise like ALIST.
1029 Does not copy ALIST."
1033 "Return a new alist with each elt of KEYS paired with an elt of DATA;
1034 optional 3rd arg ALIST is nconc'd at the end. KEYS and DATA must
1035 have the same length."
1047 \f
1048 ;;;; SEQUENCES
1049 ;;;; Emacs Lisp provides many of the 'sequences' functionality of
1050 ;;;; Common Lisp. This file provides a few things that were left out.
1051 ;;;;
1066 \f
1068 "Test PREDICATE on each element of SEQUENCE; is it ever non-nil?
1069 Extra args are additional sequences; PREDICATE gets one arg from each
1070 sequence and we advance down all the sequences together in lock-step.
1071 A sequence means either a list or a vector."
1087 "Test PREDICATE on each element of SEQUENCE; is it always non-nil?
1088 Extra args are additional sequences; PREDICATE gets one arg from each
1089 sequence and we advance down all the sequences together in lock-step.
1090 A sequence means either a list or a vector."
1104 \f
1106 "Test PREDICATE on each element of SEQUENCE; is it always nil?
1107 Extra args are additional sequences; PREDICATE gets one arg from each
1108 sequence and we advance down all the sequences together in lock-step.
1109 A sequence means either a list or a vector."
1125 "Test PREDICATE on each element of SEQUENCE; is it sometimes nil?
1126 Extra args are additional sequences; PREDICATE gets one arg from each
1127 sequence and we advance down all the sequences together in lock-step.
1128 A sequence means either a list or a vector."
1142 \f
1143 ;;; More sequence functions that don't need keyword arguments
1146 "(concatenate TYPE &rest SEQUENCES) => a sequence
1147 The sequence returned is of type TYPE (must be 'list, 'string, or 'vector) and
1148 contains the concatenation of the elements of all the arguments, in the order
1149 given."
1163 "(map TYPE FUNCTION &rest SEQUENCES) => a sequence
1164 The FUNCTION is called on each set of elements from the SEQUENCES \(stopping
1165 when the shortest sequence is terminated\) and the results are possibly
1166 returned in a sequence of type TYPE \(one of 'list, 'vector, 'string, or nil\)
1167 giving NIL for TYPE gets rid of the values."
1172 results)
1178 argslists))
1181 results)
1186 \f
1187 ;;; an inverse of elt is needed for setf purposes
1190 "In SEQUENCE, set the Nth element to NEWVAL. Returns NEWVAL.
1191 A sequence means either a list or a vector."
1195 ;; only two cases need be considered valid, as strings are arrays
1203 \f
1204 ;;; Testing with keyword arguments.
1205 ;;;
1206 ;;; Many of the sequence functions use keywords to denote some stylized
1207 ;;; form of selecting entries in a sequence. The involved arguments
1208 ;;; are collected with a &rest marker (as Emacs Lisp doesn't have a &key
1209 ;;; marker), then they are passed to build-klist, who
1210 ;;; constructs an association list. That association list is used to
1211 ;;; test for satisfaction and matching.
1213 ;;; DON'T USE MEMBER, NOR ANY FUNCTION THAT COULD TAKE KEYWORDS HERE!!!
1216 "Decode a keyword argument list ARGSLIST for keywords in ACCEPTABLE.
1217 ARGSLIST is a list, presumably the &rest argument of a call, whose
1218 even numbered elements must be keywords.
1219 ACCEPTABLE is a list of keywords, the only ones that are truly acceptable.
1220 The result is an alist containing the arguments named by the keywords
1221 in ACCEPTABLE, or an error is signalled, if something failed.
1222 If the third argument (an optional) is non-nil, other keys are acceptable."
1223 ;; check legality of the arguments, then destructure them
1239 keywords))
1243 nil
1245 keywords))
1255 ;; if THIS appears in auxlist, use its value
1261 "(extract-from-klist KLIST KEY [DEFAULT]) => value of KEY or DEFAULT
1262 Extract value associated with KEY in KLIST (return DEFAULT if nil)."
1267 "(keyword-argument-supplied-p KLIST KEY) => nil or something
1268 NIL if KEY (a keyword) does not appear in the KLIST."
1272 "(ADD-TO-KLIST KEY ITEM KLIST) => new KLIST
1273 Add association (KEY . ITEM) to KLIST."
1277 "(elt-satisfies-test-p ITEM ELT KLIST) => t or nil
1278 KLIST encodes a keyword-arguments test, as in CH. 14 of CLtL.
1279 True if the given ITEM and ELT satisfy the test."
1292 "(elt-satisfies-if-p ITEM KLIST) => t or nil
1293 True if an -if style function was called and ITEM satisfies the
1294 predicate under :predicate in KLIST."
1300 "(elt-satisfies-if-not-p ITEM KLIST) => t or nil
1301 KLIST encodes a keyword-arguments test, as in CH. 14 of CLtL.
1302 True if an -if-not style function was called and ITEM does not satisfy
1303 the predicate under :predicate in KLIST."
1309 "(elts-match-under-klist-p E1 E2 KLIST) => t or nil
1310 KLIST encodes a keyword-arguments test, as in CH. 14 of CLtL.
1311 True if elements E1 and E2 match under the tests encoded in KLIST."
1325 \f
1326 ;;; This macro simplifies using keyword args. It is less clumsy than using
1327 ;;; the primitives build-klist, etc... For instance, member could be written
1328 ;;; this way:
1330 ;;; (defun member (item list &rest kargs)
1331 ;;; (with-keyword-args kargs (test test-not (key 'identity))
1332 ;;; ...))
1334 ;;; Suggested by Robert Potter (potter@cs.rochester.edu, 15 Nov 1989)
1337 "(WITH-KEYWORD-ARGS KEYARGSLIST VARDEFS . BODY)
1338 KEYARGSLIST can be either a symbol or a list of one or two symbols.
1339 In the second case, the second symbol is either T or NIL, indicating whether
1340 keywords other than the mentioned ones are tolerable.
1342 VARDEFS is a list. Each entry is either a VAR (symbol) or matches
1343 \(VAR [DEFAULT [KEYWORD]]). Just giving VAR is the same as giving
1344 \(VAR nil :VAR).
1346 The BODY is executed in an environment where each VAR (a symbol) is bound to
1347 the value present in the KEYARGSLIST provided, or to the DEFAULT. The value
1348 is searched by using the keyword form of VAR (i.e., :VAR) or the optional
1349 keyword if provided.
1351 Notice that this macro doesn't distinguish between a default value given
1352 explicitly by the user and one provided by default. See also the more
1353 primitive functions build-klist, add-to-klist, extract-from-klist,
1354 keyword-argument-supplied-p, elt-satisfies-test-p, elt-satisfies-if-p,
1355 elt-satisfies-if-not-p, elts-match-under-klist-p. They provide more complete,
1356 if clumsier, control over this feature."
1361 "`%s' should be SYMBOL, (SYMBOL), or (SYMBOL t-OR-nil)"
1369 "first subform should be SYMBOL, (SYMBOL), or (SYMBOL t-OR-nil)"
1370 )))
1386 "`%s' must match (VAR [DEFAULT [KEYWORD]])"
1390 "bad variable `%s': must be non-null symbol"
1403 klistname
1404 k
1405 d))
1406 forms)))))
1407 vardefs)
1412 allow-other-keys)))
1414 body))))
1417 \f
1418 ;;; REDUCE
1419 ;;; It is here mostly as an example of how to use KLISTs.
1420 ;;;
1421 ;;; First of all, you need to declare the keywords (done elsewhere in this
1422 ;;; file):
1423 ;;; (defkeyword :from-end "syntax of sequence functions")
1424 ;;; (defkeyword :start "syntax of sequence functions")
1425 ;;; etc...
1426 ;;;
1427 ;;; Then, you capture all the possible keyword arguments with a &rest
1428 ;;; argument. You can pass that list downward again, of course, but
1429 ;;; internally you need to parse it into a KLIST (an alist, really). One uses
1430 ;;; (build-klist REST-ARGS ACCEPTABLE-KEYWORDS [ALLOW-OTHER]). You can then
1431 ;;; test for presence by using (keyword-argument-supplied-p KLIST KEY) and
1432 ;;; extract a value with (extract-from-klist KLIST KEY [DEFAULT]).
1435 "Apply FUNCTION (a function of two arguments) to succesive pairs of elements
1436 from SEQUENCE. Some keyword arguments are valid after FUNCTION and SEQUENCE:
1437 :from-end If non-nil, process the values backwards
1438 :initial-value If given, prefix it to the SEQUENCE. Suffix, if :from-end
1439 :start Restrict reduction to the subsequence from this index
1440 :end Restrict reduction to the subsequence BEFORE this index.
1441 If the sequence is empty and no :initial-value is given, the FUNCTION is
1442 called on zero (not two) arguments. Otherwise, if there is exactly one
1443 element in the combination of SEQUENCE and the initial value, that element is
1444 returned."
1457 sequence)))
1467 result))))
1470 "(cl$subseq-as-list SEQUENCE START END) => a list"
1473 result)
1479 list
1487 ;;;; end of cl-sequences.el
1488 \f
1489 ;;;; Some functions with keyword arguments
1490 ;;;;
1491 ;;;; Both list and sequence functions are considered here together. This
1492 ;;;; doesn't fit any more with the original split of functions in files.
1495 "Look for ITEM in LIST; return first tail of LIST the car of whose first
1496 cons cell tests the same as ITEM. Admits arguments :key, :test, and :test-not."
1503 ;; another workaround allegledly for speed
1511 ))
1517 ;; final hack: remove the indirection through the function names
1525 ;; ok, go for it
1540 result)))))
1541 \f
1542 ;;;; MULTIPLE VALUES
1543 ;;;; This package approximates the behavior of the multiple-values
1544 ;;;; forms of Common Lisp.
1545 ;;;;
1546 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
1547 ;;;; (quiroz@cs.rochester.edu)
1549 ;;; Lisp indentation information
1556 ;;; Global state of the package is kept here
1561 \f
1562 ;;; values is the standard multiple-value-return form. Must be the
1563 ;;; last thing evaluated inside a function. If the caller is not
1564 ;;; expecting multiple values, only the first one is passed. (values)
1565 ;;; is the same as no-values returned (unaware callers see nil). The
1566 ;;; alternative (values-list <list>) is just a convenient shorthand
1567 ;;; and complements multiple-value-list.
1570 "Produce multiple values (zero or more). Each arg is one value.
1571 See also `multiple-value-bind', which is one way to examine the
1572 multiple values produced by a form. If the containing form or caller
1573 does not check specially to see multiple values, it will see only
1574 the first value."
1580 "Produce multiple values (zero or mode). Each element of LIST is one value.
1581 This is equivalent to (apply 'values LIST)."
1588 \f
1589 ;;; Callers that want to see the multiple values use these macros.
1592 "Execute FORM and return a list of all the (multiple) values FORM produces.
1593 See `values' and `multiple-value-bind'."
1607 "Call FUNCTION on all the values produced by the remaining arguments.
1608 (multiple-value-call '+ (values 1 2) (values 3 4)) is 10."
1616 result
1621 "Bind VARS to the (multiple) values produced by FORM, then do BODY.
1622 VARS is a list of variables; each is bound to one of FORM's values.
1623 If FORM doesn't make enough values, the extra variables are bound to nil.
1624 (Ordinary forms produce only one value; to produce more, use `values'.)
1625 Extra values are ignored.
1626 BODY (zero or more forms) is executed with the variables bound,
1627 then the bindings are unwound."
1633 clauses)
1634 body)))
1635 \f
1637 "Set VARS to the (multiple) values produced by FORM.
1638 VARS is a list of variables; each is set to one of FORM's values.
1639 If FORM doesn't make enough values, the extra variables are set to nil.
1640 (Ordinary forms produce only one value; to produce more, use `values'.)
1641 Extra values are ignored."
1650 "Evaluate FORM, then BODY, then produce the same values FORM produced.
1651 Thus, (multiple-value-prog1 (values 1 2) (foobar)) produces values 1 and 2.
1652 This is like `prog1' except that `prog1' would produce only one value,
1653 which would be the first of FORM's values."
1659 ;;; utility functions
1660 ;;;
1661 ;;; mv-bind-clausify makes the pairs needed to have the variables in
1662 ;;; the variable list correspond with the values returned by the form.
1663 ;;; vals is a fresh symbol that intervenes in all the bindings.
1666 "MV-BIND-CLAUSIFY VARS VALS => Auxiliary list
1667 Forms a list of pairs `(,(nth i vars) (nth i vals)) for i from 0 to
1668 the length of VARS (a list of symbols). VALS is just a fresh symbol."
1679 ;;;; end of cl-multiple-values.el
1680 \f
1681 ;;;; ARITH
1682 ;;;; This file provides integer arithmetic extensions. Although
1683 ;;;; Emacs Lisp doesn't really support anything but integers, that
1684 ;;;; has still to be made to look more or less standard.
1685 ;;;;
1686 ;;;;
1687 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
1688 ;;;; (quiroz@cs.rochester.edu)
1692 "True if NUMBER is strictly greater than zero."
1696 "True if NUMBER is strictly less than zero."
1700 "True if INTEGER is not divisible by 2."
1704 "True if INTEGER is divisible by 2."
1708 "Return the absolute value of NUMBER."
1711 number))
1714 "Return -1, 0 or 1 according to the sign of NUMBER."
1721 \f
1723 "Return the greatest common divisor of all the arguments.
1724 The arguments must be integers. With no arguments, value is zero."
1735 ;; essentially the euclidean algorithm
1742 ;; intermediate results
1745 ;; final results
1755 "Return the least common multiple of all the arguments.
1756 The arguments must be integers and there must be at least one of them."
1760 prod ; intermediate product
1774 \f
1776 "Return the integer square root of NUMBER.
1777 NUMBER must not be negative. Result is largest integer less than or
1778 equal to the real square root of the argument."
1779 ;; The method used here is essentially the Newtonian iteration
1780 ;; x[n+1] <- (x[n] + Number/x[n]) / 2
1781 ;; suitably adapted to integer arithmetic.
1782 ;; Thanks to Philippe Schnoebelen <phs@lifia.imag.fr> for suggesting the
1783 ;; termination condition.
1786 number))
1795 approx))
1798 approx new)))))
1799 \f
1801 "Divide DIVIDEND by DIVISOR, rounding toward minus infinity.
1802 DIVISOR defaults to 1. The remainder is produced as a second value."
1822 "Divide DIVIDEND by DIVISOR, rounding toward plus infinity.
1823 DIVISOR defaults to 1. The remainder is produced as a second value."
1838 \f
1840 "Divide DIVIDEND by DIVISOR, rounding toward zero.
1841 DIVISOR defaults to 1. The remainder is produced as a second value."
1858 "Divide DIVIDEND by DIVISOR, rounding to nearest integer.
1859 DIVISOR defaults to 1. The remainder is produced as a second value."
1868 ;; adjust magnitudes first, and then signs
1874 ;; round to even is mandatory
1879 \f
1881 "Return remainder of X by Y (rounding quotient toward minus infinity).
1882 That is, the remainder goes with the quotient produced by `floor'."
1884 r))
1887 "Return remainder of X by Y (rounding quotient toward zero).
1888 That is, the remainder goes with the quotient produced by `truncate'."
1890 r))
1892 ;;; internal utilities
1893 ;;;
1894 ;;; safe-idiv performs an integer division with positive numbers only.
1895 ;;; It is known that some machines/compilers implement weird remainder
1896 ;;; computations when working with negatives, so the idea here is to
1897 ;;; make sure we know what is coming back to the caller in all cases.
1899 ;;; Signum computation fixed by mad@math.keio.JUNET (MAEDA Atusi)
1902 "SAFE-IDIV A B => Q R S
1903 Q=|A|/|B|, R is the rest, S is the sign of A/B."
1915 ;;;; end of cl-arith.el
1916 \f
1917 ;;;; SETF
1918 ;;;; This file provides the setf macro and friends. The purpose has
1919 ;;;; been modest, only the simplest defsetf forms are accepted.
1920 ;;;; Use it and enjoy.
1921 ;;;;
1922 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
1923 ;;;; (quiroz@cs.rochester.edu)
1927 "Property, its value is the function setf must invoke to update a
1928 generalized variable whose access form is a function call of the
1932 "Property of symbols that have a `defsetf' update function on them,
1934 \f
1936 "Generalized `setq' that can set things other than variable values.
1937 A use of `setf' looks like (setf {PLACE VALUE}...).
1938 The behavior of (setf PLACE VALUE) is to access the generalized variable
1939 at PLACE and store VALUE there. It returns VALUE. If there is more
1940 than one PLACE and VALUE, each PLACE is set from its VALUE before
1941 the next PLACE is evaluated."
1943 ;; check the number of subforms
1947 nil)
1949 ;; this is the recursive case
1959 result)))))
1961 ;; this is the base case (SETF PLACE VALUE)
1966 ;; dispatch on the type of the PLACE
1984 ;; this let gets new symbols to ensure adequate
1985 ;; order of evaluation of the subforms.
1987 bindings
1992 \f
1994 "Define how `setf' works on a certain kind of generalized variable.
1995 A use of `defsetf' looks like (defsetf ACCESSFN UPDATEFN [DOCSTRING]).
1996 ACCESSFN is a symbol. UPDATEFN is a function or macro which takes
1997 one more argument than ACCESSFN does. DEFSETF defines the translation
1998 of (SETF (ACCESFN . ARGS) NEWVAL) to be a form like (UPDATEFN ARGS... NEWVAL).
1999 The function UPDATEFN must return its last arg, after performing the
2000 updating called for."
2001 ;; reject ill-formed requests. too bad one can't test for functionp
2002 ;; or macrop.
2006 ;; update properties
2011 ;; any better thing to return?
2013 \f
2014 ;;; This section provides the "default" setfs for Common-Emacs-Lisp
2015 ;;; The user will not normally add anything to this, although
2016 ;;; defstruct will introduce new ones as a matter of fact.
2017 ;;;
2018 ;;; Apply is a special case. The Common Lisp
2019 ;;; standard makes the case of apply be useful when the user writes
2020 ;;; something like (apply #'name ...), Emacs Lisp doesn't have the #
2021 ;;; stuff, but it has (function ...). Notice that V18 includes a new
2022 ;;; apply: this file is compatible with V18 and pre-V18 Emacses.
2024 ;;; INCOMPATIBILITY: the SETF macro evaluates its arguments in the
2025 ;;; (correct) left to right sequence *before* checking for apply
2026 ;;; methods (which should really be an special case inside setf). Due
2027 ;;; to this, the lambda expression defsetf'd to apply will succeed in
2028 ;;; applying the right function even if the name was not quoted, but
2029 ;;; computed! That extension is not Common Lisp (nor is particularly
2030 ;;; useful, I think).
2034 ;; dissasemble the calling form
2035 ;; "(((quote fn) x1 x2 ... xn) val)" (function instead of quote, too)
2048 \f
2050 aset
2054 setnth
2058 setnthcdr
2062 setelt
2092 \f
2140 \f
2184 \f
2239 ;; how about defsetfing other Emacs forms?
2240 \f
2241 ;;; Modify macros
2242 ;;;
2243 ;;; It could be nice to implement define-modify-macro, but I don't
2244 ;;; think it really pays.
2247 "(incf REF [DELTA]) -> increment the g.v. REF by DELTA (default 1)"
2253 "(decf REF [DELTA]) -> decrement the g.v. REF by DELTA (default 1)"
2259 "(push ITEM REF) -> cons ITEM at the head of the g.v. REF (a list)"
2263 "(pushnew ITEM REF): adjoin ITEM at the head of the g.v. REF (a list)"
2267 "(pop REF) -> (prog1 (car REF) (setf REF (cdr REF)))"
2273 \f
2274 ;;; PSETF
2275 ;;;
2276 ;;; Psetf is the generalized variable equivalent of psetq. The right
2277 ;;; hand sides are evaluated and assigned (via setf) to the left hand
2278 ;;; sides. The evaluations are done in an environment where they
2279 ;;; appear to occur in parallel.
2282 "(psetf {var value }...) => nil
2283 Like setf, but all the values are computed before any assignment is made."
2287 length))
2289 '())
2302 setfs))))))
2303 setfs))))))
2304 \f
2305 ;;; SHIFTF and ROTATEF
2306 ;;;
2309 "(shiftf PLACE1 PLACE2... NEWVALUE)
2310 Set PLACE1 to PLACE2, PLACE2 to PLACE3...
2311 Each PLACE is set to the old value of the following PLACE,
2312 and the last PLACE is set to the value NEWVALUE.
2313 Returns the old value of PLACE1."
2318 ;; the places are accessed to fresh symbols
2329 "(rotatef PLACE...) sets each PLACE to the old value of the following PLACE.
2330 The last PLACE is set to the old value of the first PLACE.
2331 Thus, the values rotate through the PLACEs. Returns nil."
2333 nil
2338 'let bindings
2342 nil))))
2343 \f
2344 ;;;; STRUCTS
2345 ;;;; This file provides the structures mechanism. See the
2346 ;;;; documentation for Common-Lisp's defstruct. Mine doesn't
2347 ;;;; implement all the functionality of the standard, although some
2348 ;;;; more could be grafted if so desired. More details along with
2349 ;;;; the code.
2350 ;;;;
2351 ;;;;
2352 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
2353 ;;;; (quiroz@cs.rochester.edu)
2375 \f
2377 "(defstruct NAME [DOC-STRING] . SLOTS) define NAME as structure type.
2378 NAME must be a symbol, the name of the new structure. It could also
2379 be a list (NAME . OPTIONS).
2381 Each option is either a symbol, or a list of a keyword symbol taken from the
2382 list \{:conc-name, :copier, :constructor, :predicate, :include,
2383 :print-function, :type, :initial-offset\}. The meanings of these are as in
2384 CLtL, except that no BOA-constructors are provided, and the options
2385 \{:print-fuction, :type, :initial-offset\} are ignored quietly. All these
2386 structs are named, in the sense that their names can be used for type
2387 discrimination.
2389 The DOC-STRING is established as the `structure-doc' property of NAME.
2391 The SLOTS are one or more of the following:
2392 SYMBOL -- meaning the SYMBOL is the name of a SLOT of NAME
2393 list of SYMBOL and VALUE -- meaning that VALUE is the initial value of
2394 the slot.
2395 `defstruct' defines functions `make-NAME', `NAME-p', `copy-NAME' for the
2396 structure, and functions with the same name as the slots to access
2397 them. `setf' of the accessors sets their values."
2401 ;; Names for the member functions come from the options. The
2402 ;; slots* stuff collects info about the slots declared explicitly.
2405 moreslotsn moreslots moreinits included)
2407 ;; The moreslots* stuff refers to slots gained as a consequence
2408 ;; of (:include clauses). -- Oct 89: Only one :include tolerated
2423 ;; compute properties of NAME
2428 docstring)
2430 slotsn)
2437 ;; If this definition :includes another defstruct,
2438 ;; modify both property lists.
2443 :structure-includes
2460 old
2461 :structure-included-in
2464 ;; careful with destructive
2465 ;;manipulation!
2467 'append
2469 'get
2470 old
2472 '())
2473 )))))
2476 :structure-includes
2477 '()))))
2478 ;; If this definition used to be :included in another, warn
2479 ;; that things make break. On the other hand, the redefinition
2480 ;; may be trivial, so don't call it an error.
2489 "`%s' redefined. Should redefine `%s'?"
2493 ;; Compute functions associated with NAME. This is not
2494 ;; handling BOA constructors yet, but here would be the place.
2510 'function
2520 'and
2522 typetag
2528 'memq
2529 typetag
2533 )))))
2534 ;; compute accessors for NAME's slots
2538 ;; generate returned value -- not defined by the standard
2545 ;; generate code
2548 accessors alterators returned))))))
2549 \f
2551 "(parse$defstruct$args ARGS) => NAME OPTIONS DOCSTRING SLOTSN SLOTS INITLIST
2552 NAME=symbol, OPTIONS=list of, DOCSTRING=string, SLOTSN=count of slots,
2553 SLOTS=list of their names, INITLIST=alist (keyword . initform)."
2555 options ;args=((symbol . options) ...)
2557 slotargs ;second or third cdr of args
2561 ;; extract name and options
2564 options '()))
2572 ;; is there a docstring?
2576 ;; now for the slots
2581 \f
2583 "(process$slots SLOTS) => SLOTSN SLOTSLIST INITLIST
2584 Converts a list of symbols or lists of symbol and form into the last 3
2585 values returned by PARSE$DEFSTRUCT$ARGS."
2587 slotslist ;(slot1 slot2 ...)
2600 ;; this silently ignores any slot options. bad...
2607 \f
2609 "(parse$defstruct$options name OPTIONS SLOTS) => many values
2610 A defstruct named NAME, with options list OPTIONS, has already slots SLOTS.
2611 Parse the OPTIONS and return the updated form of the struct's slots and other
2612 information. The values returned are:
2614 CONC-NAME is the string to use as prefix/suffix in the methods,
2615 CONST is the name of the official constructor,
2616 COPIER is the name of the structure copier,
2617 PRED is the name of the type predicate,
2618 MORESLOTSN is the number of slots added by :include,
2619 MORESLOTS is the list of slots added by :include,
2620 MOREINITS is the list of initialization forms added by :include,
2621 INCLUDED is nil, or the list of the symbol added by :include"
2623 ;; to build the return values
2631 ;; auxiliaries
2632 option-head ;When an option is not a plain
2633 option-second ; keyword, it must be a list of
2634 option-rest ; the form (head second . rest)
2635 these-slotsn ;When :include is found, the
2636 these-slots ; info about the included
2637 these-inits ; structure is added here.
2638 included ;NIL or (list INCLUDED)
2639 )
2640 ;; Values above are the defaults. Now we read the options themselves
2642 ;; 2 cases arise, as options must be a keyword or a list
2646 (:named
2656 (:conc-name
2660 option-second)
2666 (:copier
2671 option-second)
2675 \f
2681 option-second)
2685 (:predicate
2690 option-second)
2694 (:include
2730 ;; Return values found
2732 moreslotsn moreslots moreinits
2733 included)))
2734 \f
2736 "(simplify$inits SLOTS INITLIST) => new INITLIST
2737 Removes from INITLIST - an ALIST - any shadowed bindings."
2739 key ;from the slot
2740 )
2747 "(extract$indices INITLIST) => indices list
2748 Kludge. From a list of pairs (keyword . form) build a list of pairs
2749 of the form (keyword . position in list from 0). Useful to precompute
2750 some of the work of MAKE$STRUCTURE$INSTANCE."
2756 \f
2758 "(build$accessors$for NAME PREDICATE SLOTS SLOTSN) => FSETS DEFSETFS KWDS
2759 Generate the code for accesors and defsetfs of a structure called
2760 NAME, whose slots are SLOTS. Also, establishes the keywords for the
2761 slots names."
2781 "`%s' is not a struct %s"
2786 name))))))))
2787 accessors))
2797 "`%s' not a `%s'"
2802 name)))))))
2803 alterators))
2806 keywords))))
2807 \f
2809 "(make$structure$instance NAME ARGS) => new struct NAME
2810 A struct of type NAME is created, some slots might be initialized
2811 according to ARGS (the &rest argument of MAKE-name)."
2818 initalist ;pairlis'd on initforms
2819 initializers ;definitive initializers
2820 )
2821 ;; check sanity of the request
2829 ;; analyze the initializers provided by the call
2833 ;; check that all the arguments are introduced by keywords
2837 ;; check that all the keywords are known
2842 ;; update initforms
2852 result)))
2854 ;; compute definitive initializers
2863 ;; do real initialization
2867 ;;;; end of cl-structs.el
2868 \f
2869 ;;; For lisp-interaction mode, so that multiple values can be seen when passed
2870 ;;; back. Lies every now and then...
2884 "Evaluate sexp before point; print value\(s\) into current buffer.
2885 If the evaled form returns multiple values, they are shown one to a line.
2886 The variables -, +, ++, +++, *, **, ***, /, //, /// have their usual meaning.
2888 It clears the multiple-value passing mechanism, and does not pass back
2889 multiple values. Use this only if you are debugging cl.el and understand well
2890 how the multiple-value stuff works, because it can be fooled into believing
2891 that multiple values have been returned when they actually haven't, for
2892 instance
2893 \(identity \(values nil 1\)\)
2894 However, even when this fails, you can trust the first printed value to be
2895 \(one of\) the returned value\(s\)."
2897 ;; top level call, can reset mvalues
2911 ** *
2914 // /
2917 ++ +
2929 /)))
2932 \f
2933 ;;;; More LISTS functions
2934 ;;;;
2936 ;;; Some mapping functions on lists, commonly useful.
2937 ;;; They take no extra sequences, to go along with Emacs Lisp's MAPCAR.
2940 "(MAPC FUNCTION LIST) => LIST
2941 Apply FUNCTION to each element of LIST, return LIST.
2942 Like mapcar, but called only for effect."
2947 list)
2950 "(MAPLIST FUNCTION LIST) => list'ed results of FUNCTION on cdrs of LIST
2951 Apply FUNCTION to successive sublists of LIST, return the list of the results"
2953 results '())
2960 "(MAPL FUNCTION LIST) => LIST
2961 Apply FUNCTION to successive cdrs of LIST, return LIST.
2962 Like maplist, but called only for effect."
2967 list))
2970 "(MAPCAN FUNCTION LIST) => nconc'd results of FUNCTION on LIST
2971 Apply FUNCTION to each element of LIST, nconc the results.
2972 Beware: nconc destroys its first argument! See copy-list."
2981 "(MAPCON FUNCTION LIST) => nconc'd results of FUNCTION on cdrs of LIST
2982 Apply FUNCTION to successive sublists of LIST, nconc the results.
2983 Beware: nconc destroys its first argument! See copy-list."
2991 ;;; Copiers
2994 "Build a copy of LIST"
2998 "Build a copy of the tree of conses TREE
2999 The argument is a tree of conses, it is recursively copied down to
3000 non conses. Circularity and sharing of substructure are not
3001 necessarily preserved."
3005 tree))
3007 ;;; reversals, and destructive manipulations of a list's spine
3010 "does what (append (reverse X) Y) would, only faster"
3012 y
3016 "does (nconc (nreverse X) Y) would, only faster
3017 Destructive on X, be careful."
3019 y
3020 ;; reuse the first cons of x, making it point to y
3024 "Side-effected LIST truncated N+1 conses from the end.
3025 This is the destructive version of BUTLAST. Returns () and does not
3026 modify the LIST argument if the length of the list is not at least N."
3030 list)
3032 '())
3035 list))))
3036 \f
3037 ;;; Substitutions
3040 "NEW replaces OLD in a copy of TREE
3041 Uses eql for the test."
3045 "NEW replaces any subtree or leaf that fails TEST in a copy of TREE"
3046 ;; (subst-if new (function (lambda (x) (not (funcall test x)))) tree)
3048 new)
3050 tree)
3054 ;; If nothing changed, return originals. Else use the new
3055 ;; components to assemble a new tree.
3058 tree
3062 "NEW replaces any subtree or leaf that satisfies TEST in a copy of TREE"
3064 new)
3066 tree)
3070 ;; If nothing changed, return originals. Else use the new
3071 ;; components to assemble a new tree.
3074 tree
3078 "Use association list ALIST to modify a copy of TREE
3079 If a subtree or leaf of TREE is a key in ALIST, it is replaced by the
3080 associated value. Not exactly Common Lisp, but close in spirit and
3081 compatible with the native Emacs Lisp ASSOC, which uses EQUAL."
3086 tree)
3092 tree
3096 "PREDICATE is applied to the members of LIST. As soon as one of them
3097 returns true, that tail of the list if returned. Else NIL."
3103 nil))
3106 "PREDICATE is applied to the members of LIST. As soon as one of them
3107 returns false, that tail of the list if returned. Else NIL."
3113 nil))
3116 "(tailp SUBLIST LIST) => True if SUBLIST is a sublist of LIST."
3122 nil))
3123 \f
3124 ;;; Suggestion of phr%widow.Berkeley.EDU@lilac.berkeley.edu
3127 "Ignore a Common-Lisp declaration."
3131 "Ignore a Common-Lisp proclamation."
3135 "(the TYPE FORM) macroexpands to FORM
3136 No checking is even attempted. This is just for compatibility with
3137 Common-Lisp codes."
3138 form)
3142 ;;; cl.el ends here