[elpa] externals/dict-tree f0af36e 148/154: Fix byte-compilation of functions embedded in dict-trees.

[Stefan Monnier]

branch: externals/dict-tree
commit f0af36ef541724dfd944651bb5d01a33cf0c1199
Author: Toby S. Cubitt <toby-predictive@dr-qubit.org>
Commit: Toby S. Cubitt <toby-predictive@dr-qubit.org>

    Fix byte-compilation of functions embedded in dict-trees.
---
 dict-tree.el | 231 +++++++++++++++++++++++++++++++----------------------------
 1 file changed, 121 insertions(+), 110 deletions(-)

diff --git a/dict-tree.el b/dict-tree.el
index 8124fea..a6358aa 100644
--- a/dict-tree.el
+++ b/dict-tree.el
@@ -1,9 +1,9 @@
 ;;; dict-tree.el --- Dictionary data structure  -*- lexical-binding: t; -*-
 
-;; Copyright (C) 2004-2015, 2017-2018  Free Software Foundation, Inc
+;; Copyright (C) 2004-2015, 2017-2019  Free Software Foundation, Inc
 
 ;; Author: Toby Cubitt <toby-predictive@dr-qubit.org>
-;; Version: 0.15
+;; Version: 0.16
 ;; Keywords: extensions, matching, data structures
 ;;           trie, tree, dictionary, completion, regexp
 ;; Package-Requires: ((trie "0.3) (tNFA "0.1.1") (heap "0.3"))
@@ -221,27 +221,29 @@ If START or END is negative, it counts from the end."
 ;;                     Wrapping functions
 
 ;; return wrapped insfun to deal with data wrapping
-(dictree--if-lexical-binding
-    (defun dictree--wrap-insfun (insfun)  ; INTERNAL USE ONLY
-      (lambda (new old)
-       (dictree--cell-set-data old (funcall insfun
-                                            (dictree--cell-data new)
-                                            (dictree--cell-data old)))
-       old))
+(defun dictree--wrap-insfun (insfun)  ; INTERNAL USE ONLY
+  (lambda (new old)
+    (dictree--cell-set-data old (funcall insfun
+                                        (dictree--cell-data new)
+                                        (dictree--cell-data old)))
+    old))
+
+(dictree--if-lexical-binding nil
   (defun dictree--wrap-insfun (insfun)  ; INTERNAL USE ONLY
     `(lambda (new old)
        (dictree--cell-set-data old (,insfun (dictree--cell-data new)
-                                           (dictree--cell-data old)))
+                                           (dictree--cell-data old)))
        old)))
 
 
 ;; return wrapped rankfun to deal with data wrapping
-(dictree--if-lexical-binding
-    (defun dictree--wrap-rankfun (rankfun)  ; INTERNAL USE ONLY
-      (lambda (a b)
-       (funcall rankfun
-                (cons (car a) (dictree--cell-data (cdr a)))
-                (cons (car b) (dictree--cell-data (cdr b))))))
+(defun dictree--wrap-rankfun (rankfun)  ; INTERNAL USE ONLY
+  (lambda (a b)
+    (funcall rankfun
+            (cons (car a) (dictree--cell-data (cdr a)))
+            (cons (car b) (dictree--cell-data (cdr b))))))
+
+(dictree--if-lexical-binding nil
   (defun dictree--wrap-rankfun (rankfun)  ; INTERNAL USE ONLY
     `(lambda (a b)
        (,rankfun (cons (car a) (dictree--cell-data (cdr a)))
@@ -249,23 +251,24 @@ If START or END is negative, it counts from the end."
 
 
 ;; return wrapped rankfun to ignore regexp grouping data
-(dictree--if-lexical-binding
-    (defun dictree--wrap-regexp-rankfun (rankfun)
-      (lambda (a b)
-       ;; if car of argument contains a key+group list rather than a straight
-       ;; key, remove group list
-       ;; FIXME: the test for straight key, below, will fail if the key is a
-       ;;        list, and the first element of the key is itself a list
-       ;;        (there might be no easy way to fully fix this...)
-       (if (or (atom (car a))
-               (and (listp (car a)) (not (sequencep (caar a)))))
-           (setq a (cons (car a) (dictree--cell-data (cdr a))))
-         (setq a (cons (caar a) (dictree--cell-data (cdr a)))))
-       (if (or (atom (car b))
-               (and (listp (car b)) (not (sequencep (caar b)))))
-           (setq b (cons (car b) (dictree--cell-data (cdr b))))
-         (setq b (cons (caar b) (dictree--cell-data (cdr b)))))
-       (funcall rankfun a b)))
+(defun dictree--wrap-regexp-rankfun (rankfun)
+  (lambda (a b)
+    ;; if car of argument contains a key+group list rather than a straight
+    ;; key, remove group list
+    ;; FIXME: the test for straight key, below, will fail if the key is a
+    ;;        list, and the first element of the key is itself a list
+    ;;        (there might be no easy way to fully fix this...)
+    (if (or (atom (car a))
+           (and (listp (car a)) (not (sequencep (caar a)))))
+       (setq a (cons (car a) (dictree--cell-data (cdr a))))
+      (setq a (cons (caar a) (dictree--cell-data (cdr a)))))
+    (if (or (atom (car b))
+           (and (listp (car b)) (not (sequencep (caar b)))))
+       (setq b (cons (car b) (dictree--cell-data (cdr b))))
+      (setq b (cons (caar b) (dictree--cell-data (cdr b)))))
+    (funcall rankfun a b)))
+
+(dictree--if-lexical-binding nil
   (defun dictree--wrap-regexp-rankfun (rankfun)
     `(lambda (a b)
        ;; if car of argument contains a key+group list rather than a straight
@@ -274,61 +277,63 @@ If START or END is negative, it counts from the end."
        ;;        list, and the first element of the key is itself a list
        ;;        (there might be no easy way to fully fix this...)
        (if (or (atom (car a))
-              (and (listp (car a)) (not (sequencep (caar a)))))
-           (setq a (cons (car a) (dictree--cell-data (cdr a))))
+              (and (listp (car a)) (not (sequencep (caar a)))))
+          (setq a (cons (car a) (dictree--cell-data (cdr a))))
         (setq a (cons (caar a) (dictree--cell-data (cdr a)))))
        (if (or (atom (car b))
-              (and (listp (car b)) (not (sequencep (caar b)))))
-          (setq b (cons (car b) (dictree--cell-data (cdr b))))
+              (and (listp (car b)) (not (sequencep (caar b)))))
+          (setq b (cons (car b) (dictree--cell-data (cdr b))))
         (setq b (cons (caar b) (dictree--cell-data (cdr b)))))
        (,rankfun a b))))
 
 ;; return wrapped sortfun to ignore regexp grouping data
-(dictree--if-lexical-binding
-    (defun dictree--wrap-regexp-sortfun (cmpfun &optional reverse)
-       (let ((sortfun (trie-construct-sortfun cmpfun reverse)))
-         (lambda (a b)
-           ;; if car of argument contains a key+group list rather than a
-           ;; straight key, remove group list
-           ;; FIXME: the test for straight key, below, will fail if the key
-           ;;        is a list, and the first element of the key is itself a
-           ;;        list (there might be no easy way to fully fix this...)
-           (if (or (atom (car a))
-                   (and (listp (car a)) (not (sequencep (caar a)))))
-               (setq a (car a))
-             (setq a (caar a)))
-           (if (or (atom (car b))
-                   (and (listp (car b)) (not (sequencep (caar b)))))
-               (setq b (car b))
-             (setq b (caar b)))
-           (funcall sortfun a b))))
+(defun dictree--wrap-regexp-sortfun (cmpfun &optional reverse)
+  (let ((sortfun (trie-construct-sortfun cmpfun reverse)))
+    (lambda (a b)
+      ;; if car of argument contains a key+group list rather than a
+      ;; straight key, remove group list
+      ;; FIXME: the test for straight key, below, will fail if the key
+      ;;        is a list, and the first element of the key is itself a
+      ;;        list (there might be no easy way to fully fix this...)
+      (if (or (atom (car a))
+             (and (listp (car a)) (not (sequencep (caar a)))))
+         (setq a (car a))
+       (setq a (caar a)))
+      (if (or (atom (car b))
+             (and (listp (car b)) (not (sequencep (caar b)))))
+         (setq b (car b))
+       (setq b (caar b)))
+      (funcall sortfun a b))))
+
+(dictree--if-lexical-binding nil
   (defun dictree--wrap-regexp-sortfun (cmpfun &optional reverse)
     (let ((sortfun (trie-construct-sortfun cmpfun reverse)))
       `(lambda (a b)
-        ;; if car of argument contains a key+group list rather than a
-        ;; straight key, remove group list
-        ;; FIXME: the test for straight key, below, will fail if the key
-        ;;        is a list, and the first element of the key is itself a
-        ;;        list (there might be no easy way to fully fix this...)
-        (if (or (atom (car a))
-                (and (listp (car a)) (not (sequencep (caar a)))))
-            (setq a (car a))
-          (setq a (caar a)))
-        (if (or (atom (car b))
-                (and (listp (car b)) (not (sequencep (caar b)))))
-            (setq b (car b))
-          (setq b (caar b)))
-        (,sortfun a b)))))
+        ;; if car of argument contains a key+group list rather than a
+        ;; straight key, remove group list
+        ;; FIXME: the test for straight key, below, will fail if the key
+        ;;        is a list, and the first element of the key is itself a
+        ;;        list (there might be no easy way to fully fix this...)
+        (if (or (atom (car a))
+                (and (listp (car a)) (not (sequencep (caar a)))))
+            (setq a (car a))
+          (setq a (caar a)))
+        (if (or (atom (car b))
+                (and (listp (car b)) (not (sequencep (caar b)))))
+            (setq b (car b))
+          (setq b (caar b)))
+        (,sortfun a b)))))
 
 
 ;; return wrapped rankfun to deal with data wrapping and ignore fuzzy query
 ;; distance data. Note: works for both fuzzy-matching and fuzzy-completion.
-(dictree--if-lexical-binding
-    (defun dictree--wrap-fuzzy-rankfun (rankfun)  ; INTERNAL USE ONLY
-      (lambda (a b)
-       (funcall rankfun
-                (cons (car a) (dictree--cell-data (cdr a)))
-                (cons (car b) (dictree--cell-data (cdr b))))))
+(defun dictree--wrap-fuzzy-rankfun (rankfun)  ; INTERNAL USE ONLY
+  (lambda (a b)
+    (funcall rankfun
+            (cons (car a) (dictree--cell-data (cdr a)))
+            (cons (car b) (dictree--cell-data (cdr b))))))
+
+(dictree--if-lexical-binding nil
   (defun dictree--wrap-fuzzy-rankfun (rankfun)  ; INTERNAL USE ONLY
     `(lambda (a b)
        (,rankfun (cons (car a) (dictree--cell-data (cdr a)))
@@ -363,25 +368,27 @@ If START or END is negative, it counts from the end."
 
 
 ;; return wrapped sortfun to ignore fuzzy query distance data
-(dictree--if-lexical-binding
-    (defun dictree--wrap-fuzzy-sortfun (cmpfun &optional reverse)
-      (let ((sortfun (trie-construct-sortfun cmpfun reverse)))
-       (lambda (a b) (funcall sortfun (car a) (car b)))))
+(defun dictree--wrap-fuzzy-sortfun (cmpfun &optional reverse)
+  (let ((sortfun (trie-construct-sortfun cmpfun reverse)))
+    (lambda (a b) (funcall sortfun (car a) (car b)))))
+
+(dictree--if-lexical-binding nil
   (defun dictree--wrap-fuzzy-sortfun (cmpfun &optional reverse)
     (let ((sortfun (trie-construct-sortfun cmpfun reverse)))
       `(lambda (a b) (,sortfun (car a) (car b))))))
 
 
 ;; return wrapped combfun to deal with data wrapping
-(dictree--if-lexical-binding
-    (defun dictree--wrap-combfun (combfun)  ; INTERNAL USE ONLY
-      (lambda (cell1 cell2)
-       (dictree--cell-create
-        (funcall combfun
-                 (dictree--cell-data cell1)
-                 (dictree--cell-data cell2))
-        (append (dictree--cell-plist cell1)
-                (dictree--cell-plist cell2)))))
+(defun dictree--wrap-combfun (combfun)  ; INTERNAL USE ONLY
+  (lambda (cell1 cell2)
+    (dictree--cell-create
+     (funcall combfun
+             (dictree--cell-data cell1)
+             (dictree--cell-data cell2))
+     (append (dictree--cell-plist cell1)
+            (dictree--cell-plist cell2)))))
+
+(dictree--if-lexical-binding nil
   (defun dictree--wrap-combfun (combfun)  ; INTERNAL USE ONLY
     `(lambda (cell1 cell2)
        (dictree--cell-create
@@ -392,34 +399,37 @@ If START or END is negative, it counts from the end."
 
 
 ;; return wrapped filter function to deal with data wrapping
-(dictree--if-lexical-binding
-    (defun dictree--wrap-filter (filter)  ; INTERNAL USE ONLY
-      (lambda (key data) (funcall filter key (dictree--cell-data data))))
+(defun dictree--wrap-filter (filter)  ; INTERNAL USE ONLY
+  (lambda (key data) (funcall filter key (dictree--cell-data data))))
+
+(dictree--if-lexical-binding nil
   (defun dictree--wrap-filter (filter)  ; INTERNAL USE ONLY
     `(lambda (key data) (,filter key (dictree--cell-data data)))))
 
 
 ;; return wrapped result function to deal with data wrapping
-(dictree--if-lexical-binding
-    (defun dictree--wrap-resultfun (resultfun)  ; INTERNAL USE ONLY
-      (lambda (res)
-       (funcall resultfun (car res) (dictree--cell-data (cdr res)))))
+(defun dictree--wrap-resultfun (resultfun)  ; INTERNAL USE ONLY
+  (lambda (res)
+    (funcall resultfun (car res) (dictree--cell-data (cdr res)))))
+
+(dictree--if-lexical-binding nil
   (defun dictree--wrap-resultfun (resultfun)  ; INTERNAL USE ONLY
     `(lambda (res) (,resultfun (car res) (dictree--cell-data (cdr res))))))
 
 
 ;; construct lexicographic sort function from DICT's comparison function.
 ;; ACCESSOR is used to obtain the sort key, defaulting to `car'.
-;;(dictree--if-lexical-binding
 (defun dictree--construct-sortfun (comparison-function &optional accessor)  ; 
INTERNAL USE ONLY
   (unless accessor (setq accessor #'car))
   (let ((sortfun (trie-construct-sortfun comparison-function)))
     (lambda (a b)
       (funcall sortfun (funcall accessor a) (funcall accessor b)))))
-    ;; (defun dictree--construct-sortfun (dict &optional accessor)  ; INTERNAL 
USE ONLY
-    ;;   `(lambda (a b)
-    ;;          (,(trie-construct-sortfun (dictree-comparison-function dict))
-    ;;           (,accessor a) (,accessor b)))))
+
+(dictree--if-lexical-binding nil
+  (defun dictree--construct-sortfun (dict &optional accessor)  ; INTERNAL USE 
ONLY
+    `(lambda (a b)
+       (,(trie-construct-sortfun (dictree-comparison-function dict))
+       (,accessor a)   (,accessor b)))))
 
 
 
@@ -2093,19 +2103,20 @@ Interactively, DICT is read from the mini-buffer."
 
 ;; Wrap SORTFUN, which sorts keys, so it can act on dictree--meta-stack
 ;; elements.
-(dictree--if-lexical-binding
-    (defun dictree--construct-meta-stack-heapfun (sortfun &optional reverse)
-      (if reverse
-         (lambda (b a) (funcall sortfun (car (dictree-stack-first a))
-                                (car (dictree-stack-first b))))
-       (lambda (a b) (funcall sortfun (car (dictree-stack-first a))
-                              (car (dictree-stack-first b))))))
+(defun dictree--construct-meta-stack-heapfun (sortfun &optional reverse)
+  (if reverse
+      (lambda (b a) (funcall sortfun (car (dictree-stack-first a))
+                            (car (dictree-stack-first b))))
+    (lambda (a b) (funcall sortfun (car (dictree-stack-first a))
+                          (car (dictree-stack-first b))))))
+
+(dictree--if-lexical-binding nil
   (defun dictree--construct-meta-stack-heapfun (sortfun &optional reverse)
     (if reverse
-       `(lambda (b a) (,sortfun (car (dictree-stack-first a))
-                                (car (dictree-stack-first b))))
+       `(lambda (b a) (,sortfun (car (dictree-stack-first a))
+                                (car (dictree-stack-first b))))
       `(lambda (a b) (,sortfun (car (dictree-stack-first a))
-                              (car (dictree-stack-first b)))))))
+                              (car (dictree-stack-first b)))))))
 
 
 (defun* dictree-stack (dict &key type reverse pfxfilter)