diff options
| -rw-r--r-- | lisp/ChangeLog | 86 | ||||
| -rw-r--r-- | lisp/emacs-lisp/cl-seq.el | 209 |
2 files changed, 177 insertions, 118 deletions
diff --git a/lisp/ChangeLog b/lisp/ChangeLog index f26ba678b73..f35eec9e1f0 100644 --- a/lisp/ChangeLog +++ b/lisp/ChangeLog @@ -1,20 +1,3 @@ -2005-05-20 Lute Kamstra <lute@gnu.org> - - * diff-mode.el (diff-header-face, diff-file-header-face) - (diff-index-face, diff-hunk-header-face, diff-removed-face) - (diff-added-face, diff-changed-face, diff-function-face) - (diff-context-face, diff-nonexistent-face): Put them in the - diff-mode customization group. - -2005-05-20 Stefan Monnier <monnier@iro.umontreal.ca> - - * progmodes/vhdl-mode.el (vhdl-font-lock-match-item): Simplify regexp. - - * progmodes/sh-script.el (sh-mode, sh-get-word): Minor regexp fixes. - - * font-lock.el (lisp-font-lock-keywords-2): Don't error. - Minor regexp-optimization. - 2005-05-20 Carsten Dominik <dominik@science.uva.nl> * textmodes/org.el (org-agenda-toggle-time-grid): New command. @@ -22,7 +5,7 @@ (org-agenda-add-time-grid-maybe): New function. (org-agenda): Call `org-agenda-add-time-grid-maybe'. (org-table-create): `dotimes' instead of `mapcar'. - (org-xor): Simplify implementation. + (org-xor): Simplified implementation. (org-agenda): `inhibit-redisplay' turned on. (org-agenda-change-all-lines): Use `org-format-agenda-item' to get a consistent line after a state change. @@ -36,7 +19,22 @@ 2005-05-20 Juanma Barranquero <lekktu@gmail.com> - * subr.el (send-string, send-region): Remove obsolescence declaration. + * emacs-lisp/cl-seq.el (reduce, fill, replace, remove*) + (remove-if, remove-if-not, delete*, delete-if, delete-if-not) + (remove-duplicates, delete-duplicates, substitute) + (substitute-if, substitute-if-not, nsubstitute, nsubstitute-if) + (nsubstitute-if-not, find, find-if, find-if-not, position) + (position-if, position-if-not, count, count-if, count-if-not) + (mismatch, search, sort*, stable-sort, merge, member*) + (member-if, member-if-not, assoc*, assoc-if, assoc-if-not) + (rassoc*, rassoc-if, rassoc-if-not, union, nunion) + (intersection, nintersection, set-difference, nset-difference) + (set-exclusive-or, nset-exclusive-or, subsetp, subst-if) + (subst-if-not, nsubst, nsubst-if, nsubst-if-not, sublis) + (nsublis, tree-equal): Improve argument/docstring consistency. + + * subr.el (send-string, send-region): + Remove obsolescence declaration. (window-dot, set-window-dot, read-input, show-buffer) (eval-current-buffer, string-to-int): Add release number to obsolescence declarations. @@ -173,8 +171,8 @@ 2005-05-18 Jay Belanger <belanger@truman.edu> - * calc/calc-help.el (calc-s-prefix-help): - Add `calc-copy-special-constant' to help string. + * calc/calc-help.el (calc-s-prefix-help): Add + `calc-copy-special-constant' to help string. 2005-05-18 Luc Teirlinck <teirllm@auburn.edu> @@ -187,8 +185,8 @@ 2005-05-18 Carsten Dominik <dominik@science.uva.nl> - * textmodes/reftex-vars.el (reftex-cite-format-builtin): - Support for jurabib. + * textmodes/reftex-vars.el (reftex-cite-format-builtin): Support + for jurabib. * textmodes/reftex.el (featurep): Define aliases for overlay commands, for XEmacs compatibility, and use these aliases in @@ -199,8 +197,8 @@ (reftex-access-search-path): Use `reftex-uniquify' instead of `reftex-uniq' - * textmodes/reftex-sel.el (reftex-select-unmark): - Overlay `before-string' property modification enables for Emacs as well. + * textmodes/reftex-sel.el (reftex-select-unmark): Overlay + `before-string' property modification enables for Emacs as well. (reftex-select-item): Use `reftex-delete-overlay'. (reftex-select-mark): Use `reftex-make-overlay' and `reftex-overlay-put'. @@ -235,7 +233,8 @@ * progmodes/prolog.el (inferior-prolog-mode): Doc fix. (prolog-consult-region): Replace `send-string' by - `process-send-string'; replace `send-region' by `process-send-region'. + `process-send-string'; replace `send-region' by + `process-send-region'. * progmodes/delphi.el (delphi-log-msg): Replace `set-window-dot' by `set-window-point'. @@ -266,8 +265,8 @@ loop. It should also be more efficient, because first it only searches for `:', instead of applying the very complex regexp. (makefile-mode): Cancel `font-lock-support-mode', because blocks - to be fontified in one piece can be too long for JIT. - Makefiles are never *that* big. + to be fontified in one piece can be too long for JIT. Makefiles + are never *that* big. 2005-05-17 Reiner Steib <Reiner.Steib@gmx.de> @@ -293,8 +292,8 @@ 2005-05-16 Daniel Pfeiffer <occitan@esperanto.org> - * font-lock.el (lisp-font-lock-keywords-1): - Set `font-lock-negation-char-face' for [^...] char group. + * font-lock.el (lisp-font-lock-keywords-1): Set + `font-lock-negation-char-face' for [^...] char group. (lisp-font-lock-keywords-2): Highlight regexp's \\( \\| \\). * progmodes/make-mode.el (makefile-dependency-regex): Turn it into @@ -308,10 +307,11 @@ might be the same one to be skipped by the initial [^$], leading to an overlooked variable use. (makefile-make-font-lock-keywords): Remove two parameters, which - are now variables that some of the modes set locally. - Handle dependency and rule action matching through functions, because + are now variables that some of the modes set locally. Handle + dependency and rule action matching through functions, because regexps alone match too often. Dependency matching now comes - last, so it can check, whether a colon already matched something else. + last, so it can check, whether a colon already matched something + else. (makefile-mode): Inform that font-lock improves makefile parsing capabilities. (makefile-match-dependency, makefile-match-action): New functions. @@ -396,8 +396,8 @@ (reftex-bib-sort-year-reverse, reftex-format-citation): * textmodes/reftex-parse.el (reftex-init-section-numbers) (reftex-section-number): - * textmodes/texinfmt.el (texinfo-paragraphindent): - Replace `string-to-int' by `string-to-number'. + * textmodes/texinfmt.el (texinfo-paragraphindent): Replace + `string-to-int' by `string-to-number'. * international/latexenc.el: Add page marker to force the "Local Variables:" string out of the last page. @@ -505,22 +505,23 @@ (tramp-pre-connection): Add parameter CHUNKSIZE. Make local variable `tramp-chunksize'. Change callees. (tramp-open-connection-setup-interactive-shell): Check remote host - for buggy `send-process-string' implementation. - Set `tramp-chunksize' if found. Reported by Michael Kifer + for buggy `send-process-string' implementation. Set + `tramp-chunksize' if found. Reported by Michael Kifer <kifer@cs.sunysb.edu> (and a lot of other people all the years). (tramp-handle-shell-command): `insert-buffer' cannot be used because the contents of the Tramp buffer is changed before insertion (`expand-file' and alike). Reported by Fr,Ai(Bd,Ai(Bric Bothamy <frederic.bothamy@free.fr>. (tramp-set-auto-save): Actions should be done for Tramp file name - handler only. Ange-FTP has its own auto-save mechanism. - Reported by Richard G. Bielawski <Richard.G.Bielawski@wellsfargo.com>. + handler only. Ange-FTP has its own auto-save mechanism. Reported + by Richard G. Bielawski <Richard.G.Bielawski@wellsfargo.com>. (tramp-set-auto-save-file-modes): Set file modes of `buffer-auto-save-file-name' to ?\600 as fallback solution. Reported by Ferenc Wagner <wferi@tba.elte.hu>. (tramp-bug): Remove obsolete variable. (tramp-append-tramp-buffers): Rewrite partly. More suitable check - for presence of `mml-mode'. Make it running for older Emacsen as well. + for presence of `mml-mode'. Make it running for older Emacsen as + well. 2005-05-14 John Paul Wallington <jpw@pobox.com> @@ -572,14 +573,15 @@ 2005-05-13 Matt Hodges <MPHodges@member.fsf.org> - * tmm.el (tmm-get-keymap): Include only active menus and menu items. + * tmm.el (tmm-get-keymap): Include only active menus and menu + items. * emacs-lisp/easymenu.el (easy-menu-define): Doc fixes. 2005-05-13 Jan Dj,Ad(Brv <jan.h.d@swipnet.se> * dired.el (dired-mode): make-variable-buffer-local => - make-local-variable. + make-local-variable 2005-05-13 YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp> diff --git a/lisp/emacs-lisp/cl-seq.el b/lisp/emacs-lisp/cl-seq.el index cb202700a00..35403df1d0b 100644 --- a/lisp/emacs-lisp/cl-seq.el +++ b/lisp/emacs-lisp/cl-seq.el @@ -125,8 +125,9 @@ (defun reduce (cl-func cl-seq &rest cl-keys) - "Reduce two-argument FUNCTION across SEQUENCE. -Keywords supported: :start :end :from-end :initial-value :key" + "Reduce two-argument FUNCTION across SEQ. +\nKeywords supported: :start :end :from-end :initial-value :key +\n(fn FUNCTION SEQ [KEYWORD VALUE]...)" (cl-parsing-keywords (:from-end (:start 0) :end :initial-value :key) () (or (listp cl-seq) (setq cl-seq (append cl-seq nil))) (setq cl-seq (subseq cl-seq cl-start cl-end)) @@ -145,7 +146,8 @@ Keywords supported: :start :end :from-end :initial-value :key" (defun fill (seq item &rest cl-keys) "Fill the elements of SEQ with ITEM. -Keywords supported: :start :end" +\nKeywords supported: :start :end +\n(fn SEQ ITEM [KEYWORD VALUE]...)" (cl-parsing-keywords ((:start 0) :end) () (if (listp seq) (let ((p (nthcdr cl-start seq)) @@ -164,7 +166,8 @@ Keywords supported: :start :end" (defun replace (cl-seq1 cl-seq2 &rest cl-keys) "Replace the elements of SEQ1 with the elements of SEQ2. SEQ1 is destructively modified, then returned. -Keywords supported: :start1 :end1 :start2 :end2" +\nKeywords supported: :start1 :end1 :start2 :end2 +\n(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" (cl-parsing-keywords ((:start1 0) :end1 (:start2 0) :end2) () (if (and (eq cl-seq1 cl-seq2) (<= cl-start2 cl-start1)) (or (= cl-start1 cl-start2) @@ -206,7 +209,8 @@ Keywords supported: :start1 :end1 :start2 :end2" "Remove all occurrences of ITEM in SEQ. This is a non-destructive function; it makes a copy of SEQ if necessary to avoid corrupting the original SEQ. -Keywords supported: :test :test-not :key :count :start :end :from-end" +\nKeywords supported: :test :test-not :key :count :start :end :from-end +\n(fn ITEM SEQ [KEYWORD VALUE]...)" (cl-parsing-keywords (:test :test-not :key :if :if-not :count :from-end (:start 0) :end) () (if (<= (or cl-count (setq cl-count 8000000)) 0) @@ -250,20 +254,23 @@ Keywords supported: :test :test-not :key :count :start :end :from-end" "Remove all items satisfying PREDICATE in SEQ. This is a non-destructive function; it makes a copy of SEQ if necessary to avoid corrupting the original SEQ. -Keywords supported: :key :count :start :end :from-end" +\nKeywords supported: :key :count :start :end :from-end +\n(fn PREDICATE SEQ [KEYWORD VALUE]...)" (apply 'remove* nil cl-list :if cl-pred cl-keys)) (defun remove-if-not (cl-pred cl-list &rest cl-keys) "Remove all items not satisfying PREDICATE in SEQ. This is a non-destructive function; it makes a copy of SEQ if necessary to avoid corrupting the original SEQ. -Keywords supported: :key :count :start :end :from-end" +\nKeywords supported: :key :count :start :end :from-end +\n(fn PREDICATE SEQ [KEYWORD VALUE]...)" (apply 'remove* nil cl-list :if-not cl-pred cl-keys)) (defun delete* (cl-item cl-seq &rest cl-keys) "Remove all occurrences of ITEM in SEQ. This is a destructive function; it reuses the storage of SEQ whenever possible. -Keywords supported: :test :test-not :key :count :start :end :from-end" +\nKeywords supported: :test :test-not :key :count :start :end :from-end +\n(fn ITEM SEQ [KEYWORD VALUE]...)" (cl-parsing-keywords (:test :test-not :key :if :if-not :count :from-end (:start 0) :end) () (if (<= (or cl-count (setq cl-count 8000000)) 0) @@ -305,23 +312,27 @@ Keywords supported: :test :test-not :key :count :start :end :from-end" (defun delete-if (cl-pred cl-list &rest cl-keys) "Remove all items satisfying PREDICATE in SEQ. This is a destructive function; it reuses the storage of SEQ whenever possible. -Keywords supported: :key :count :start :end :from-end" +\nKeywords supported: :key :count :start :end :from-end +\n(fn PREDICATE SEQ [KEYWORD VALUE]...)" (apply 'delete* nil cl-list :if cl-pred cl-keys)) (defun delete-if-not (cl-pred cl-list &rest cl-keys) "Remove all items not satisfying PREDICATE in SEQ. This is a destructive function; it reuses the storage of SEQ whenever possible. -Keywords supported: :key :count :start :end :from-end" +\nKeywords supported: :key :count :start :end :from-end +\n(fn PREDICATE SEQ [KEYWORD VALUE]...)" (apply 'delete* nil cl-list :if-not cl-pred cl-keys)) (defun remove-duplicates (cl-seq &rest cl-keys) "Return a copy of SEQ with all duplicate elements removed. -Keywords supported: :test :test-not :key :start :end :from-end" +\nKeywords supported: :test :test-not :key :start :end :from-end +\n(fn SEQ [KEYWORD VALUE]...)" (cl-delete-duplicates cl-seq cl-keys t)) (defun delete-duplicates (cl-seq &rest cl-keys) "Remove all duplicate elements from SEQ (destructively). -Keywords supported: :test :test-not :key :start :end :from-end" +\nKeywords supported: :test :test-not :key :start :end :from-end +\n(fn SEQ [KEYWORD VALUE]...)" (cl-delete-duplicates cl-seq cl-keys nil)) (defun cl-delete-duplicates (cl-seq cl-keys cl-copy) @@ -368,7 +379,8 @@ Keywords supported: :test :test-not :key :start :end :from-end" "Substitute NEW for OLD in SEQ. This is a non-destructive function; it makes a copy of SEQ if necessary to avoid corrupting the original SEQ. -Keywords supported: :test :test-not :key :count :start :end :from-end" +\nKeywords supported: :test :test-not :key :count :start :end :from-end +\n(fn NEW OLD SEQ [KEYWORD VALUE]...)" (cl-parsing-keywords (:test :test-not :key :if :if-not :count (:start 0) :end :from-end) () (if (or (eq cl-old cl-new) @@ -388,20 +400,23 @@ Keywords supported: :test :test-not :key :count :start :end :from-end" "Substitute NEW for all items satisfying PREDICATE in SEQ. This is a non-destructive function; it makes a copy of SEQ if necessary to avoid corrupting the original SEQ. -Keywords supported: :key :count :start :end :from-end" +\nKeywords supported: :key :count :start :end :from-end +\n(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" (apply 'substitute cl-new nil cl-list :if cl-pred cl-keys)) (defun substitute-if-not (cl-new cl-pred cl-list &rest cl-keys) "Substitute NEW for all items not satisfying PREDICATE in SEQ. This is a non-destructive function; it makes a copy of SEQ if necessary to avoid corrupting the original SEQ. -Keywords supported: :key :count :start :end :from-end" +\nKeywords supported: :key :count :start :end :from-end +\n(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" (apply 'substitute cl-new nil cl-list :if-not cl-pred cl-keys)) (defun nsubstitute (cl-new cl-old cl-seq &rest cl-keys) "Substitute NEW for OLD in SEQ. This is a destructive function; it reuses the storage of SEQ whenever possible. -Keywords supported: :test :test-not :key :count :start :end :from-end" +\nKeywords supported: :test :test-not :key :count :start :end :from-end +\n(fn NEW OLD SEQ [KEYWORD VALUE]...)" (cl-parsing-keywords (:test :test-not :key :if :if-not :count (:start 0) :end :from-end) () (or (eq cl-old cl-new) (<= (or cl-count (setq cl-count 8000000)) 0) @@ -433,38 +448,44 @@ Keywords supported: :test :test-not :key :count :start :end :from-end" (defun nsubstitute-if (cl-new cl-pred cl-list &rest cl-keys) "Substitute NEW for all items satisfying PREDICATE in SEQ. This is a destructive function; it reuses the storage of SEQ whenever possible. -Keywords supported: :key :count :start :end :from-end" +\nKeywords supported: :key :count :start :end :from-end +\n(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" (apply 'nsubstitute cl-new nil cl-list :if cl-pred cl-keys)) (defun nsubstitute-if-not (cl-new cl-pred cl-list &rest cl-keys) "Substitute NEW for all items not satisfying PREDICATE in SEQ. This is a destructive function; it reuses the storage of SEQ whenever possible. -Keywords supported: :key :count :start :end :from-end" +\nKeywords supported: :key :count :start :end :from-end +\n(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" (apply 'nsubstitute cl-new nil cl-list :if-not cl-pred cl-keys)) (defun find (cl-item cl-seq &rest cl-keys) - "Find the first occurrence of ITEM in LIST. + "Find the first occurrence of ITEM in SEQ. Return the matching ITEM, or nil if not found. -Keywords supported: :test :test-not :key :start :end :from-end" +\nKeywords supported: :test :test-not :key :start :end :from-end +\n(fn ITEM SEQ [KEYWORD VALUE]...)" (let ((cl-pos (apply 'position cl-item cl-seq cl-keys))) (and cl-pos (elt cl-seq cl-pos)))) (defun find-if (cl-pred cl-list &rest cl-keys) - "Find the first item satisfying PREDICATE in LIST. -Return the matching ITEM, or nil if not found. -Keywords supported: :key :start :end :from-end" + "Find the first item satisfying PREDICATE in SEQ. +Return the matching item, or nil if not found. +\nKeywords supported: :key :start :end :from-end +\n(fn PREDICATE SEQ [KEYWORD VALUE]...)" (apply 'find nil cl-list :if cl-pred cl-keys)) (defun find-if-not (cl-pred cl-list &rest cl-keys) - "Find the first item not satisfying PREDICATE in LIST. -Return the matching ITEM, or nil if not found. -Keywords supported: :key :start :end :from-end" + "Find the first item not satisfying PREDICATE in SEQ. +Return the matching item, or nil if not found. +\nKeywords supported: :key :start :end :from-end +\n(fn PREDICATE SEQ [KEYWORD VALUE]...)" (apply 'find nil cl-list :if-not cl-pred cl-keys)) (defun position (cl-item cl-seq &rest cl-keys) - "Find the first occurrence of ITEM in LIST. + "Find the first occurrence of ITEM in SEQ. Return the index of the matching item, or nil if not found. -Keywords supported: :test :test-not :key :start :end :from-end" +\nKeywords supported: :test :test-not :key :start :end :from-end +\n(fn ITEM SEQ [KEYWORD VALUE]...)" (cl-parsing-keywords (:test :test-not :key :if :if-not (:start 0) :end :from-end) () (cl-position cl-item cl-seq cl-start cl-end cl-from-end))) @@ -491,20 +512,23 @@ Keywords supported: :test :test-not :key :start :end :from-end" (and (< cl-start cl-end) cl-start)))) (defun position-if (cl-pred cl-list &rest cl-keys) - "Find the first item satisfying PREDICATE in LIST. + "Find the first item satisfying PREDICATE in SEQ. Return the index of the matching item, or nil if not found. -Keywords supported: :key :start :end :from-end" +\nKeywords supported: :key :start :end :from-end +\n(fn PREDICATE SEQ [KEYWORD VALUE]...)" (apply 'position nil cl-list :if cl-pred cl-keys)) (defun position-if-not (cl-pred cl-list &rest cl-keys) - "Find the first item not satisfying PREDICATE in LIST. + "Find the first item not satisfying PREDICATE in SEQ. Return the index of the matching item, or nil if not found. -Keywords supported: :key :start :end :from-end" +\nKeywords supported: :key :start :end :from-end +\n(fn PREDICATE SEQ [KEYWORD VALUE]...)" (apply 'position nil cl-list :if-not cl-pred cl-keys)) (defun count (cl-item cl-seq &rest cl-keys) - "Count the number of occurrences of ITEM in LIST. -Keywords supported: :test :test-not :key :start :end" + "Count the number of occurrences of ITEM in SEQ. +\nKeywords supported: :test :test-not :key :start :end +\n(fn ITEM SEQ [KEYWORD VALUE]...)" (cl-parsing-keywords (:test :test-not :key :if :if-not (:start 0) :end) () (let ((cl-count 0) cl-x) (or cl-end (setq cl-end (length cl-seq))) @@ -516,20 +540,23 @@ Keywords supported: :test :test-not :key :start :end" cl-count))) (defun count-if (cl-pred cl-list &rest cl-keys) - "Count the number of items satisfying PREDICATE in LIST. -Keywords supported: :key :start :end" + "Count the number of items satisfying PREDICATE in SEQ. +\nKeywords supported: :key :start :end +\n(fn PREDICATE SEQ [KEYWORD VALUE]...)" (apply 'count nil cl-list :if cl-pred cl-keys)) (defun count-if-not (cl-pred cl-list &rest cl-keys) - "Count the number of items not satisfying PREDICATE in LIST. -Keywords supported: :key :start :end" + "Count the number of items not satisfying PREDICATE in SEQ. +\nKeywords supported: :key :start :end +\n(fn PREDICATE SEQ [KEYWORD VALUE]...)" (apply 'count nil cl-list :if-not cl-pred cl-keys)) (defun mismatch (cl-seq1 cl-seq2 &rest cl-keys) "Compare SEQ1 with SEQ2, return index of first mismatching element. Return nil if the sequences match. If one sequence is a prefix of the other, the return value indicates the end of the shorter sequence. -Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end" +\nKeywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end +\n(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" (cl-parsing-keywords (:test :test-not :key :from-end (:start1 0) :end1 (:start2 0) :end2) () (or cl-end1 (setq cl-end1 (length cl-seq1))) @@ -558,7 +585,8 @@ Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end" "Search for SEQ1 as a subsequence of SEQ2. Return the index of the leftmost element of the first match found; return nil if there are no matches. -Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end" +\nKeywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end +\n(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" (cl-parsing-keywords (:test :test-not :key :from-end (:start1 0) :end1 (:start2 0) :end2) () (or cl-end1 (setq cl-end1 (length cl-seq1))) @@ -580,9 +608,10 @@ Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end" (and (< cl-start2 cl-end2) cl-pos))))) (defun sort* (cl-seq cl-pred &rest cl-keys) - "Sort the argument SEQUENCE according to PREDICATE. -This is a destructive function; it reuses the storage of SEQUENCE if possible. -Keywords supported: :key" + "Sort the argument SEQ according to PREDICATE. +This is a destructive function; it reuses the storage of SEQ if possible. +\nKeywords supported: :key +\n(fn SEQ PREDICATE [KEYWORD VALUE]...)" (if (nlistp cl-seq) (replace cl-seq (apply 'sort* (append cl-seq nil) cl-pred cl-keys)) (cl-parsing-keywords (:key) () @@ -593,16 +622,18 @@ Keywords supported: :key" (funcall cl-key cl-y))))))))) (defun stable-sort (cl-seq cl-pred &rest cl-keys) - "Sort the argument SEQUENCE stably according to PREDICATE. -This is a destructive function; it reuses the storage of SEQUENCE if possible. -Keywords supported: :key" + "Sort the argument SEQ stably according to PREDICATE. +This is a destructive function; it reuses the storage of SEQ if possible. +\nKeywords supported: :key +\n(fn SEQ PREDICATE [KEYWORD VALUE]...)" (apply 'sort* cl-seq cl-pred cl-keys)) (defun merge (cl-type cl-seq1 cl-seq2 cl-pred &rest cl-keys) "Destructively merge the two sequences to produce a new sequence. -TYPE is the sequence type to return, SEQ1 and SEQ2 are the two -argument sequences, and PRED is a `less-than' predicate on the elements. -Keywords supported: :key" +TYPE is the sequence type to return, SEQ1 and SEQ2 are the two argument +sequences, and PREDICATE is a `less-than' predicate on the elements. +\nKeywords supported: :key +\n(fn TYPE SEQ1 SEQ2 PREDICATE [KEYWORD VALUE]...)" (or (listp cl-seq1) (setq cl-seq1 (append cl-seq1 nil))) (or (listp cl-seq2) (setq cl-seq2 (append cl-seq2 nil))) (cl-parsing-keywords (:key) () @@ -618,7 +649,8 @@ Keywords supported: :key" (defun member* (cl-item cl-list &rest cl-keys) "Find the first occurrence of ITEM in LIST. Return the sublist of LIST whose car is ITEM. -Keywords supported: :test :test-not :key" +\nKeywords supported: :test :test-not :key +\n(fn ITEM LIST [KEYWORD VALUE]...)" (if cl-keys (cl-parsing-keywords (:test :test-not :key :if :if-not) () (while (and cl-list (not (cl-check-test cl-item (car cl-list)))) @@ -631,13 +663,15 @@ Keywords supported: :test :test-not :key" (defun member-if (cl-pred cl-list &rest cl-keys) "Find the first item satisfying PREDICATE in LIST. Return the sublist of LIST whose car matches. -Keywords supported: :key" +\nKeywords supported: :key +\n(fn PREDICATE LIST [KEYWORD VALUE]...)" (apply 'member* nil cl-list :if cl-pred cl-keys)) (defun member-if-not (cl-pred cl-list &rest cl-keys) "Find the first item not satisfying PREDICATE in LIST. Return the sublist of LIST whose car matches. -Keywords supported: :key" +\nKeywords supported: :key +\n(fn PREDICATE LIST [KEYWORD VALUE]...)" (apply 'member* nil cl-list :if-not cl-pred cl-keys)) (defun cl-adjoin (cl-item cl-list &rest cl-keys) @@ -649,7 +683,8 @@ Keywords supported: :key" ;;; See compiler macro in cl-macs.el (defun assoc* (cl-item cl-alist &rest cl-keys) "Find the first item whose car matches ITEM in LIST. -Keywords supported: :test :test-not :key" +\nKeywords supported: :test :test-not :key +\n(fn ITEM LIST [KEYWORD VALUE]...)" (if cl-keys (cl-parsing-keywords (:test :test-not :key :if :if-not) () (while (and cl-alist @@ -663,17 +698,20 @@ Keywords supported: :test :test-not :key" (defun assoc-if (cl-pred cl-list &rest cl-keys) "Find the first item whose car satisfies PREDICATE in LIST. -Keywords supported: :key" +\nKeywords supported: :key +\n(fn PREDICATE LIST [KEYWORD VALUE]...)" (apply 'assoc* nil cl-list :if cl-pred cl-keys)) (defun assoc-if-not (cl-pred cl-list &rest cl-keys) "Find the first item whose car does not satisfy PREDICATE in LIST. -Keywords supported: :key" +\nKeywords supported: :key +\n(fn PREDICATE LIST [KEYWORD VALUE]...)" (apply 'assoc* nil cl-list :if-not cl-pred cl-keys)) (defun rassoc* (cl-item cl-alist &rest cl-keys) "Find the first item whose cdr matches ITEM in LIST. -Keywords supported: :test :test-not :key" +\nKeywords supported: :test :test-not :key +\n(fn ITEM LIST [KEYWORD VALUE]...)" (if (or cl-keys (numberp cl-item)) (cl-parsing-keywords (:test :test-not :key :if :if-not) () (while (and cl-alist @@ -685,12 +723,14 @@ Keywords supported: :test :test-not :key" (defun rassoc-if (cl-pred cl-list &rest cl-keys) "Find the first item whose cdr satisfies PREDICATE in LIST. -Keywords supported: :key" +\nKeywords supported: :key +\n(fn PREDICATE LIST [KEYWORD VALUE]...)" (apply 'rassoc* nil cl-list :if cl-pred cl-keys)) (defun rassoc-if-not (cl-pred cl-list &rest cl-keys) "Find the first item whose cdr does not satisfy PREDICATE in LIST. -Keywords supported: :key" +\nKeywords supported: :key +\n(fn PREDICATE LIST [KEYWORD VALUE]...)" (apply 'rassoc* nil cl-list :if-not cl-pred cl-keys)) (defun union (cl-list1 cl-list2 &rest cl-keys) @@ -698,7 +738,8 @@ Keywords supported: :key" The result list contains all items that appear in either LIST1 or LIST2. This is a non-destructive function; it makes a copy of the data if necessary to avoid corrupting the original LIST1 and LIST2. -Keywords supported: :test :test-not :key" +\nKeywords supported: :test :test-not :key +\n(fn LIST1 LIST2 [KEYWORD VALUE]...)" (cond ((null cl-list1) cl-list2) ((null cl-list2) cl-list1) ((equal cl-list1 cl-list2) cl-list1) (t @@ -717,7 +758,8 @@ Keywords supported: :test :test-not :key" The result list contains all items that appear in either LIST1 or LIST2. This is a destructive function; it reuses the storage of LIST1 and LIST2 whenever possible. -Keywords supported: :test :test-not :key" +\nKeywords supported: :test :test-not :key +\n(fn LIST1 LIST2 [KEYWORD VALUE]...)" (cond ((null cl-list1) cl-list2) ((null cl-list2) cl-list1) (t (apply 'union cl-list1 cl-list2 cl-keys)))) @@ -726,7 +768,8 @@ Keywords supported: :test :test-not :key" The result list contains all items that appear in both LIST1 and LIST2. This is a non-destructive function; it makes a copy of the data if necessary to avoid corrupting the original LIST1 and LIST2. -Keywords supported: :test :test-not :key" +\nKeywords supported: :test :test-not :key +\n(fn LIST1 LIST2 [KEYWORD VALUE]...)" (and cl-list1 cl-list2 (if (equal cl-list1 cl-list2) cl-list1 (cl-parsing-keywords (:key) (:test :test-not) @@ -747,7 +790,8 @@ Keywords supported: :test :test-not :key" The result list contains all items that appear in both LIST1 and LIST2. This is a destructive function; it reuses the storage of LIST1 and LIST2 whenever possible. -Keywords supported: :test :test-not :key" +\nKeywords supported: :test :test-not :key +\n(fn LIST1 LIST2 [KEYWORD VALUE]...)" (and cl-list1 cl-list2 (apply 'intersection cl-list1 cl-list2 cl-keys))) (defun set-difference (cl-list1 cl-list2 &rest cl-keys) @@ -755,7 +799,8 @@ Keywords supported: :test :test-not :key" The result list contains all items that appear in LIST1 but not LIST2. This is a non-destructive function; it makes a copy of the data if necessary to avoid corrupting the original LIST1 and LIST2. -Keywords supported: :test :test-not :key" +\nKeywords supported: :test :test-not :key +\n(fn LIST1 LIST2 [KEYWORD VALUE]...)" (if (or (null cl-list1) (null cl-list2)) cl-list1 (cl-parsing-keywords (:key) (:test :test-not) (let ((cl-res nil)) @@ -773,7 +818,8 @@ Keywords supported: :test :test-not :key" The result list contains all items that appear in LIST1 but not LIST2. This is a destructive function; it reuses the storage of LIST1 and LIST2 whenever possible. -Keywords supported: :test :test-not :key" +\nKeywords supported: :test :test-not :key +\n(fn LIST1 LIST2 [KEYWORD VALUE]...)" (if (or (null cl-list1) (null cl-list2)) cl-list1 (apply 'set-difference cl-list1 cl-list2 cl-keys))) @@ -782,7 +828,8 @@ Keywords supported: :test :test-not :key" The result list contains all items that appear in exactly one of LIST1, LIST2. This is a non-destructive function; it makes a copy of the data if necessary to avoid corrupting the original LIST1 and LIST2. -Keywords supported: :test :test-not :key" +\nKeywords supported: :test :test-not :key +\n(fn LIST1 LIST2 [KEYWORD VALUE]...)" (cond ((null cl-list1) cl-list2) ((null cl-list2) cl-list1) ((equal cl-list1 cl-list2) nil) (t (append (apply 'set-difference cl-list1 cl-list2 cl-keys) @@ -793,7 +840,8 @@ Keywords supported: :test :test-not :key" The result list contains all items that appear in exactly one of LIST1, LIST2. This is a destructive function; it reuses the storage of LIST1 and LIST2 whenever possible. -Keywords supported: :test :test-not :key" +\nKeywords supported: :test :test-not :key +\n(fn LIST1 LIST2 [KEYWORD VALUE]...)" (cond ((null cl-list1) cl-list2) ((null cl-list2) cl-list1) ((equal cl-list1 cl-list2) nil) (t (nconc (apply 'nset-difference cl-list1 cl-list2 cl-keys) @@ -802,7 +850,8 @@ Keywords supported: :test :test-not :key" (defun subsetp (cl-list1 cl-list2 &rest cl-keys) "Return true if LIST1 is a subset of LIST2. I.e., if every element of LIST1 also appears in LIST2. -Keywords supported: :test :test-not :key" +\nKeywords supported: :test :test-not :key +\n(fn LIST1 LIST2 [KEYWORD VALUE]...)" (cond ((null cl-list1) t) ((null cl-list2) nil) ((equal cl-list1 cl-list2) t) (t (cl-parsing-keywords (:key) (:test :test-not) @@ -815,38 +864,44 @@ Keywords supported: :test :test-not :key" (defun subst-if (cl-new cl-pred cl-tree &rest cl-keys) "Substitute NEW for elements matching PREDICATE in TREE (non-destructively). Return a copy of TREE with all matching elements replaced by NEW. -Keywords supported: :key" +\nKeywords supported: :key +\n(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" (apply 'sublis (list (cons nil cl-new)) cl-tree :if cl-pred cl-keys)) (defun subst-if-not (cl-new cl-pred cl-tree &rest cl-keys) "Substitute NEW for elts not matching PREDICATE in TREE (non-destructively). Return a copy of TREE with all non-matching elements replaced by NEW. -Keywords supported: :key" +\nKeywords supported: :key +\n(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" (apply 'sublis (list (cons nil cl-new)) cl-tree :if-not cl-pred cl-keys)) (defun nsubst (cl-new cl-old cl-tree &rest cl-keys) "Substitute NEW for OLD everywhere in TREE (destructively). Any element of TREE which is `eql' to OLD is changed to NEW (via a call to `setcar'). -Keywords supported: :test :test-not :key" +\nKeywords supported: :test :test-not :key +\n(fn NEW OLD TREE [KEYWORD VALUE]...)" (apply 'nsublis (list (cons cl-old cl-new)) cl-tree cl-keys)) (defun nsubst-if (cl-new cl-pred cl-tree &rest cl-keys) "Substitute NEW for elements matching PREDICATE in TREE (destructively). Any element of TREE which matches is changed to NEW (via a call to `setcar'). -Keywords supported: :key" +\nKeywords supported: :key +\n(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" (apply 'nsublis (list (cons nil cl-new)) cl-tree :if cl-pred cl-keys)) (defun nsubst-if-not (cl-new cl-pred cl-tree &rest cl-keys) "Substitute NEW for elements not matching PREDICATE in TREE (destructively). Any element of TREE which matches is changed to NEW (via a call to `setcar'). -Keywords supported: :key" +\nKeywords supported: :key +\n(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" (apply 'nsublis (list (cons nil cl-new)) cl-tree :if-not cl-pred cl-keys)) (defun sublis (cl-alist cl-tree &rest cl-keys) "Perform substitutions indicated by ALIST in TREE (non-destructively). Return a copy of TREE with all matching elements replaced. -Keywords supported: :test :test-not :key" +\nKeywords supported: :test :test-not :key +\n(fn ALIST TREE [KEYWORD VALUE]...)" (cl-parsing-keywords (:test :test-not :key :if :if-not) () (cl-sublis-rec cl-tree))) @@ -867,7 +922,8 @@ Keywords supported: :test :test-not :key" (defun nsublis (cl-alist cl-tree &rest cl-keys) "Perform substitutions indicated by ALIST in TREE (destructively). Any matching element of TREE is changed via a call to `setcar'. -Keywords supported: :test :test-not :key" +\nKeywords supported: :test :test-not :key +\n(fn ALIST TREE [KEYWORD VALUE]...)" (cl-parsing-keywords (:test :test-not :key :if :if-not) () (let ((cl-hold (list cl-tree))) (cl-nsublis-rec cl-hold) @@ -888,9 +944,10 @@ Keywords supported: :test :test-not :key" (setq cl-tree (cdr cl-tree)))))) (defun tree-equal (cl-x cl-y &rest cl-keys) - "Return t if trees X and Y have `eql' leaves. + "Return t if trees TREE1 and TREE2 have `eql' leaves. Atoms are compared by `eql'; cons cells are compared recursively. -Keywords supported: :test :test-not :key" +\nKeywords supported: :test :test-not :key +\n(fn TREE1 TREE2 [KEYWORD VALUE]...)" (cl-parsing-keywords (:test :test-not :key) () (cl-tree-equal-rec cl-x cl-y))) |