Remove redundant #' before lambda

* admin/unidata/unidata-gen.el (unidata-gen-table)
(unidata-gen-table-symbol, unidata-gen-table-integer)
(unidata-gen-table-numeric, unidata-gen-table-word-list)
(unidata-describe-decomposition):
* lisp/apropos.el (apropos-user-option):
* lisp/bookmark.el (bookmark-bmenu-search):
* lisp/composite.el (unicode-category-table):
* lisp/elec-pair.el (electric-pair--balance-info):
* lisp/electric.el (electric-quote-chars):
* lisp/emulation/cua-base.el (cua-rectangle-mark-key):
* lisp/epa-hook.el (epa-file-encrypt-to):
* lisp/faces.el (face-font-selection-order)
(face-font-family-alternatives, face-font-registry-alternatives)
(face-valid-attribute-values, tty-run-terminal-initialization):
* lisp/files.el (recover-file, file-expand-wildcards):
* lisp/frame.el (frames-on-display-list):
* lisp/help-at-pt.el (help-at-pt-display-when-idle):
* lisp/help-fns.el (help-fns--face-attributes):
* lisp/ido.el (ido-mode, ido-unc-hosts):
* lisp/isearch.el (isearch-highlight-regexp)
(isearch-highlight-lines-matching-regexp):
* lisp/language/indian.el (script-regexp-alist):
* lisp/language/lao.el:
* lisp/leim/quail/ipa.el (ipa-x-sampa-prepend-to-keymap-entry):
* lisp/mh-e/mh-folder.el (mh-process-commands):
* lisp/mh-e/mh-mime.el (mh-display-with-external-viewer):
* lisp/ps-mule.el (ps-mule-end-job):
* lisp/ps-print.el (ps-color-scale, ps-background-pages)
(ps-background-text, ps-background-image, ps-background)
(ps-begin-job, ps-print-translation-table):
* lisp/recentf.el (recentf-sort-ascending)
(recentf-sort-descending, recentf-sort-basenames-ascending)
(recentf-sort-basenames-descending)
(recentf-sort-directories-ascending)
(recentf-sort-directories-descending):
* lisp/replace.el (occur-engine-add-prefix):
* lisp/select.el (xselect--encode-string):
* lisp/server.el (server-use-tcp):
* lisp/ses.el (ses-sort-column):
* lisp/sort.el (sort-columns):
* lisp/term/ns-win.el (window-system-initialization):
* lisp/tree-widget.el (tree-widget-image-formats):
* lisp/whitespace.el (whitespace-report-region): Remove redundant #'
before lambda.

1 files changed, 39 insertions, 39 deletions

diff --git a/lisp/elec-pair.el b/lisp/elec-pair.el
index ba88c819133..f907bba4c6e 100644
--- a/lisp/elec-pair.el
+++ b/lisp/elec-pair.el
@@ -308,51 +308,51 @@ If point is not enclosed by any lists, return ((t) . (t))."
           ;; called when `scan-sexps' ran perfectly, when it found
           ;; a parenthesis pointing in the direction of travel.
           ;; Also when travel started inside a comment and exited it.
-          #'(lambda ()
-              (setq outermost (list t))
-              (unless innermost
-                (setq innermost (list t)))))
+          (lambda ()
+            (setq outermost (list t))
+            (unless innermost
+              (setq innermost (list t)))))
          (ended-prematurely-fn
           ;; called when `scan-sexps' crashed against a parenthesis
           ;; pointing opposite the direction of travel.  After
           ;; traversing that character, the idea is to travel one sexp
           ;; in the opposite direction looking for a matching
           ;; delimiter.
-          #'(lambda ()
-              (let* ((pos (point))
-                     (matched
-                      (save-excursion
-                        (cond ((< direction 0)
-                               (condition-case nil
-                                   (eq (char-after pos)
-                                       (electric-pair--with-uncached-syntax
-                                           (table)
-                                         (matching-paren
-                                          (char-before
-                                           (scan-sexps (point) 1)))))
-                                 (scan-error nil)))
-                              (t
-                               ;; In this case, no need to use
-                               ;; `scan-sexps', we can use some
-                               ;; `electric-pair--syntax-ppss' in this
-                               ;; case (which uses the quicker
-                               ;; `syntax-ppss' in some cases)
-                               (let* ((ppss (electric-pair--syntax-ppss
-                                             (1- (point))))
-                                      (start (car (last (nth 9 ppss))))
-                                      (opener (char-after start)))
-                                 (and start
-                                      (eq (char-before pos)
-                                          (or (with-syntax-table table
-                                                (matching-paren opener))
-                                              opener))))))))
-                     (actual-pair (if (> direction 0)
-                                      (char-before (point))
-                                    (char-after (point)))))
-                (unless innermost
-                  (setq innermost (cons matched actual-pair)))
-                (unless matched
-                  (setq outermost (cons matched actual-pair)))))))
+          (lambda ()
+            (let* ((pos (point))
+                   (matched
+                    (save-excursion
+                      (cond ((< direction 0)
+                             (condition-case nil
+                                 (eq (char-after pos)
+                                     (electric-pair--with-uncached-syntax
+                                      (table)
+                                      (matching-paren
+                                       (char-before
+                                        (scan-sexps (point) 1)))))
+                               (scan-error nil)))
+                            (t
+                             ;; In this case, no need to use
+                             ;; `scan-sexps', we can use some
+                             ;; `electric-pair--syntax-ppss' in this
+                             ;; case (which uses the quicker
+                             ;; `syntax-ppss' in some cases)
+                             (let* ((ppss (electric-pair--syntax-ppss
+                                           (1- (point))))
+                                    (start (car (last (nth 9 ppss))))
+                                    (opener (char-after start)))
+                               (and start
+                                    (eq (char-before pos)
+                                        (or (with-syntax-table table
+                                              (matching-paren opener))
+                                            opener))))))))
+                   (actual-pair (if (> direction 0)
+                                    (char-before (point))
+                                  (char-after (point)))))
+              (unless innermost
+                (setq innermost (cons matched actual-pair)))
+              (unless matched
+                (setq outermost (cons matched actual-pair)))))))
     (save-excursion
       (while (not outermost)
         (condition-case err