Remove redundant #' before lambda in international/*.el

* lisp/international/characters.el:
(use-cjk-char-width-table, update-glyphless-char-display):
* lisp/international/fontset.el (build-default-fontset-data)
(generate-fontset-menu):
* lisp/international/latin1-disp.el (latin1-display-reset):
* lisp/international/mule-cmds.el
(select-safe-coding-system-interactively):
* lisp/international/mule-diag.el (sort-listed-character-sets)
(font-show-log):
* lisp/international/mule.el (char-displayable-p):
* lisp/international/quail.el (quail-keyboard-layout-type)
(quail-update-translation, quail-find-key):
* lisp/international/titdic-cnv.el (tsang-quick-converter)
(ziranma-converter): Remove redundant #' before lambda.

8 files changed, 130 insertions, 130 deletions

diff --git a/lisp/international/characters.el b/lisp/international/characters.el
index c643f66cbb0..97bf31acfc3 100644
--- a/lisp/international/characters.el
+++ b/lisp/international/characters.el
@@ -484,9 +484,9 @@ with L, LRE, or LRO Unicode bidi character type.")
 	  (progn
 	    (modify-syntax-entry chars syntax)
 	    (modify-category-entry chars category))
-	(mapc #'(lambda (x)
-		  (modify-syntax-entry x syntax)
-		  (modify-category-entry x category))
+        (mapc (lambda (x)
+                (modify-syntax-entry x syntax)
+                (modify-category-entry x category))
 	      chars)))))
 
 ;; Bidi categories
@@ -1390,8 +1390,8 @@ with L, LRE, or LRO Unicode bidi character type.")
 	(dolist (charset-info (nthcdr 2 slot))
 	  (let ((charset (car charset-info)))
 	    (dolist (code-range (cdr charset-info))
-	      (map-charset-chars #'(lambda (range _arg)
-				     (set-char-table-range table range 2))
+              (map-charset-chars (lambda (range _arg)
+                                   (set-char-table-range table range 2))
 				 charset nil
 				 (car code-range) (cdr code-range)))))
 	(optimize-char-table table)
@@ -1417,8 +1417,8 @@ Setup char-width-table appropriate for non-CJK language environment."
   (require 'charscript))
 
 (map-charset-chars
- #'(lambda (range _ignore)
-     (set-char-table-range char-script-table range 'tibetan))
+ (lambda (range _ignore)
+   (set-char-table-range char-script-table range 'tibetan))
  'tibetan)
 
 
@@ -1426,14 +1426,14 @@ Setup char-width-table appropriate for non-CJK language environment."
 
 (when (setq unicode-category-table
 	    (unicode-property-table-internal 'general-category))
-  (map-char-table #'(lambda (key val)
-		      (if val
-			  (cond ((or (and (/= (aref (symbol-name val) 0) ?M)
-					  (/= (aref (symbol-name val) 0) ?C))
-				     (eq val 'Zs))
-				 (modify-category-entry key ?.))
-				((eq val 'Mn)
-				 (modify-category-entry key ?^)))))
+  (map-char-table (lambda (key val)
+                    (if val
+                        (cond ((or (and (/= (aref (symbol-name val) 0) ?M)
+                                        (/= (aref (symbol-name val) 0) ?C))
+                                   (eq val 'Zs))
+                               (modify-category-entry key ?.))
+                              ((eq val 'Mn)
+                               (modify-category-entry key ?^)))))
 		  unicode-category-table))
 
 (optimize-char-table (standard-category-table))
@@ -1524,21 +1524,21 @@ option `glyphless-char-display'."
 	    ((eq target 'format-control)
 	     (when unicode-category-table
 	       (map-char-table
-		#'(lambda (char category)
-		    (if (eq category 'Cf)
-			(let ((this-method method)
-			      from to)
-			  (if (consp char)
-			      (setq from (car char) to (cdr char))
-			    (setq from char to char))
-			  (while (<= from to)
-			    (when (/= from #xAD)
-			      (if (eq method 'acronym)
-				  (setq this-method
-					(aref char-acronym-table from)))
-			      (set-char-table-range glyphless-char-display
-						    from this-method))
-			    (setq from (1+ from))))))
+                (lambda (char category)
+                  (if (eq category 'Cf)
+                      (let ((this-method method)
+                            from to)
+                        (if (consp char)
+                            (setq from (car char) to (cdr char))
+                          (setq from char to char))
+                        (while (<= from to)
+                          (when (/= from #xAD)
+                            (if (eq method 'acronym)
+                                (setq this-method
+                                      (aref char-acronym-table from)))
+                            (set-char-table-range glyphless-char-display
+                                                  from this-method))
+                          (setq from (1+ from))))))
 		unicode-category-table)))
 	    ((eq target 'no-font)
 	     (set-char-table-extra-slot glyphless-char-display 0 method))
diff --git a/lisp/international/fontset.el b/lisp/international/fontset.el
index 8f0f263dcce..3deaff96774 100644
--- a/lisp/international/fontset.el
+++ b/lisp/international/fontset.el
@@ -497,37 +497,37 @@
 		     (:registry "iso10646-1"))))
 	 (cjk-table (make-char-table nil))
 	 (script-coverage
-	  #'(lambda (script)
-	      (let ((coverage))
-		(map-char-table
-		 #'(lambda (range val)
-		     (when (eq val script)
-		       (if (consp range)
-			   (setq range (cons (car range) (cdr range))))
-		       (push range coverage)))
-		 char-script-table)
-		coverage)))
+          (lambda (script)
+            (let ((coverage))
+              (map-char-table
+               (lambda (range val)
+                 (when (eq val script)
+                   (if (consp range)
+                       (setq range (cons (car range) (cdr range))))
+                   (push range coverage)))
+               char-script-table)
+              coverage)))
 	 (data (list (vconcat (mapcar 'car cjk))))
 	 (i 0))
     (dolist (elt cjk)
       (let ((mask (ash 1 i)))
 	(map-charset-chars
-	 #'(lambda (range _arg)
-	     (let ((from (car range)) (to (cdr range)))
-	       (if (< to #x110000)
-		   (while (<= from to)
-		     (or (memq (aref char-script-table from)
-			       '(kana hangul han cjk-misc))
-			 (aset cjk-table from
-			       (logior (or (aref cjk-table from) 0) mask)))
-		     (setq from (1+ from))))))
+         (lambda (range _arg)
+           (let ((from (car range)) (to (cdr range)))
+             (if (< to #x110000)
+                 (while (<= from to)
+                   (or (memq (aref char-script-table from)
+                             '(kana hangul han cjk-misc))
+                       (aset cjk-table from
+                             (logior (or (aref cjk-table from) 0) mask)))
+                   (setq from (1+ from))))))
 	 (nth 1 elt) nil (nth 2 elt) (nth 3 elt)))
       (setq i (1+ i)))
     (map-char-table
-     #'(lambda (range val)
-	 (if (consp range)
-	     (setq range (cons (car range) (cdr range))))
-	 (push (cons range val) data))
+     (lambda (range val)
+       (if (consp range)
+           (setq range (cons (car range) (cdr range))))
+       (push (cons range val) data))
      cjk-table)
     (dolist (script scripts)
       (dolist (range (funcall script-coverage (car script)))
@@ -1227,7 +1227,7 @@ Done when `mouse-set-font' is called."
 	  (string-match "fontset-auto[0-9]+$" fontset)
 	  (push (list (fontset-plain-name fontset) fontset) l)))
     (cons "Fontset"
-	  (sort l #'(lambda (x y) (string< (car x) (car y)))))))
+          (sort l (lambda (x y) (string< (car x) (car y)))))))
 
 (declare-function query-fontset "fontset.c" (pattern &optional regexpp))
 
diff --git a/lisp/international/latin1-disp.el b/lisp/international/latin1-disp.el
index 4b6ef9833e5..b3d6a635b1c 100644
--- a/lisp/international/latin1-disp.el
+++ b/lisp/international/latin1-disp.el
@@ -186,8 +186,8 @@ character set."
 		     'arabic-iso8859-6
 		   (car (remq 'ascii (get-language-info language
 							'charset))))))
-    (map-charset-chars #'(lambda (range _arg)
-			   (standard-display-default (car range) (cdr range)))
+    (map-charset-chars (lambda (range _arg)
+                         (standard-display-default (car range) (cdr range)))
 		       charset))
   (sit-for 0))
 
diff --git a/lisp/international/mule-cmds.el b/lisp/international/mule-cmds.el
index bf0df6f971d..578d97bcc0a 100644
--- a/lisp/international/mule-cmds.el
+++ b/lisp/international/mule-cmds.el
@@ -679,18 +679,18 @@ DEFAULT is the coding system to use by default in the query."
   ;;	((CODING (POS . CHAR) (POS . CHAR) ...) ...)
   (if unsafe
       (setq unsafe
-	    (mapcar #'(lambda (coding)
-			(cons coding
-			      (if (stringp from)
-				  (mapcar #'(lambda (pos)
-					      (cons pos (aref from pos)))
-					  (unencodable-char-position
-					   0 (length from) coding
-					   11 from))
-				(mapcar #'(lambda (pos)
-					    (cons pos (char-after pos)))
-					(unencodable-char-position
-					 from to coding 11)))))
+            (mapcar (lambda (coding)
+                      (cons coding
+                            (if (stringp from)
+                                (mapcar (lambda (pos)
+                                          (cons pos (aref from pos)))
+                                        (unencodable-char-position
+                                         0 (length from) coding
+                                         11 from))
+                              (mapcar (lambda (pos)
+                                        (cons pos (char-after pos)))
+                                      (unencodable-char-position
+                                       from to coding 11)))))
 		    unsafe)))
 
   (setq codings (sanitize-coding-system-list codings))
@@ -744,19 +744,19 @@ e.g., for sending an email message.\n ")
 		(insert (format "  %s cannot encode these:" (car coding)))
 		(let ((i 0)
 		      (func1
-		       #'(lambda (bufname pos)
-			   (when (buffer-live-p (get-buffer bufname))
-			     (pop-to-buffer bufname)
-			     (goto-char pos))))
+                       (lambda (bufname pos)
+                         (when (buffer-live-p (get-buffer bufname))
+                           (pop-to-buffer bufname)
+                           (goto-char pos))))
 		      (func2
-		       #'(lambda (bufname pos coding)
-			   (when (buffer-live-p (get-buffer bufname))
-			     (pop-to-buffer bufname)
-			     (if (< (point) pos)
-				 (goto-char pos)
-			       (forward-char 1)
-			       (search-unencodable-char coding)
-			       (forward-char -1))))))
+                       (lambda (bufname pos coding)
+                         (when (buffer-live-p (get-buffer bufname))
+                           (pop-to-buffer bufname)
+                           (if (< (point) pos)
+                               (goto-char pos)
+                             (forward-char 1)
+                             (search-unencodable-char coding)
+                             (forward-char -1))))))
 		  (dolist (elt (cdr coding))
 		    (insert " ")
 		    (if (stringp from)
diff --git a/lisp/international/mule-diag.el b/lisp/international/mule-diag.el
index a0063c8dbb6..2d3cd25b4a4 100644
--- a/lisp/international/mule-diag.el
+++ b/lisp/international/mule-diag.el
@@ -45,8 +45,8 @@
 (define-button-type 'sort-listed-character-sets
   'help-echo (purecopy "mouse-2, RET: sort on this column")
   'face 'bold
-  'action #'(lambda (button)
-	      (sort-listed-character-sets (button-get button 'sort-key))))
+  'action (lambda (button)
+            (sort-listed-character-sets (button-get button 'sort-key))))
 
 (define-button-type 'list-charset-chars
   :supertype 'help-xref
@@ -1172,12 +1172,12 @@ The default is 20.  If LIMIT is negative, do not limit the listing."
 	(if (or (vectorp elt) (listp elt))
 	    (let ((i 0))
 	      (catch 'tag
-		(mapc #'(lambda (x)
-			  (setq i (1+ i))
-			  (when (= i limit)
-			    (insert "  ...\n")
-			    (throw 'tag nil))
-			  (insert (format "  %s\n" x)))
+                (mapc (lambda (x)
+                        (setq i (1+ i))
+                        (when (= i limit)
+                          (insert "  ...\n")
+                          (throw 'tag nil))
+                        (insert (format "  %s\n" x)))
 		      elt)))
 	  (insert (format "  %s\n" elt)))))))
 
diff --git a/lisp/international/mule.el b/lisp/international/mule.el
index 83cbb44c4db..a6fccff3c9a 100644
--- a/lisp/international/mule.el
+++ b/lisp/international/mule.el
@@ -490,27 +490,27 @@ per-character basis, this may not be accurate."
 		   (cond
 		    ((listp cs-list)
 		     (catch 'tag
-		       (mapc #'(lambda (charset)
-				 (if (encode-char char charset)
-				     (throw 'tag charset)))
+                       (mapc (lambda (charset)
+                               (if (encode-char char charset)
+                                   (throw 'tag charset)))
 			     cs-list)
 		       nil))
 		    ((eq cs-list 'iso-2022)
 		     (catch 'tag2
-		       (mapc #'(lambda (charset)
-				 (if (and (plist-get (charset-plist charset)
-						     :iso-final-char)
-					  (encode-char char charset))
-				     (throw 'tag2 charset)))
+                       (mapc (lambda (charset)
+                               (if (and (plist-get (charset-plist charset)
+                                                   :iso-final-char)
+                                        (encode-char char charset))
+                                   (throw 'tag2 charset)))
 			     charset-list)
 		       nil))
 		    ((eq cs-list 'emacs-mule)
 		     (catch 'tag3
-		       (mapc #'(lambda (charset)
-				 (if (and (plist-get (charset-plist charset)
-						     :emacs-mule-id)
-					  (encode-char char charset))
-				     (throw 'tag3 charset)))
+                       (mapc (lambda (charset)
+                               (if (and (plist-get (charset-plist charset)
+                                                   :emacs-mule-id)
+                                        (encode-char char charset))
+                                   (throw 'tag3 charset)))
 			     charset-list)
 		       nil)))))))))))
 
diff --git a/lisp/international/quail.el b/lisp/international/quail.el
index 87a905045d4..fff06deee88 100644
--- a/lisp/international/quail.el
+++ b/lisp/international/quail.el
@@ -728,9 +728,9 @@ Available types are listed in the variable `quail-keyboard-layout-alist'."
   :type (cons 'choice (mapcar (lambda (elt)
 				(list 'const (car elt)))
 			      quail-keyboard-layout-alist))
-  :set #'(lambda (symbol value)
-	   (quail-update-keyboard-layout value)
-	   (set symbol value)))
+  :set (lambda (symbol value)
+         (quail-update-keyboard-layout value)
+         (set symbol value)))
 
 ;;;###autoload
 (defun quail-set-keyboard-layout (kbd-type)
@@ -1571,12 +1571,12 @@ with more keys."
 	    (let (char)
 	      (if (stringp quail-current-str)
 		  (catch 'tag
-		    (mapc #'(lambda (ch)
-			      (when (/= (unibyte-char-to-multibyte
-					 (multibyte-char-to-unibyte ch))
-					ch)
-				  (setq char ch)
-				  (throw 'tag nil)))
+                    (mapc (lambda (ch)
+                            (when (/= (unibyte-char-to-multibyte
+                                       (multibyte-char-to-unibyte ch))
+                                      ch)
+                              (setq char ch)
+                              (throw 'tag nil)))
 			  quail-current-str))
 		(if (/= (unibyte-char-to-multibyte
 			 (multibyte-char-to-unibyte quail-current-str))
@@ -2827,19 +2827,19 @@ If CHAR is an ASCII character and can be input by typing itself, return t."
 	(key-list nil))
     (if (consp decode-map)
 	(let ((str (string char)))
-	  (mapc #'(lambda (elt)
-		    (if (string= str (car elt))
-			(setq key-list (cons (cdr elt) key-list))))
+          (mapc (lambda (elt)
+                  (if (string= str (car elt))
+                      (setq key-list (cons (cdr elt) key-list))))
 		(cdr decode-map)))
       (let ((key-head (aref decode-map char)))
 	(if (stringp key-head)
 	    (setq key-list (quail-find-key1
 			    (quail-lookup-key key-head nil t)
 			    key-head char nil))
-	  (mapc #'(lambda (elt)
-		    (setq key-list
-			  (quail-find-key1
-			   (quail-lookup-key elt nil t) elt char key-list)))
+          (mapc (lambda (elt)
+                  (setq key-list
+                        (quail-find-key1
+                         (quail-lookup-key elt nil t) elt char key-list)))
 		key-head))))
     (or key-list
 	(and (< char 128)
diff --git a/lisp/international/titdic-cnv.el b/lisp/international/titdic-cnv.el
index 64d66443760..ccb4c8390bb 100644
--- a/lisp/international/titdic-cnv.el
+++ b/lisp/international/titdic-cnv.el
@@ -781,7 +781,7 @@ To get complete usage, invoke \"emacs -batch -f batch-titdic-convert -h\"."
 	    (if val (setq trans (concat val trans)))
 	    (puthash key trans table)
 	    (forward-line 1)))
-	(maphash #'(lambda (key val) (setq dic (cons (cons key val) dic)))
+        (maphash (lambda (key val) (setq dic (cons (cons key val) dic)))
 		 table)))
     (setq dic (sort dic (lambda (x y) (string< (car x ) (car y)))))
     (dolist (elt dic)
@@ -931,18 +931,18 @@ method `chinese-tonepy' with which you must specify tones by digits
 	  (if val (setq trans (vconcat val trans)))
 	  (puthash key trans table)
 	  (forward-line 1))
-	(maphash #'(lambda (key trans)
-		     (let ((len (length trans))
-			   i)
-		       (if (and (= len 1) (= (length (aref trans 0)) 1))
-			   (setq trans (aref trans 0))
-			 (setq i 0)
-			 (while (and (< i len)
-				     (= (length (aref trans i)) 1))
-			   (setq i (1+ i)))
-			 (if (= i len)
-			     (setq trans (mapconcat #'identity trans "")))))
-		     (setq dic (cons (cons key trans) dic)))
+        (maphash (lambda (key trans)
+                   (let ((len (length trans))
+                         i)
+                     (if (and (= len 1) (= (length (aref trans 0)) 1))
+                         (setq trans (aref trans 0))
+                       (setq i 0)
+                       (while (and (< i len)
+                                   (= (length (aref trans i)) 1))
+                         (setq i (1+ i)))
+                       (if (= i len)
+                           (setq trans (mapconcat #'identity trans "")))))
+                   (setq dic (cons (cons key trans) dic)))
 		 table)))
     (setq dic (sort dic (lambda (x y) (string< (car x) (car y)))))
     (goto-char (point-max))