emacs: lisp/emacs-lisp/cl-seq.el comparison

comparison lisp/emacs-lisp/cl-seq.el @ 90185:5b029ff3b08d

Revision: miles@gnu.org--gnu-2005/emacs--unicode--0--patch-55 Merge from emacs--cvs-trunk--0 Patches applied: * emacs--cvs-trunk--0 (patch 320-323) - Update from CVS

author	Miles Bader <miles@gnu.org>
date	Thu, 26 May 2005 05:42:19 +0000
parents	f042e7c0fe20 e74fa19e333d
children	f9a65d7ebd29

comparison

equal deleted inserted replaced

-:9e5e2f01c7ab
+:5b029ff3b08d
 (defvar cl-if) (defvar cl-if-not)
 (defvar cl-key)
 (defun reduce (cl-func cl-seq &rest cl-keys)
-"Reduce two-argument FUNCTION across SEQUENCE.
+"Reduce two-argument FUNCTION across SEQ.
-Keywords supported:  :start :end :from-end :initial-value :key"
+\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))
 (if cl-from-end (setq cl-seq (nreverse cl-seq)))
 (let ((cl-accum (cond ((memq :initial-value cl-keys) cl-initial-value)
 				  (cl-check-key (pop cl-seq))))))
 cl-accum)))
 (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))
 	      (n (if cl-end (- cl-end cl-start) 8000000)))
 	  (while (and p (>= (setq n (1- n)) 0))
 seq))
 (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)
 	    (let* ((cl-len (length cl-seq1))
 		   (cl-n (min (- (or cl-end1 cl-len) cl-start1)
 (defun remove* (cl-item cl-seq &rest cl-keys)
 "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)
 	cl-seq
 (if (or (nlistp cl-seq) (and cl-from-end (< cl-count 4000000)))
 (defun remove-if (cl-pred cl-list &rest cl-keys)
 "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)
 	cl-seq
 (if (listp cl-seq)
 	(apply 'remove* cl-item cl-seq cl-keys)))))
 (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)
 (if (listp cl-seq)
 (cl-parsing-keywords (:test :test-not :key (:start 0) :end :from-end :if)
 (defun substitute (cl-new cl-old cl-seq &rest cl-keys)
 "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)
 	    (<= (or cl-count (setq cl-from-end nil cl-count 8000000)) 0))
 	cl-seq
 (defun substitute-if (cl-new cl-pred cl-list &rest cl-keys)
 "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)
 	(if (and (listp cl-seq) (or (not cl-from-end) (> cl-count 4000000)))
 	    (let ((cl-p (nthcdr cl-start cl-seq)))
 cl-seq))
 (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.
+"Find the first item satisfying PREDICATE in SEQ.
-Return the matching ITEM, or nil if not found.
+Return 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 '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.
+"Find the first item not satisfying PREDICATE in SEQ.
-Return the matching ITEM, or nil if not found.
+Return 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 '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)))
 (defun cl-position (cl-item cl-seq cl-start &optional cl-end cl-from-end)
 		  (not (cl-check-test cl-item (aref cl-seq cl-start))))
 	(setq cl-start (1+ cl-start)))
 (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.
+"Count the number of occurrences of ITEM in SEQ.
-Keywords supported:  :test :test-not :key :start :end"
+\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)))
 (if (consp cl-seq) (setq cl-seq (nthcdr cl-start cl-seq)))
 (while (< cl-start cl-end)
 	(if (cl-check-test cl-item cl-x) (setq cl-count (1+ cl-count)))
 	(setq cl-start (1+ cl-start)))
 cl-count)))
 (defun count-if (cl-pred cl-list &rest cl-keys)
-"Count the number of items satisfying PREDICATE in LIST.
+"Count the number of items satisfying PREDICATE in SEQ.
-Keywords supported:  :key :start :end"
+\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.
+"Count the number of items not satisfying PREDICATE in SEQ.
-Keywords supported:  :key :start :end"
+\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)))
 (or cl-end2 (setq cl-end2 (length cl-seq2)))
 (if cl-from-end
 (defun search (cl-seq1 cl-seq2 &rest cl-keys)
 "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)))
 (or cl-end2 (setq cl-end2 (length cl-seq2)))
 (if (>= cl-start1 cl-end1)
 			   :from-end nil cl-keys))
 	  (if cl-from-end (setq cl-end2 cl-pos) (setq cl-start2 (1+ cl-pos))))
 	(and (< cl-start2 cl-end2) cl-pos)))))
 (defun sort* (cl-seq cl-pred &rest cl-keys)
-"Sort the argument SEQUENCE according to PREDICATE.
+"Sort the argument SEQ according to PREDICATE.
-This is a destructive function; it reuses the storage of SEQUENCE if possible.
+This is a destructive function; it reuses the storage of SEQ if possible.
-Keywords supported:  :key"
+\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) ()
 (if (memq cl-key '(nil identity))
 	  (sort cl-seq cl-pred)
 	(sort cl-seq (function (lambda (cl-x cl-y)
 				 (funcall cl-pred (funcall cl-key cl-x)
 					  (funcall cl-key cl-y)))))))))
 (defun stable-sort (cl-seq cl-pred &rest cl-keys)
-"Sort the argument SEQUENCE stably according to PREDICATE.
+"Sort the argument SEQ stably according to PREDICATE.
-This is a destructive function; it reuses the storage of SEQUENCE if possible.
+This is a destructive function; it reuses the storage of SEQ if possible.
-Keywords supported:  :key"
+\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
+TYPE is the sequence type to return, SEQ1 and SEQ2 are the two argument
-argument sequences, and PRED is a `less-than' predicate on the elements.
+sequences, and PREDICATE is a `less-than' predicate on the elements.
-Keywords supported:  :key"
+\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) ()
 (let ((cl-res nil))
 (while (and cl-seq1 cl-seq2)
 ;;; See compiler macro in cl-macs.el
 (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))))
 	  (setq cl-list (cdr cl-list)))
 	cl-list)
 (memq cl-item cl-list))))
 (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)
 (if (cl-parsing-keywords (:key) t
 	(apply 'member* (cl-check-key cl-item) cl-list cl-keys))
 (cons cl-item cl-list)))
 ;;; 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
 		    (or (not (consp (car cl-alist)))
 			(not (cl-check-test cl-item (car (car cl-alist))))))
 	(assoc cl-item cl-alist)
 (assq cl-item cl-alist))))
 (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
 		    (or (not (consp (car cl-alist)))
 			(not (cl-check-test cl-item (cdr (car cl-alist))))))
 	(and cl-alist (car cl-alist)))
 (rassq cl-item cl-alist)))
 (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)
 "Combine LIST1 and LIST2 using a set-union operation.
 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
 	 (or (>= (length cl-list1) (length cl-list2))
 	     (setq cl-list1 (prog1 cl-list2 (setq cl-list2 cl-list1))))
 (defun nunion (cl-list1 cl-list2 &rest cl-keys)
 "Combine LIST1 and LIST2 using a set-union operation.
 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))))
 (defun intersection (cl-list1 cl-list2 &rest cl-keys)
 "Combine LIST1 and LIST2 using a set-intersection operation.
 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)
 	   (let ((cl-res nil))
 	     (or (>= (length cl-list1) (length cl-list2))
 (defun nintersection (cl-list1 cl-list2 &rest cl-keys)
 "Combine LIST1 and LIST2 using a set-intersection operation.
 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)
 "Combine LIST1 and LIST2 using a set-difference operation.
 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))
 	(while cl-list1
 	  (or (if (or cl-keys (numberp (car cl-list1)))
 (defun nset-difference (cl-list1 cl-list2 &rest cl-keys)
 "Combine LIST1 and LIST2 using a set-difference operation.
 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)))
 (defun set-exclusive-or (cl-list1 cl-list2 &rest cl-keys)
 "Combine LIST1 and LIST2 using a set-exclusive-or operation.
 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)
 		   (apply 'set-difference cl-list2 cl-list1 cl-keys)))))
 (defun nset-exclusive-or (cl-list1 cl-list2 &rest cl-keys)
 "Combine LIST1 and LIST2 using a set-exclusive-or operation.
 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)
 		  (apply 'nset-difference cl-list2 cl-list1 cl-keys)))))
 (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)
 	     (while (and cl-list1
 			 (apply 'member* (cl-check-key (car cl-list1))
 	     (null cl-list1)))))
 (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)))
 (defvar cl-alist)
 (defun cl-sublis-rec (cl-tree)   ; uses cl-alist/key/test*/if*
 	cl-tree))))
 (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)
 (car cl-hold))))
 (if cl-p
 	  (progn (setcdr cl-tree (cdr (car cl-p))) (setq cl-tree nil))
 	(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)))
 (defun cl-tree-equal-rec (cl-x cl-y)
 (while (and (consp cl-x) (consp cl-y)

Mercurial > emacs

comparison lisp/emacs-lisp/cl-seq.el @ 90185:5b029ff3b08d