Don't quote lambdas in several places

* lisp/align.el (align-highlight-rule):
* lisp/bookmark.el (bookmark-maybe-sort-alist):
* lisp/emacs-lisp/advice.el (ad-read-advice-name)
(ad-retrieve-args-form, ad-make-hook-form, defadvice)
(ad-with-originals):
* lisp/foldout.el (foldout-inhibit-key-bindings):
* lisp/gnus/gnus-bookmark.el (gnus-bookmark-maybe-sort-alist):
* lisp/mail/rfc822.el (rfc822-addresses-1):
* lisp/net/eudcb-ldap.el (eudc-ldap-cleanup-record-simple):
* lisp/net/net-utils.el (network-connection-to-service):
* lisp/net/socks.el (socks-build-auth-list):
* lisp/org/ox-odt.el (org-odt--image-size):
* lisp/pcomplete.el (pcomplete-command-completion-function)
(pcomplete-default-completion-function, pcomplete-opt):
* lisp/progmodes/cperl-mode.el (cperl-highlight-charclass)
(cperl-tags-hier-init, cperl-tags-treeify)
(cperl-next-interpolated-REx, cperl-time-fontification):
* lisp/shadowfile.el (shadow-copy-files, shadow-shadows-of-1)
(shadow-save-buffers-kill-emacs):
* lisp/strokes.el (strokes-renormalize-to-grid):
* lisp/tempo.el (tempo-insert, tempo-forward-mark)
(tempo-backward-mark):
* lisp/textmodes/artist.el (artist-submit-bug-report):
* lisp/textmodes/ispell.el (ispell-complete-word):
* lisp/url/url-auth.el (url-get-authentication):
* lisp/url/url-cache.el (url-cache-create-filename-human-readable):
* lisp/vcursor.el (vcursor-find-window):
* test/lisp/textmodes/reftex-tests.el
(reftex-parse-bibtex-entry-test): Don't quote lambdas.

21 files changed, 153 insertions, 181 deletions

diff --git a/lisp/align.el b/lisp/align.el
index e3bdf77002e..b2cab1c1b27 100644
--- a/lisp/align.el
+++ b/lisp/align.el
@@ -1004,9 +1004,8 @@ to be colored."
 	 (completing-read
 	  "Title of rule to highlight: "
 	  (mapcar
-	   (function
-	    (lambda (rule)
-	      (list (symbol-name (car rule)))))
+           (lambda (rule)
+             (list (symbol-name (car rule))))
 	   (append (or align-mode-rules-list align-rules-list)
 		   (or align-mode-exclude-rules-list
 		       align-exclude-rules-list))) nil t)))
diff --git a/lisp/bookmark.el b/lisp/bookmark.el
index ab7b04ddfee..d703458aa11 100644
--- a/lisp/bookmark.el
+++ b/lisp/bookmark.el
@@ -1065,8 +1065,7 @@ it to the name of the bookmark currently being set, advancing
 If `bookmark-sort-flag' is non-nil, then return a sorted copy of the alist."
   (if bookmark-sort-flag
       (sort (copy-alist bookmark-alist)
-            (function
-             (lambda (x y) (string-lessp (car x) (car y)))))
+            (lambda (x y) (string-lessp (car x) (car y))))
     bookmark-alist))
 
 
diff --git a/lisp/emacs-lisp/advice.el b/lisp/emacs-lisp/advice.el
index 0ebd2741d2e..5cda399b5ef 100644
--- a/lisp/emacs-lisp/advice.el
+++ b/lisp/emacs-lisp/advice.el
@@ -1894,8 +1894,8 @@ class of FUNCTION)."
   "Read name of existing advice of CLASS for FUNCTION with completion.
 An optional PROMPT is used to prompt for the name."
   (let* ((name-completion-table
-          (mapcar (function (lambda (advice)
-			      (list (symbol-name (ad-advice-name advice)))))
+          (mapcar (lambda (advice)
+                    (list (symbol-name (ad-advice-name advice))))
 		  (ad-get-advice-info-field function class)))
 	 (default
 	   (if (null name-completion-table)
@@ -2255,13 +2255,11 @@ element is its actual current value, and the third element is either
   (let* ((parsed-arglist (ad-parse-arglist arglist))
 	 (rest (nth 2 parsed-arglist)))
     `(list
-      ,@(mapcar (function
-                 (lambda (req)
-                  `(list ',req ,req 'required)))
+      ,@(mapcar (lambda (req)
+                  `(list ',req ,req 'required))
                 (nth 0 parsed-arglist))
-      ,@(mapcar (function
-                 (lambda (opt)
-                  `(list ',opt ,opt 'optional)))
+      ,@(mapcar (lambda (opt)
+                  `(list ',opt ,opt 'optional))
                 (nth 1 parsed-arglist))
       ,@(if rest (list `(list ',rest ,rest 'rest))))))
 
@@ -2623,8 +2621,8 @@ should be modified.  The assembled function will be returned."
 (defun ad-make-hook-form (function hook-name)
   "Make hook-form from FUNCTION's advice bodies in class HOOK-NAME."
   (let ((hook-forms
-	 (mapcar (function (lambda (advice)
-			     (ad-body-forms (ad-advice-definition advice))))
+         (mapcar (lambda (advice)
+                   (ad-body-forms (ad-advice-definition advice)))
 		 (ad-get-enabled-advices function hook-name))))
     (if hook-forms
 	(macroexp-progn (apply 'append hook-forms)))))
@@ -3167,15 +3165,14 @@ usage: (defadvice FUNCTION (CLASS NAME [POSITION] [ARGLIST] FLAG...)
 			(setq args (cdr args)))))
 	 (flags
 	  (mapcar
-	   (function
-	    (lambda (flag)
+           (lambda (flag)
              (let ((completion
                     (try-completion (symbol-name flag) ad-defadvice-flags)))
                (cond ((eq completion t) flag)
                      ((member completion ad-defadvice-flags)
                       (intern completion))
                      (t (error "defadvice: Invalid or ambiguous flag: %s"
-                               flag))))))
+                               flag)))))
 	   args))
 	 (advice (ad-make-advice
 		  name (memq 'protect flags)
@@ -3217,11 +3214,10 @@ undone on exit of this macro."
   (let* ((index -1)
 	 ;; Make let-variables to store current definitions:
 	 (current-bindings
-	  (mapcar (function
-		   (lambda (function)
+          (mapcar (lambda (function)
                     (setq index (1+ index))
                     (list (intern (format "ad-oRiGdEf-%d" index))
-                          `(symbol-function ',function))))
+                          `(symbol-function ',function)))
 		  functions)))
     `(let ,current-bindings
       (unwind-protect
diff --git a/lisp/foldout.el b/lisp/foldout.el
index 0d7a7a88a6f..58455c28b16 100644
--- a/lisp/foldout.el
+++ b/lisp/foldout.el
@@ -527,19 +527,18 @@ Valid modifiers are shift, control, meta, alt, hyper and super.")
     (define-key map "\C-z" 'foldout-zoom-subtree)
     (define-key map "\C-x" 'foldout-exit-fold))
   (let* ((modifiers (apply 'concat
-			   (mapcar (function
-				    (lambda (modifier)
-				      (vector
-				       (cond
-					 ((eq modifier 'shift) ?S)
-					 ((eq modifier 'control) ?C)
-					 ((eq modifier 'meta) ?M)
-					 ((eq modifier 'alt) ?A)
-					 ((eq modifier 'hyper) ?H)
-					 ((eq modifier 'super) ?s)
-					 (t (error "invalid mouse modifier %s"
-						   modifier)))
-				       ?-)))
+                           (mapcar (lambda (modifier)
+                                     (vector
+                                      (cond
+                                       ((eq modifier 'shift) ?S)
+                                       ((eq modifier 'control) ?C)
+                                       ((eq modifier 'meta) ?M)
+                                       ((eq modifier 'alt) ?A)
+                                       ((eq modifier 'hyper) ?H)
+                                       ((eq modifier 'super) ?s)
+                                       (t (error "invalid mouse modifier %s"
+                                                 modifier)))
+                                      ?-))
 				   foldout-mouse-modifiers)))
 	 (mouse-1 (vector (intern (concat modifiers "down-mouse-1"))))
 	 (mouse-2 (vector (intern (concat modifiers "down-mouse-2"))))
diff --git a/lisp/gnus/gnus-bookmark.el b/lisp/gnus/gnus-bookmark.el
index 1b00bbbc69c..4f85349d166 100644
--- a/lisp/gnus/gnus-bookmark.el
+++ b/lisp/gnus/gnus-bookmark.el
@@ -345,8 +345,7 @@ copy of the alist."
   (when gnus-bookmark-sort-flag
     (setq gnus-bookmark-alist
 	  (sort (copy-alist gnus-bookmark-alist)
-		(function
-		 (lambda (x y) (string-lessp (car x) (car y))))))))
+                (lambda (x y) (string-lessp (car x) (car y)))))))
 
 ;;;###autoload
 (defun gnus-bookmark-bmenu-list ()
diff --git a/lisp/mail/rfc822.el b/lisp/mail/rfc822.el
index f2fe1cd8166..4572f27faf8 100644
--- a/lisp/mail/rfc822.el
+++ b/lisp/mail/rfc822.el
@@ -226,11 +226,11 @@
 		       ((and (not (eobp)) (= (following-char) ?\@))
 			;; <@foo.bar,@baz:quux@abcd.efg>
 			(rfc822-snarf-frob-list "<...> address" ?\, ?\:
-			  (function (lambda ()
-				      (if (rfc822-looking-at ?\@)
-					  (rfc822-snarf-domain)
-					(rfc822-bad-address
-					  "Gubbish in route-addr")))))
+                          (lambda ()
+                            (if (rfc822-looking-at ?\@)
+                                (rfc822-snarf-domain)
+                              (rfc822-bad-address
+                               "Gubbish in route-addr"))))
 			(rfc822-snarf-words)
 			(or (rfc822-looking-at ?@)
 			    (rfc822-bad-address "Malformed <..@..> address"))
diff --git a/lisp/net/eudcb-ldap.el b/lisp/net/eudcb-ldap.el
index 1764f03e213..14cc7db2fa8 100644
--- a/lisp/net/eudcb-ldap.el
+++ b/lisp/net/eudcb-ldap.el
@@ -76,12 +76,11 @@
   "Do some cleanup in a RECORD to make it suitable for EUDC."
   (declare (obsolete eudc-ldap-cleanup-record-filtering-addresses "25.1"))
   (mapcar
-   (function
-    (lambda (field)
-      (cons (intern (downcase (car field)))
-	    (if (cdr (cdr field))
-		(cdr field)
-	      (car (cdr field))))))
+   (lambda (field)
+     (cons (intern (downcase (car field)))
+           (if (cdr (cdr field))
+               (cdr field)
+             (car (cdr field)))))
    record))
 
 (defun eudc-filter-$ (string)
diff --git a/lisp/net/net-utils.el b/lisp/net/net-utils.el
index 8c7d33a67d4..8777fe4bf46 100644
--- a/lisp/net/net-utils.el
+++ b/lisp/net/net-utils.el
@@ -985,9 +985,8 @@ This command uses `network-connection-service-alist', which see."
     (read-from-minibuffer "Host: " (net-utils-machine-at-point))
     (completing-read "Service: "
 		     (mapcar
-		      (function
-		       (lambda (elt)
-			 (list (symbol-name (car elt)))))
+                      (lambda (elt)
+                        (list (symbol-name (car elt))))
 		      network-connection-service-alist))))
   (network-connection
    host
diff --git a/lisp/net/socks.el b/lisp/net/socks.el
index 84fc5dccace..9b22a5083fb 100644
--- a/lisp/net/socks.el
+++ b/lisp/net/socks.el
@@ -235,11 +235,10 @@
   (let ((num 0)
 	(retval ""))
     (mapc
-     (function
-      (lambda (x)
-	(if (fboundp (cdr (cdr x)))
-	    (setq retval (format "%s%c" retval (car x))
-		  num (1+ num)))))
+     (lambda (x)
+       (if (fboundp (cdr (cdr x)))
+           (setq retval (format "%s%c" retval (car x))
+                 num (1+ num))))
      (reverse socks-authentication-methods))
     (format "%c%s" num retval)))
 
diff --git a/lisp/org/ox-odt.el b/lisp/org/ox-odt.el
index a1486318a7d..229b524f843 100644
--- a/lisp/org/ox-odt.el
+++ b/lisp/org/ox-odt.el
@@ -2199,10 +2199,10 @@ SHORT-CAPTION are strings."
 (defun org-odt--image-size
   (file info &optional user-width user-height scale dpi embed-as)
   (let* ((--pixels-to-cms
-	  (function (lambda (pixels dpi)
-		      (let ((cms-per-inch 2.54)
-			    (inches (/ pixels dpi)))
-			(* cms-per-inch inches)))))
+          (lambda (pixels dpi)
+            (let ((cms-per-inch 2.54)
+                  (inches (/ pixels dpi)))
+              (* cms-per-inch inches))))
 	 (--size-in-cms
 	  (function
 	   (lambda (size-in-pixels dpi)
diff --git a/lisp/pcomplete.el b/lisp/pcomplete.el
index 679f2e93e03..a744165e0d5 100644
--- a/lisp/pcomplete.el
+++ b/lisp/pcomplete.el
@@ -291,9 +291,8 @@ generate the completions list.  This means that the hook
   `(pcomplete--here (lambda () ,form) ,stub ,paring ,form-only))
 
 (defcustom pcomplete-command-completion-function
-  (function
-   (lambda ()
-     (pcomplete-here (pcomplete-executables))))
+  (lambda ()
+    (pcomplete-here (pcomplete-executables)))
   "Function called for completing the initial command argument."
   :type 'function)
 
@@ -302,9 +301,8 @@ generate the completions list.  This means that the hook
   :type 'function)
 
 (defcustom pcomplete-default-completion-function
-  (function
-   (lambda ()
-     (while (pcomplete-here (pcomplete-entries)))))
+  (lambda ()
+    (while (pcomplete-here (pcomplete-entries))))
   "Function called when no completion rule can be found.
 This function is used to generate completions for every argument."
   :type 'function)
@@ -988,9 +986,8 @@ Arguments NO-GANGING and ARGS-FOLLOW are currently ignored."
 	    (setq index (1+ index))))
 	(throw 'pcomplete-completions
 	       (mapcar
-		(function
-		 (lambda (opt)
-		   (concat "-" opt)))
+                (lambda (opt)
+                  (concat "-" opt))
 		(pcomplete-uniquify-list choices))))
     (let ((arg (pcomplete-arg)))
       (when (and (> (length arg) 1)
diff --git a/lisp/progmodes/cperl-mode.el b/lisp/progmodes/cperl-mode.el
index d5b30025e7b..a42ace105aa 100644
--- a/lisp/progmodes/cperl-mode.el
+++ b/lisp/progmodes/cperl-mode.el
@@ -3441,8 +3441,8 @@ Should be called with the point before leading colon of an attribute."
 	   (match-beginning 4) (match-end 4)
 	   'face dashface))
       ;; save match data (for looking-at)
-      (setq lll (mapcar (function (lambda (elt) (cons (match-beginning elt)
-						 (match-end elt))))
+      (setq lll (mapcar (lambda (elt) (cons (match-beginning elt)
+                                       (match-end elt)))
                         l))
       (while lll
 	(setq ll (car lll))
@@ -6758,10 +6758,10 @@ One may build such TAGS files from CPerl mode menu."
   (require 'etags)
   (require 'imenu)
   (if (or update (null (nth 2 cperl-hierarchy)))
-      (let ((remover (function (lambda (elt) ; (name (file1...) (file2..))
-				 (or (nthcdr 2 elt)
-				     ;; Only in one file
-				     (setcdr elt (cdr (nth 1 elt)))))))
+      (let ((remover (lambda (elt) ; (name (file1...) (file2..))
+                       (or (nthcdr 2 elt)
+                           ;; Only in one file
+                           (setcdr elt (cdr (nth 1 elt))))))
 	    to l1 l2 l3)
 	;; (setq cperl-hierarchy '(() () ())) ; Would write into '() later!
 	(setq cperl-hierarchy (list l1 l2 l3))
@@ -6841,33 +6841,33 @@ One may build such TAGS files from CPerl mode menu."
     (setq ord 2)
     (mapc move-deeper methods)
     (if recurse
-	(mapc (function (lambda (elt)
-			  (cperl-tags-treeify elt (1+ level))))
+        (mapc (lambda (elt)
+                (cperl-tags-treeify elt (1+ level)))
 	      (cdr to)))
     ;;Now clean up leaders with one child only
-    (mapc (function (lambda (elt)
-		      (if (not (and (listp (cdr elt))
-				    (eq (length elt) 2)))
-                          nil
-			(setcar elt (car (nth 1 elt)))
-			(setcdr elt (cdr (nth 1 elt))))))
+    (mapc (lambda (elt)
+            (if (not (and (listp (cdr elt))
+                          (eq (length elt) 2)))
+                nil
+              (setcar elt (car (nth 1 elt)))
+              (setcdr elt (cdr (nth 1 elt)))))
 	  (cdr to))
     ;; Sort the roots of subtrees
     (if (default-value 'imenu-sort-function)
 	(setcdr to
 		(sort (cdr to) (default-value 'imenu-sort-function))))
     ;; Now add back functions removed from display
-    (mapc (function (lambda (elt)
-		      (setcdr to (cons elt (cdr to)))))
+    (mapc (lambda (elt)
+            (setcdr to (cons elt (cdr to))))
 	  (if (default-value 'imenu-sort-function)
 	      (nreverse
 	       (sort root-functions (default-value 'imenu-sort-function)))
 	    root-functions))
     ;; Now add back packages removed from display
-    (mapc (function (lambda (elt)
-		      (setcdr to (cons (cons (concat "package " (car elt))
-					     (cdr elt))
-				       (cdr to)))))
+    (mapc (lambda (elt)
+            (setcdr to (cons (cons (concat "package " (car elt))
+                                   (cdr elt))
+                             (cdr to))))
 	  (if (default-value 'imenu-sort-function)
 	      (nreverse
 	       (sort root-packages (default-value 'imenu-sort-function)))
@@ -8211,11 +8211,11 @@ a result of qr//, this is not a performance hit), t for the rest."
     (and (eq (get-text-property beg 'syntax-type) 'string)
 	 (setq beg (next-single-property-change beg 'syntax-type nil limit)))
     (cperl-map-pods-heres
-     (function (lambda (s _e _p)
-		 (if (memq (get-text-property s 'REx-interpolated) skip)
-		     t
-		   (setq pp s)
-		   nil)))	; nil stops
+     (lambda (s _e _p)
+       (if (memq (get-text-property s 'REx-interpolated) skip)
+           t
+         (setq pp s)
+         nil))	; nil stops
      'REx-interpolated beg limit)
     (if pp (goto-char pp)
       (message "No more interpolated REx"))))
@@ -8334,7 +8334,7 @@ start with default arguments, then refine the slowdown regions."
   (or l (setq l 1))
   (or step (setq step 500))
   (or lim (setq lim 40))
-  (let* ((timems (function (lambda () (car (cperl--time-convert nil 1000)))))
+  (let* ((timems (lambda () (car (cperl--time-convert nil 1000))))
 	 (tt (funcall timems)) (c 0) delta tot)
     (goto-char (point-min))
     (forward-line (1- l))
diff --git a/lisp/shadowfile.el b/lisp/shadowfile.el
index 31f3a34d500..a7343a9f943 100644
--- a/lisp/shadowfile.el
+++ b/lisp/shadowfile.el
@@ -524,10 +524,9 @@ call it manually."
       (if (called-interactively-p 'interactive)
 	  (message "No files need to be shadowed."))
     (save-excursion
-      (map-y-or-n-p (function
-		     (lambda (pair)
-		       (or arg shadow-noquery
-			   (format "Copy shadow file %s? " (cdr pair)))))
+      (map-y-or-n-p (lambda (pair)
+                      (or arg shadow-noquery
+                          (format "Copy shadow file %s? " (cdr pair))))
 		    (function shadow-copy-file)
 		    shadow-files-to-copy
 		    '("shadow" "shadows" "copy"))
@@ -632,9 +631,8 @@ Consider them as regular expressions if third arg REGEXP is true."
                             "shadow-shadows-of-1: %s %s %s"
                             file (shadow-parse-name file) realname))
 			 (mapcar
-			  (function
-			   (lambda (x)
-			     (shadow-replace-name-component x realname)))
+                          (lambda (x)
+                            (shadow-replace-name-component x realname))
 			  nonmatching)))
 		      (t nonmatching))
 		(shadow-shadows-of-1 file (cdr groups) regexp)))))
@@ -791,9 +789,8 @@ look for files that have been changed and need to be copied to other systems."
   (save-some-buffers arg t)
   (shadow-copy-files)
   (shadow-save-todo-file)
-  (and (or (not (memq t (mapcar (function
-				 (lambda (buf) (and (buffer-file-name buf)
-						    (buffer-modified-p buf))))
+  (and (or (not (memq t (mapcar (lambda (buf) (and (buffer-file-name buf)
+                                              (buffer-modified-p buf)))
 				(buffer-list))))
 	   (yes-or-no-p "Modified buffers exist; exit anyway? "))
        (or (not (fboundp 'process-list))
diff --git a/lisp/strokes.el b/lisp/strokes.el
index c2f03cac0f1..11bc07a29cc 100644
--- a/lisp/strokes.el
+++ b/lisp/strokes.el
@@ -574,9 +574,8 @@ Optional GRID-RESOLUTION may be used in place of `strokes-grid-resolution'.
 The grid is a square whose dimension is [0,GRID-RESOLUTION)."
   (or grid-resolution (setq grid-resolution strokes-grid-resolution))
   (let ((stroke-extent (strokes-get-stroke-extent positions)))
-    (mapcar (function
-	     (lambda (pos)
-	       (strokes-get-grid-position stroke-extent pos grid-resolution)))
+    (mapcar (lambda (pos)
+              (strokes-get-grid-position stroke-extent pos grid-resolution))
 	    positions)))
 
 (defun strokes-fill-stroke (unfilled-stroke &optional force)
diff --git a/lisp/tempo.el b/lisp/tempo.el
index f6612354b1c..9ee0eefc4ae 100644
--- a/lisp/tempo.el
+++ b/lisp/tempo.el
@@ -353,9 +353,8 @@ possible."
 	((and (consp element)
 	      (eq (car element) 's)) (tempo-insert-named (car (cdr element))))
 	((and (consp element)
-	      (eq (car element) 'l)) (mapcar (function
-					      (lambda (elt)
-						(tempo-insert elt on-region)))
+              (eq (car element) 'l)) (mapcar (lambda (elt)
+                                               (tempo-insert elt on-region))
 					     (cdr element)))
 	((eq element 'p) (tempo-insert-mark (point-marker)))
 	((eq element 'r) (if on-region
@@ -546,10 +545,9 @@ and insert the results."
   (interactive)
   (let ((next-mark (catch 'found
 		     (mapc
-		      (function
-		       (lambda (mark)
-			 (if (< (point) mark)
-			     (throw 'found mark))))
+                      (lambda (mark)
+                        (if (< (point) mark)
+                            (throw 'found mark)))
 		      tempo-marks)
 		     ;; return nil if not found
 		     nil)))
@@ -565,11 +563,10 @@ and insert the results."
   (let ((prev-mark (catch 'found
 		     (let (last)
 		       (mapc
-			(function
-			 (lambda (mark)
-			   (if (<= (point) mark)
-			       (throw 'found last))
-			   (setq last mark)))
+                        (lambda (mark)
+                          (if (<= (point) mark)
+                              (throw 'found last))
+                          (setq last mark))
 			tempo-marks)
 		       last))))
     (if prev-mark
diff --git a/lisp/textmodes/artist.el b/lisp/textmodes/artist.el
index 5ce9a90ea65..90e8d360c1b 100644
--- a/lisp/textmodes/artist.el
+++ b/lisp/textmodes/artist.el
@@ -5398,10 +5398,9 @@ The event, EV, is the mouse event."
 		    artist-arrow-point-2)))
 	;; Remove those variables from vars that are not bound
 	(mapc
-	 (function
-	  (lambda (x)
-	    (if (not (and (boundp x) (symbol-value x)))
-		(setq vars (delq x vars))))) vars)
+         (lambda (x)
+           (if (not (and (boundp x) (symbol-value x)))
+               (setq vars (delq x vars)))) vars)
 	(reporter-submit-bug-report
 	 artist-maintainer-address
 	 (concat "artist.el " artist-version)
diff --git a/lisp/textmodes/ispell.el b/lisp/textmodes/ispell.el
index 31b699cf501..14de77cd542 100644
--- a/lisp/textmodes/ispell.el
+++ b/lisp/textmodes/ispell.el
@@ -3704,11 +3704,10 @@ Standard ispell choices are then available."
 	    ((string-equal (upcase word) word)
 	     (setq possibilities (mapcar #'upcase possibilities)))
 	    ((eq (upcase (aref word 0)) (aref word 0))
-             (setq possibilities (mapcar (function
-                                          (lambda (pos)
-                                            (if (eq (aref word 0) (aref pos 0))
-						pos
-                                              (capitalize pos))))
+             (setq possibilities (mapcar (lambda (pos)
+                                           (if (eq (aref word 0) (aref pos 0))
+                                               pos
+                                             (capitalize pos)))
                                          possibilities))))
 	   (setq case-fold-search case-fold-search-val)
 	   (save-window-excursion
diff --git a/lisp/url/url-auth.el b/lisp/url/url-auth.el
index 8f39b5ae010..fd800cd9782 100644
--- a/lisp/url/url-auth.el
+++ b/lisp/url/url-auth.el
@@ -494,21 +494,19 @@ PROMPT is boolean - specifies whether to ask the user for a username/password
        (car-safe
 	(sort
 	 (mapcar
-	  (function
-	   (lambda (scheme)
-	     (if (fboundp (car (cdr scheme)))
-		 (cons (cdr (cdr scheme))
-		       (funcall (car (cdr scheme)) url nil nil realm))
-	       (cons 0 nil))))
+          (lambda (scheme)
+            (if (fboundp (car (cdr scheme)))
+                (cons (cdr (cdr scheme))
+                      (funcall (car (cdr scheme)) url nil nil realm))
+              (cons 0 nil)))
 	  url-registered-auth-schemes)
-	 (function
-	  (lambda (x y)
-	    (cond
-	     ((null (cdr x)) nil)
-	     ((and (cdr x) (null (cdr y))) t)
-	     ((and (cdr x) (cdr y))
-	      (>= (car x) (car y)))
-	     (t nil)))))))
+         (lambda (x y)
+           (cond
+            ((null (cdr x)) nil)
+            ((and (cdr x) (null (cdr y))) t)
+            ((and (cdr x) (cdr y))
+             (>= (car x) (car y)))
+            (t nil))))))
     (if (symbolp type) (setq type (symbol-name type)))
     (let* ((scheme (car-safe
 		    (cdr-safe (assoc (downcase type)
diff --git a/lisp/url/url-cache.el b/lisp/url/url-cache.el
index 056ad1e0188..ea14e60ecc8 100644
--- a/lisp/url/url-cache.el
+++ b/lisp/url/url-cache.el
@@ -110,18 +110,17 @@ The actual return value is the last modification time of the cache file."
 	    (let ((slash nil))
 	      (setq fname
 		    (mapconcat
-		     (function
-		      (lambda (x)
-			(cond
-			 ((and (= ?/ x) slash)
-			  (setq slash nil)
-			  "%2F")
-			 ((= ?/ x)
-			  (setq slash t)
-			  "/")
-			 (t
-			  (setq slash nil)
-			  (char-to-string x))))) fname ""))))
+                     (lambda (x)
+                       (cond
+                        ((and (= ?/ x) slash)
+                         (setq slash nil)
+                         "%2F")
+                        ((= ?/ x)
+                         (setq slash t)
+                         "/")
+                        (t
+                         (setq slash nil)
+                         (char-to-string x)))) fname ""))))
 
 	(setq fname (and fname
 			 (mapconcat
diff --git a/lisp/vcursor.el b/lisp/vcursor.el
index 3601abcd6e4..e5e9f062a92 100644
--- a/lisp/vcursor.el
+++ b/lisp/vcursor.el
@@ -602,15 +602,14 @@ Set `vcursor-window' to the returned value as a side effect."
 	       (pos-visible-in-window-p (point) vcursor-window))
 	  (progn
 	    (walk-windows
-	     (function
-	      (lambda (win)
-		(and (not winok)
-		     (eq (current-buffer) (window-buffer win))
-		     (not (and not-this (eq thiswin win)))
-		     (cond
-		      ((pos-visible-in-window-p (point) win) (setq winok win))
-		      ((eq thiswin win))
-		      ((not winbuf) (setq winbuf win))))))
+             (lambda (win)
+               (and (not winok)
+                    (eq (current-buffer) (window-buffer win))
+                    (not (and not-this (eq thiswin win)))
+                    (cond
+                     ((pos-visible-in-window-p (point) win) (setq winok win))
+                     ((eq thiswin win))
+                     ((not winbuf) (setq winbuf win)))))
 	     nil (not this-frame))
 	    (setq vcursor-window
 		  (cond
diff --git a/test/lisp/textmodes/reftex-tests.el b/test/lisp/textmodes/reftex-tests.el
index 2350326c14c..42a060b395e 100644
--- a/test/lisp/textmodes/reftex-tests.el
+++ b/test/lisp/textmodes/reftex-tests.el
@@ -153,24 +153,23 @@
   edition =   {17th},
   note   =      {Updated for Emacs   Version 24.2}
 }")
-        (check (function
-                (lambda (parsed)
-                  (should (string= (reftex-get-bib-field "&key" parsed)
-                                   "Stallman12"))
-                  (should (string= (reftex-get-bib-field "&type" parsed)
-                                   "book"))
-                  (should (string= (reftex-get-bib-field "author" parsed)
-                                   "Richard Stallman et al."))
-                  (should (string= (reftex-get-bib-field "title" parsed)
-                                   "The Emacs Editor"))
-                  (should (string= (reftex-get-bib-field "publisher" parsed)
-                                   "GNU Press"))
-                  (should (string= (reftex-get-bib-field "year" parsed)
-                                   "2012"))
-                  (should (string= (reftex-get-bib-field "edition" parsed)
-                                   "17th"))
-                  (should (string= (reftex-get-bib-field "note" parsed)
-                                   "Updated for Emacs Version 24.2"))))))
+        (check (lambda (parsed)
+                 (should (string= (reftex-get-bib-field "&key" parsed)
+                                  "Stallman12"))
+                 (should (string= (reftex-get-bib-field "&type" parsed)
+                                  "book"))
+                 (should (string= (reftex-get-bib-field "author" parsed)
+                                  "Richard Stallman et al."))
+                 (should (string= (reftex-get-bib-field "title" parsed)
+                                  "The Emacs Editor"))
+                 (should (string= (reftex-get-bib-field "publisher" parsed)
+                                  "GNU Press"))
+                 (should (string= (reftex-get-bib-field "year" parsed)
+                                  "2012"))
+                 (should (string= (reftex-get-bib-field "edition" parsed)
+                                  "17th"))
+                 (should (string= (reftex-get-bib-field "note" parsed)
+                                  "Updated for Emacs Version 24.2")))))
     (funcall check (reftex-parse-bibtex-entry entry))
     (with-temp-buffer
       (insert entry)