Clean up 'cl-' prefixes for local variables

The 'cl-' prefixes used for let-bound variables and argument names is a
holdover from the dynbind days.  They are no longer necessary, and make
the code hard to read.  This was partially cleaned up in the past; let's
finish the job now.

* lisp/emacs-lisp/cl-extra.el (cl--mapcar-many, cl-map, cl-maplist)
(cl-mapc, cl-mapl, cl-mapcan, cl-mapcon, cl-some, cl-every, cl-notany)
(cl-notevery, cl--map-keymap-recursively, cl--map-intervals)
(cl--map-overlays):
* lisp/emacs-lisp/cl-lib.el (cl-mapcar, cl-adjoin, cl-subst)
(cl--do-subst):
* lisp/emacs-lisp/cl-macs.el (cl--parse-loop-clause):
* lisp/emacs-lisp/cl-seq.el (cl-reduce, cl-fill, cl-replace, cl-remove)
(cl-remove-if, cl-remove-if-not, cl-delete, cl-delete-if)
(cl-delete-if-not, cl-remove-duplicates, cl-delete-duplicates)
(cl--delete-duplicates, cl-substitute, cl-substitute-if)
(cl-substitute-if-not, cl-nsubstitute, cl-nsubstitute-if)
(cl-nsubstitute-if-not, cl-find, cl-find-if, cl-find-if-not)
(cl-position, cl--position, cl-position-if, cl-position-if-not)
(cl-count, cl-count-if, cl-count-if-not, cl-mismatch, cl-search)
(cl-sort, cl-stable-sort, cl-merge, cl-member, cl-member-if)
(cl-member-if-not, cl--adjoin, cl-assoc, cl-assoc-if, cl-assoc-if-not)
(cl-rassoc, cl-rassoc-if, cl-rassoc-if-not, cl-union, cl-nunion)
(cl-intersection, cl-nintersection, cl-set-difference)
(cl-nset-difference, cl-set-exclusive-or, cl-nset-exclusive-or)
(cl-subsetp, cl-subst-if, cl-subst-if-not, cl-nsubst, cl-nsubst-if)
(cl-nsubst-if-not, cl-sublis, cl--sublis-rec, cl-nsublis)
(cl--nsublis-rec, cl-tree-equal, cl--tree-equal-rec): Clean up 'cl-'
prefixes for let-bound variables and arguments.

lisp/emacs-lisp/cl-extra.el

@@ -91,120 +91,120 @@ strings case-insensitively."
 ;;; Control structures.
 
 ;;;###autoload
-(defun cl--mapcar-many (cl-func cl-seqs &optional acc)
+(defun cl--mapcar-many (func seqs &optional acc)
-  (if (cdr (cdr cl-seqs))
+  (if (cdr (cdr seqs))
-      (let* ((cl-res nil)
+      (let* ((res nil)
-	     (cl-n (apply #'min (mapcar #'length cl-seqs)))
+             (n (apply #'min (mapcar #'length seqs)))
-	     (cl-i 0)
+             (i 0)
-	     (cl-args (copy-sequence cl-seqs))
+             (args (copy-sequence seqs))
-	     cl-p1 cl-p2)
+             p1 p2)
-	(setq cl-seqs (copy-sequence cl-seqs))
+        (setq seqs (copy-sequence seqs))
-	(while (< cl-i cl-n)
+        (while (< i n)
-	  (setq cl-p1 cl-seqs cl-p2 cl-args)
+          (setq p1 seqs p2 args)
-	  (while cl-p1
+          (while p1
-	    (setcar cl-p2
+            (setcar p2
-		    (if (consp (car cl-p1))
+                    (if (consp (car p1))
-			(prog1 (car (car cl-p1))
+                        (prog1 (car (car p1))
-			  (setcar cl-p1 (cdr (car cl-p1))))
+                          (setcar p1 (cdr (car p1))))
-		      (aref (car cl-p1) cl-i)))
+                      (aref (car p1) i)))
-	    (setq cl-p1 (cdr cl-p1) cl-p2 (cdr cl-p2)))
+            (setq p1 (cdr p1) p2 (cdr p2)))
 	  (if acc
-	      (push (apply cl-func cl-args) cl-res)
+              (push (apply func args) res)
-	    (apply cl-func cl-args))
+            (apply func args))
-	  (setq cl-i (1+ cl-i)))
+          (setq i (1+ i)))
-	(and acc (nreverse cl-res)))
+        (and acc (nreverse res)))
-    (let ((cl-res nil)
+    (let ((res nil)
-	  (cl-x (car cl-seqs))
+          (x (car seqs))
-	  (cl-y (nth 1 cl-seqs)))
+          (y (nth 1 seqs)))
-      (let ((cl-n (min (length cl-x) (length cl-y)))
+      (let ((n (min (length x) (length y)))
-	    (cl-i -1))
+            (i -1))
-	(while (< (setq cl-i (1+ cl-i)) cl-n)
+        (while (< (setq i (1+ i)) n)
-	  (let ((val (funcall cl-func
+          (let ((val (funcall func
-			      (if (consp cl-x) (pop cl-x) (aref cl-x cl-i))
+                              (if (consp x) (pop x) (aref x i))
-			      (if (consp cl-y) (pop cl-y) (aref cl-y cl-i)))))
+                              (if (consp y) (pop y) (aref y i)))))
 	    (when acc
-	      (push val cl-res)))))
+              (push val res)))))
-      (and acc (nreverse cl-res)))))
+      (and acc (nreverse res)))))
 
 ;;;###autoload
-(defsubst cl-map (cl-type cl-func cl-seq &rest cl-rest)
+(defsubst cl-map (type func seq &rest rest)
   "Map a FUNCTION across one or more SEQUENCEs, returning a sequence.
 TYPE is the sequence type to return.
 \n(fn TYPE FUNCTION SEQUENCE...)"
   (declare (important-return-value t))
-  (let ((cl-res (apply 'cl-mapcar cl-func cl-seq cl-rest)))
+  (let ((res (apply 'cl-mapcar func seq rest)))
-    (and cl-type (cl-coerce cl-res cl-type))))
+    (and type (cl-coerce res type))))
 
 ;;;###autoload
-(defun cl-maplist (cl-func cl-list &rest cl-rest)
+(defun cl-maplist (func list &rest rest)
   "Map FUNCTION to each sublist of LIST or LISTs.
 Like `cl-mapcar', except applies to lists and their cdr's rather than to
 the elements themselves.
 \n(fn FUNCTION LIST...)"
   (declare (important-return-value t))
-  (if cl-rest
+  (if rest
-      (let ((cl-res nil)
+      (let ((res nil)
-	    (cl-args (cons cl-list (copy-sequence cl-rest)))
+            (args (cons list (copy-sequence rest)))
-	    cl-p)
+            p)
-	(while (not (memq nil cl-args))
+        (while (not (memq nil args))
-	  (push (apply cl-func cl-args) cl-res)
+          (push (apply func args) res)
-	  (setq cl-p cl-args)
+          (setq p args)
-	  (while cl-p (setcar cl-p (cdr (pop cl-p)))))
+          (while p (setcar p (cdr (pop p)))))
-	(nreverse cl-res))
+        (nreverse res))
-    (let ((cl-res nil))
+    (let ((res nil))
-      (while cl-list
+      (while list
-	(push (funcall cl-func cl-list) cl-res)
+        (push (funcall func list) res)
-	(setq cl-list (cdr cl-list)))
+        (setq list (cdr list)))
-      (nreverse cl-res))))
+      (nreverse res))))
 
 ;;;###autoload
-(defun cl-mapc (cl-func cl-seq &rest cl-rest)
+(defun cl-mapc (func seq &rest rest)
   "Like `cl-mapcar', but does not accumulate values returned by the function.
 \n(fn FUNCTION SEQUENCE...)"
-  (if cl-rest
+  (if rest
-      (if (or (cdr cl-rest) (nlistp cl-seq) (nlistp (car cl-rest)))
+      (if (or (cdr rest) (nlistp seq) (nlistp (car rest)))
           (progn
-            (cl--mapcar-many cl-func (cons cl-seq cl-rest))
+            (cl--mapcar-many func (cons seq rest))
-            cl-seq)
+            seq)
-        (let ((cl-x cl-seq) (cl-y (car cl-rest)))
+        (let ((x seq) (y (car rest)))
-          (while (and cl-x cl-y)
+          (while (and x y)
-            (funcall cl-func (pop cl-x) (pop cl-y)))
+            (funcall func (pop x) (pop y)))
-          cl-seq))
+          seq))
-    (mapc cl-func cl-seq)))
+    (mapc func seq)))
 
 ;;;###autoload
-(defun cl-mapl (cl-func cl-list &rest cl-rest)
+(defun cl-mapl (func list &rest rest)
   "Like `cl-maplist', but does not accumulate values returned by the function.
 \n(fn FUNCTION LIST...)"
-  (if cl-rest
+  (if rest
-      (let ((cl-args (cons cl-list (copy-sequence cl-rest)))
+      (let ((args (cons list (copy-sequence rest)))
-	    cl-p)
+            p)
-	(while (not (memq nil cl-args))
+        (while (not (memq nil args))
-          (apply cl-func cl-args)
+          (apply func args)
-	  (setq cl-p cl-args)
+          (setq p args)
-	  (while cl-p (setcar cl-p (cdr (pop cl-p))))))
+          (while p (setcar p (cdr (pop p))))))
-    (let ((cl-p cl-list))
+    (let ((p list))
-      (while cl-p (funcall cl-func cl-p) (setq cl-p (cdr cl-p)))))
+      (while p (funcall func p) (setq p (cdr p)))))
-  cl-list)
+  list)
 
 ;;;###autoload
-(defun cl-mapcan (cl-func cl-seq &rest cl-rest)
+(defun cl-mapcan (func seq &rest rest)
   "Like `cl-mapcar', but nconc's together the values returned by the function.
 \n(fn FUNCTION SEQUENCE...)"
   (declare (important-return-value t))
-  (if cl-rest
+  (if rest
-      (apply #'nconc (apply #'cl-mapcar cl-func cl-seq cl-rest))
+      (apply #'nconc (apply #'cl-mapcar func seq rest))
-    (mapcan cl-func cl-seq)))
+    (mapcan func seq)))
 
 ;;;###autoload
-(defun cl-mapcon (cl-func cl-list &rest cl-rest)
+(defun cl-mapcon (func list &rest rest)
   "Like `cl-maplist', but nconc's together the values returned by the function.
 \n(fn FUNCTION LIST...)"
   (declare (important-return-value t))
-  (apply #'nconc (apply #'cl-maplist cl-func cl-list cl-rest)))
+  (apply #'nconc (apply #'cl-maplist func list rest)))
 
 ;;;###autoload
-(defun cl-some (cl-pred cl-seq &rest cl-rest)
+(defun cl-some (pred seq &rest rest)
   "Say whether PREDICATE is true for any element in the SEQ sequences.
 More specifically, the return value of this function will be the
 same as the first return value of PREDICATE where PREDICATE has a
@@ -212,105 +212,105 @@ non-nil value.
 
 \n(fn PREDICATE SEQ...)"
   (declare (important-return-value t))
-  (if (or cl-rest (nlistp cl-seq))
+  (if (or rest (nlistp seq))
       (catch 'cl-some
         (apply #'cl-map nil
-               (lambda (&rest cl-x)
+               (lambda (&rest x)
-                 (let ((cl-res (apply cl-pred cl-x)))
+                 (let ((res (apply pred x)))
-                   (if cl-res (throw 'cl-some cl-res))))
+                   (if res (throw 'cl-some res))))
-	       cl-seq cl-rest) nil)
+               seq rest) nil)
-    (let ((cl-x nil))
+    (let ((x nil))
-      (while (and cl-seq (not (setq cl-x (funcall cl-pred (pop cl-seq))))))
+      (while (and seq (not (setq x (funcall pred (pop seq))))))
-      cl-x)))
+      x)))
 
 ;;;###autoload
-(defun cl-every (cl-pred cl-seq &rest cl-rest)
+(defun cl-every (pred seq &rest rest)
   "Return true if PREDICATE is true of every element of SEQ or SEQs.
 \n(fn PREDICATE SEQ...)"
   (declare (important-return-value t))
-  (if (or cl-rest (nlistp cl-seq))
+  (if (or rest (nlistp seq))
       (catch 'cl-every
         (apply #'cl-map nil
-               (lambda (&rest cl-x)
+               (lambda (&rest x)
-                 (or (apply cl-pred cl-x) (throw 'cl-every nil)))
+                 (or (apply pred x) (throw 'cl-every nil)))
-	       cl-seq cl-rest) t)
+               seq rest) t)
-    (while (and cl-seq (funcall cl-pred (car cl-seq)))
+    (while (and seq (funcall pred (car seq)))
-      (setq cl-seq (cdr cl-seq)))
+      (setq seq (cdr seq)))
-    (null cl-seq)))
+    (null seq)))
 
 ;;;###autoload
-(defsubst cl-notany (cl-pred cl-seq &rest cl-rest)
+(defsubst cl-notany (pred seq &rest rest)
   "Return true if PREDICATE is false of every element of SEQ or SEQs.
 \n(fn PREDICATE SEQ...)"
   (declare (important-return-value t))
-  (not (apply #'cl-some cl-pred cl-seq cl-rest)))
+  (not (apply #'cl-some pred seq rest)))
 
 ;;;###autoload
-(defsubst cl-notevery (cl-pred cl-seq &rest cl-rest)
+(defsubst cl-notevery (pred seq &rest rest)
   "Return true if PREDICATE is false of some element of SEQ or SEQs.
 \n(fn PREDICATE SEQ...)"
   (declare (important-return-value t))
-  (not (apply #'cl-every cl-pred cl-seq cl-rest)))
+  (not (apply #'cl-every pred seq rest)))
 
 ;;;###autoload
-(defun cl--map-keymap-recursively (cl-func-rec cl-map &optional cl-base)
+(defun cl--map-keymap-recursively (func-rec map &optional base)
-  (or cl-base
+  (or base
-      (setq cl-base (copy-sequence [0])))
+      (setq base (copy-sequence [0])))
   (map-keymap
-   (lambda (cl-key cl-bind)
+   (lambda (key bind)
-     (aset cl-base (1- (length cl-base)) cl-key)
+     (aset base (1- (length base)) key)
-     (if (keymapp cl-bind)
+     (if (keymapp bind)
          (cl--map-keymap-recursively
-          cl-func-rec cl-bind
+          func-rec bind
-          (vconcat cl-base (list 0)))
+          (vconcat base (list 0)))
-       (funcall cl-func-rec cl-base cl-bind)))
+       (funcall func-rec base bind)))
-   cl-map))
+   map))
 
 ;;;###autoload
-(defun cl--map-intervals (cl-func &optional cl-what cl-prop cl-start cl-end)
+(defun cl--map-intervals (func &optional what prop start end)
-  (or cl-what (setq cl-what (current-buffer)))
+  (or what (setq what (current-buffer)))
-  (if (bufferp cl-what)
+  (if (bufferp what)
-      (let (cl-mark cl-mark2 (cl-next t) cl-next2)
+      (let (mark mark2 (next t) next2)
-	(with-current-buffer cl-what
+        (with-current-buffer what
-	  (setq cl-mark (copy-marker (or cl-start (point-min))))
+          (setq mark (copy-marker (or start (point-min))))
-	  (setq cl-mark2 (and cl-end (copy-marker cl-end))))
+          (setq mark2 (and end (copy-marker end))))
-	(while (and cl-next (or (not cl-mark2) (< cl-mark cl-mark2)))
+        (while (and next (or (not mark2) (< mark mark2)))
-	  (setq cl-next (if cl-prop (next-single-property-change
+          (setq next (if prop (next-single-property-change
-				     cl-mark cl-prop cl-what)
+                               mark prop what)
-			  (next-property-change cl-mark cl-what))
+                       (next-property-change mark what))
-		cl-next2 (or cl-next (with-current-buffer cl-what
+                next2 (or next (with-current-buffer what
-				       (point-max))))
+                                 (point-max))))
-	  (funcall cl-func (prog1 (marker-position cl-mark)
+          (funcall func (prog1 (marker-position mark)
-			     (set-marker cl-mark cl-next2))
+                          (set-marker mark next2))
-		   (if cl-mark2 (min cl-next2 cl-mark2) cl-next2)))
+                   (if mark2 (min next2 mark2) next2)))
-	(set-marker cl-mark nil) (if cl-mark2 (set-marker cl-mark2 nil)))
+        (set-marker mark nil) (if mark2 (set-marker mark2 nil)))
-    (or cl-start (setq cl-start 0))
+    (or start (setq start 0))
-    (or cl-end (setq cl-end (length cl-what)))
+    (or end (setq end (length what)))
-    (while (< cl-start cl-end)
+    (while (< start end)
-      (let ((cl-next (or (if cl-prop (next-single-property-change
+      (let ((next (or (if prop (next-single-property-change
-				      cl-start cl-prop cl-what)
+                                start prop what)
-			   (next-property-change cl-start cl-what))
+                        (next-property-change start what))
-			 cl-end)))
+                      end)))
-	(funcall cl-func cl-start (min cl-next cl-end))
+        (funcall func start (min next end))
-	(setq cl-start cl-next)))))
+        (setq start next)))))
 
 ;;;###autoload
-(defun cl--map-overlays (cl-func &optional cl-buffer cl-start cl-end cl-arg)
+(defun cl--map-overlays (func &optional buffer start end arg)
-  (or cl-buffer (setq cl-buffer (current-buffer)))
+  (or buffer (setq buffer (current-buffer)))
-  (let (cl-ovl)
+  (let (ovl)
-    (with-current-buffer cl-buffer
+    (with-current-buffer buffer
-      (setq cl-ovl (overlay-lists))
+      (setq ovl (overlay-lists))
-      (if cl-start (setq cl-start (copy-marker cl-start)))
+      (if start (setq start (copy-marker start)))
-      (if cl-end (setq cl-end (copy-marker cl-end))))
+      (if end (setq end (copy-marker end))))
-    (setq cl-ovl (nconc (car cl-ovl) (cdr cl-ovl)))
+    (setq ovl (nconc (car ovl) (cdr ovl)))
-    (while (and cl-ovl
+    (while (and ovl
-		(or (not (overlay-start (car cl-ovl)))
+                (or (not (overlay-start (car ovl)))
-		    (and cl-end (>= (overlay-start (car cl-ovl)) cl-end))
+                    (and end (>= (overlay-start (car ovl)) end))
-		    (and cl-start (<= (overlay-end (car cl-ovl)) cl-start))
+                    (and start (<= (overlay-end (car ovl)) start))
-		    (not (funcall cl-func (car cl-ovl) cl-arg))))
+                    (not (funcall func (car ovl) arg))))
-      (setq cl-ovl (cdr cl-ovl)))
+      (setq ovl (cdr ovl)))
-    (if cl-start (set-marker cl-start nil))
+    (if start (set-marker start nil))
-    (if cl-end (set-marker cl-end nil))))
+    (if end (set-marker end nil))))
 
 ;;; Support for `setf'.
 ;;;###autoload

lisp/emacs-lisp/cl-lib.el

@@ -362,7 +362,7 @@ Call `cl-float-limits' to set this.")
 
 (declare-function cl--mapcar-many "cl-extra" (cl-func cl-seqs &optional acc))
 
-(defun cl-mapcar (cl-func cl-x &rest cl-rest)
+(defun cl-mapcar (func x &rest rest)
   "Apply FUNCTION to each element of SEQ, and make a list of the results.
 If there are several SEQs, FUNCTION is called with that many arguments,
 and mapping stops as soon as the shortest list runs out.  With just one
@@ -370,14 +370,14 @@ SEQ, this is like `mapcar'.  With several, it is like the Common Lisp
 `mapcar' function extended to arbitrary sequence types.
 \n(fn FUNCTION SEQ...)"
   (declare (important-return-value t))
-  (if cl-rest
+  (if rest
-      (if (or (cdr cl-rest) (nlistp cl-x) (nlistp (car cl-rest)))
+      (if (or (cdr rest) (nlistp x) (nlistp (car rest)))
-	  (cl--mapcar-many cl-func (cons cl-x cl-rest) 'accumulate)
+          (cl--mapcar-many func (cons x rest) 'accumulate)
-	(let ((cl-res nil) (cl-y (car cl-rest)))
+        (let ((res nil) (y (car rest)))
-	  (while (and cl-x cl-y)
+          (while (and x y)
-	    (push (funcall cl-func (pop cl-x) (pop cl-y)) cl-res))
+            (push (funcall func (pop x) (pop y)) res))
-	  (nreverse cl-res)))
+          (nreverse res)))
-    (mapcar cl-func cl-x)))
+    (mapcar func x)))
 
 (cl--defalias 'cl-svref #'aref)
 
@@ -502,38 +502,38 @@ The elements of LIST are not copied, just the list structure itself."
 (declare-function cl-round "cl-extra" (x &optional y))
 (declare-function cl-mod "cl-extra" (x y))
 
-(defun cl-adjoin (cl-item cl-list &rest cl-keys)
+(defun cl-adjoin (item list &rest keys)
   "Return ITEM consed onto the front of LIST only if it's not already there.
 Otherwise, return LIST unmodified.
 \nKeywords supported:  :test :test-not :key
 \n(fn ITEM LIST [KEYWORD VALUE]...)"
   (declare (important-return-value t)
            (compiler-macro cl--compiler-macro-adjoin))
-  (cond ((or (equal cl-keys '(:test eq))
+  (cond ((or (equal keys '(:test eq))
-	     (and (null cl-keys) (not (numberp cl-item))))
+             (and (null keys) (not (numberp item))))
-	 (if (memq cl-item cl-list) cl-list (cons cl-item cl-list)))
+         (if (memq item list) list (cons item list)))
-	((or (equal cl-keys '(:test equal)) (null cl-keys))
+        ((or (equal keys '(:test equal)) (null keys))
-	 (if (member cl-item cl-list) cl-list (cons cl-item cl-list)))
+         (if (member item list) list (cons item list)))
-	(t (apply 'cl--adjoin cl-item cl-list cl-keys))))
+        (t (apply 'cl--adjoin item list keys))))
 
-(defun cl-subst (cl-new cl-old cl-tree &rest cl-keys)
+(defun cl-subst (new old tree &rest keys)
   "Substitute NEW for OLD everywhere in TREE (non-destructively).
 Return a copy of TREE with all elements `eql' to OLD replaced by NEW.
 \nKeywords supported:  :test :test-not :key
 \n(fn NEW OLD TREE [KEYWORD VALUE]...)"
   (declare (important-return-value t))
-  (if (or cl-keys (and (numberp cl-old) (not (integerp cl-old))))
+  (if (or keys (and (numberp old) (not (integerp old))))
-      (apply 'cl-sublis (list (cons cl-old cl-new)) cl-tree cl-keys)
+      (apply 'cl-sublis (list (cons old new)) tree keys)
-    (cl--do-subst cl-new cl-old cl-tree)))
+    (cl--do-subst new old tree)))
 
-(defun cl--do-subst (cl-new cl-old cl-tree)
+(defun cl--do-subst (new old tree)
-  (cond ((eq cl-tree cl-old) cl-new)
+  (cond ((eq tree old) new)
-	((consp cl-tree)
+        ((consp tree)
-	 (let ((a (cl--do-subst cl-new cl-old (car cl-tree)))
+         (let ((a (cl--do-subst new old (car tree)))
-	       (d (cl--do-subst cl-new cl-old (cdr cl-tree))))
+               (d (cl--do-subst new old (cdr tree))))
-	   (if (and (eq a (car cl-tree)) (eq d (cdr cl-tree)))
+           (if (and (eq a (car tree)) (eq d (cdr tree)))
-	       cl-tree (cons a d))))
+               tree (cons a d))))
-	(t cl-tree)))
+        (t tree)))
 
 (defsubst cl-acons (key value alist)
   "Add KEY and VALUE to ALIST.

lisp/emacs-lisp/cl-macs.el

@@ -1481,7 +1481,7 @@ For more details, see Info node `(cl)Loop Facility'.
 	       ((memq word key-types)
 		(or (memq (car cl--loop-args) '(in of))
                     (error "Expected `of'"))
-		(let ((cl-map (cl--pop2 cl--loop-args))
+                (let ((map (cl--pop2 cl--loop-args))
 		      (other
                        (if (eq (car cl--loop-args) 'using)
                            (if (and (= (length (cadr cl--loop-args)) 2)
@@ -1496,7 +1496,7 @@ For more details, see Info node `(cl)Loop Facility'.
                    'keys (lambda (body)
                            `(,(if (memq word '(key-seq key-seqs))
                                   'cl--map-keymap-recursively 'map-keymap)
-                             (lambda (,var ,other) . ,body) ,cl-map)))))
+                             (lambda (,var ,other) . ,body) ,map)))))
 
 	       ((memq word '(frame frames screen screens))
 		(let ((temp (make-symbol "--cl-var--")))