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.

diff --git a/lisp/international/characters.el b/lisp/international/characters.el
index c643f66cbb034204ca0810edc850cbd715dbc6be..97bf31acfc3dc4fd19a226f421648f1018640ca7 100644 (file)
--- 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)
 
 \f
@@ -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 8f0f263dccecbe14fa51003ecfda463b9996da52..3deaff96774dcc990df4451d8e99d77565138f3c 100644 (file)
--- 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 4b6ef9833e57c8669823c91865b6dee362946c5b..b3d6a635b1ce1d2c739718abee65e62af14dbf80 100644 (file)
--- 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 bf0df6f971d7146948823f6b7edf7f7271811ab1..578d97bcc0a62d1b0a02846f6c99ceca577cd895 100644 (file)
--- 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 a0063c8dbb6ff2dcd748522daa033c670cb7533b..2d3cd25b4a47bd8e8bf2b3a2b6975c03946bd861 100644 (file)
--- 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 83cbb44c4db3338e0969f7084b0de9df02c393c1..a6fccff3c9a7a07a2a2709a20199581ecddc25d3 100644 (file)
--- 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)))))))))))
 \f

diff --git a/lisp/international/quail.el b/lisp/international/quail.el
index 87a905045d43ea17ba5bc40ffe1cdc0804337091..fff06deee88a3aa2f1ba59885642a9c7013bdd56 100644 (file)
--- 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 64d664437607997117f5cdde09546eb9413c6ebf..ccb4c8390bb7a2348b182c05e04496bc20e58b40 100644 (file)
--- 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))