[elpa] externals/trie 18dc856 084/111: Don't wrap rank and filter functions for regexp and fuzzy queries.

[Stefan Monnier]

branch: externals/trie
commit 18dc856d8c3a244f71e31e31ce021feddb0030d9
Author: Toby S. Cubitt <toby-predictive@dr-qubit.org>
Commit: Toby S. Cubitt <toby-predictive@dr-qubit.org>

    Don't wrap rank and filter functions for regexp and fuzzy queries.
    
    Otherwise, wrapped user-supplied filter and rank functions will not work for
    trie stacks, so will throw errors when used on meta-dicts.
---
 trie.el | 161 +++++++++++++++++++++-------------------------------------------
 1 file changed, 53 insertions(+), 108 deletions(-)

diff --git a/trie.el b/trie.el
index 1bccf46..dd310ca 100644
--- a/trie.el
+++ b/trie.el
@@ -272,71 +272,6 @@
                (,comparison-function b a))))))
 
 
-;; massage rankfun arguments for `trie-regexp-search' results
-(if (trie-lexical-binding-p)
-    (defun trie--wrap-regexp-search-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...)
-       (unless (or (atom (car a))
-                   (and (listp (car a))
-                        (not (sequencep (caar a)))))
-         (setq a (cons (caar a) (cdr a))))
-       (unless (or (atom (car b))
-                   (and (listp (car b))
-                        (not (sequencep (caar b)))))
-         (setq b (cons (caar b) (cdr b))))
-       (funcall rankfun a b)))
-  (defun trie--wrap-regexp-search-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...)
-       (unless (or (atom (car a))
-                  (and (listp (car a))
-                      (not (sequencep (caar a)))))
-        (setq a (cons (caar a) (cdr a))))
-       (unless (or (atom (car b))
-                  (and (listp (car b))
-                       (not (sequencep (caar b)))))
-        (setq b (cons (caar b) (cdr b))))
-       (,rankfun a b))))
-
-
-(if (trie-lexical-binding-p)
-    (defun trie--wrap-regexp-search-filter (filter)
-      (lambda (seq data)
-       ;; 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...)
-       (unless (or (atom (car seq))
-                   (and (listp (car seq))
-                        (not (sequencep (caar seq)))))
-         (setq seq (caar seq))
-         ;; call filter on massaged arguments
-         (funcall filter seq data))))
-  (defun trie--wrap-regexp-search-filter (filter)
-    `(lambda (seq data)
-       ;; 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...)
-       (unless (or (atom (car seq))
-                  (and (listp (car seq))
-                       (not (sequencep (caar seq)))))
-        (setq seq (caar seq))
-        ;; call filter on massaged arguments
-        (,filter seq data)))))
-
-
 ;; create Lewenstein rank function from trie comparison function
 (if (trie-lexical-binding-p)
     (defun trie--construct-Lewenstein-rankfun (comparison-function)
@@ -1702,40 +1637,51 @@ beginning and end of the regexp to get an unanchored 
match).
 
 If the regexp contains any non-shy grouping constructs, subgroup
 match data is included in the results. In this case, the car of
-each match is no longer just a key. Instead, it is a list whose
-first element is the matching key, and whose remaining elements
-are cons cells whose cars and cdrs give the start and end indices
+each match is no longer just a key. Instead, each element of the
+results list has the form
+
+    ((KEY (START1 . END1) (START2 . END2) ...) . DATA)
+
+where the (START . END) cons cells give the start and end indices
 of the elements that matched the corresponding groups, in order.
 
+
 The optional integer argument MAXNUM limits the results to the
 first MAXNUM matches. Otherwise, all matches are returned.
 
-If specified, RANKFUN must accept two arguments, both cons
-cells. The car contains a sequence from the trie (of the same
-type as REGEXP), the cdr contains its associated data. It should
-return non-nil if first argument is ranked strictly higher than
-the second, nil otherwise.
+
+If specified, RANKFUN must accept two arguments. If the regexp
+does not contain any non-shy grouping constructs, both arguments
+are (KEY . DATA) cons cells, where the car is a sequence of the
+same type as REGEXP. If the regexp does contain non-shy grouping
+constructs, both arguments are of the form
+
+    ((KEY (START1 . END1) (START2 . END2) ...) . DATA)
+
+RANKFUN should return non-nil if first argument is ranked
+strictly higher than the second, nil otherwise.
+
 
 The FILTER argument sets a filter function for the matches. If
 supplied, it is called for each possible match with two
-arguments: the matching key, and its associated data. If the
-filter function returns nil, the match is not included in the
-results, and does not count towards MAXNUM.
+arguments: a key and its associated data. If the regexp contains
+non-shy grouping constructs, the first argument is of the form
+
+    (KEY (START1 . END1) (START2 . END2) ...)
+
+If the FILTER function returns nil, the match is not included in
+the results, and does not count towards MAXNUM.
+
 
 RESULTFUN defines a function used to process results before
 adding them to the final result list. If specified, it should
-accept two arguments: a key and its associated data. Its return
-value is what gets added to the final result list, instead of the
-default key-data cons cell."
+accept two arguments, of the same form as those for FILTER (see
+above). Its return value is what gets added to the final result
+list, instead of the default key-data cons cell."
 
   ;; convert trie from print-form if necessary
   (trie-transform-from-read-warn trie)
 
-  ;; FIXME: could skip this if REGEXP contains no grouping constructs
-  ;; massage rankfun and filter to cope with grouping data
-  (when rankfun (setq rankfun (trie--wrap-regexp-search-rankfun rankfun)))
-  (when filter (setq filter (trie--wrap-regexp-search-filter filter)))
-
   ;; accumulate results
   (trie--accumulate-results
    rankfun maxnum reverse filter resultfun accumulator nil
@@ -1840,7 +1786,7 @@ default key-data cons cell."
 
 
 
-(defun trie-regexp-stack  (trie regexp &optional reverse)
+(defun trie-regexp-stack (trie regexp &optional reverse)
   "Return an object that allows matches to REGEXP to be accessed
 as if they were a stack.
 
@@ -2078,13 +2024,10 @@ list will be sequences of the same type as STRING.
 DISTANCE must be a positive integer. (Note that DISTANCE=0 will
 not give meaningful results; use `trie-member' instead.)
 
-The optional integer argument MAXNUM limits the results to the
-first MAXNUM matches. Otherwise, all matches are returned.
 
-RANKFUN overrides the default ordering of the results. If it is
-`t', matches are instead ordered by increasing Lewenstein
-distance \(with same-distance matches ordered
-lexicographically\).
+RANKFUN overrides the default ordering of the results. If it is t,
+matches are instead ordered by increasing Lewenstein distance
+\(with same-distance matches ordered lexicographically\).
 
 If RANKFUN is a function, it must accept two arguments, both of
 the form:
@@ -2096,15 +2039,19 @@ distances from STRING, and DATA is its associated data. 
RANKFUN
 should return non-nil if first argument is ranked strictly higher
 than the second, nil otherwise.
 
+
+The optional integer argument MAXNUM limits the results to the
+first MAXNUM matches. Otherwise, all matches are returned.
+
 The FILTER argument sets a filter function for the matches. If
-supplied, it is called for each possible match with three
-arguments: KEY, DIST and DATA. If the filter function returns
-nil, the match is not included in the results, and does not count
-towards MAXNUM.
+supplied, it is called for each possible match with two
+arguments: a (KEY . DIST) cons cell, and DATA. If the filter
+function returns nil, the match is not included in the results,
+and does not count towards MAXNUM.
 
 RESULTFUN defines a function used to process results before
 adding them to the final result list. If specified, it should
-accept two arguments: a (KEY . DIST) cons cell and DATA. Its
+accept two arguments: a (KEY . DIST) cons cell, and DATA. Its
 return value is what gets added to the final result list, instead
 of the default key-dist-data list."
 
@@ -2115,8 +2062,6 @@ of the default key-dist-data list."
   (when (eq rankfun t)
     (setq rankfun (trie--construct-Lewenstein-rankfun
                   (trie--comparison-function trie))))
-  ;; massage filter function arguments
-  (when filter (setq filter (trie--wrap-fuzzy-filter filter)))
 
   ;; accumulate results
   (trie--accumulate-results
@@ -2306,7 +2251,7 @@ Returns a list of completions, with elements of the form:
 where KEY is a matching completion from the trie, DATA its
 associated data, PFXLEN is the length of the prefix part of KEY,
 and DIST is its Lewenstein distance \(edit distance\) from
-STRING.
+PREFIX.
 
 PREFIX is a sequence (vector, list or string), whose elements are
 of the same type as elements of the trie keys. If PREFIX is a
@@ -2320,9 +2265,10 @@ not give meaningful results; use `trie-complete' 
instead.)
 The optional integer argument MAXNUM limits the results to the
 first MAXNUM matches. Otherwise, all matches are returned.
 
-RANKFUN overrides the default ordering of the results. If it is
-`t', matches are instead ordered by increasing Lewenstein
-distance of their prefix \(with same-distance matches ordered
+
+RANKFUN overrides the default ordering of the results. If it is t,
+matches are instead ordered by increasing Lewenstein distance of
+their prefix \(with same-distance prefixes ordered
 lexicographically\).
 
 If RANKFUN is a function, it must accept two arguments, both of
@@ -2335,11 +2281,12 @@ distances from PREFIX, and DATA is its associated data. 
RANKFUN
 should return non-nil if first argument is ranked strictly higher
 than the second, nil otherwise.
 
+
 The FILTER argument sets a filter function for the matches. If
-supplied, it is called for each possible match with four
-arguments: KEY, DIST, PFXLEN and DATA. If the filter function
-returns nil, the match is not included in the results, and does
-not count towards MAXNUM.
+supplied, it is called for each possible match with two
+arguments: a (KEY DIST PFXLEN) list, and DATA. If the filter
+function returns nil, the match is not included in the results,
+and does not count towards MAXNUM.
 
 RESULTFUN defines a function used to process results before
 adding them to the final result list. If specified, it should
@@ -2354,8 +2301,6 @@ of the default key-dist-data list."
   (when (eq rankfun t)
     (setq rankfun (trie--construct-Lewenstein-rankfun
                   (trie--comparison-function trie))))
-  ;; massage filter function arguments
-  (when filter (setq filter (trie--wrap-fuzzy-filter filter)))
 
   ;; accumulate results
   (trie--accumulate-results