[elpa] externals/dict-tree 3ddde93 143/154: Switch to keyword arguments for trie/dictree query functions.

[Stefan Monnier]

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

    Switch to keyword arguments for trie/dictree query functions.
    
    Allow pfxfilter in dict-tree queries.
---
 dict-tree.el | 396 +++++++++++++++++++++++++++++++++++------------------------
 1 file changed, 238 insertions(+), 158 deletions(-)

diff --git a/dict-tree.el b/dict-tree.el
index f53eae1..0a366fe 100644
--- a/dict-tree.el
+++ b/dict-tree.el
@@ -90,6 +90,7 @@
 ;;; Code:
 
 (eval-when-compile (require 'cl))
+(require 'cl-lib)
 (require 'trie)
 (require 'tNFA)
 
@@ -1240,6 +1241,15 @@ PREFIX is a prefix of STR."
                   (equal pfx (dictree--subseq str 0 len)))
          (throw 'is-prefix t))))))
 
+(defun dictree--filter-prefix (prefix pfxfilter)
+  "Return non-nil if all prefixes of PREFIX pass PFXFILTER.
+Otherwise, return nil."
+  (catch 'failed
+    (dotimes (i (length prefix))
+      (unless (funcall pfxfilter (cl-subseq prefix 0 i))
+       (throw 'failed nil)))
+    t))
+
 
 (defun dictree--above-cache-threshold-p
   (time length policy threshold &optional cache-long-keys)
@@ -1296,10 +1306,10 @@ PREFIX is a prefix of STR."
                  dictree--prefix-p)
                 (dictree-regexp-cache
                  dictree--synchronize-regexp-cache
-                 (lambda (arg key)
+                 (lambda (regexp key)
                    (tNFA-regexp-match
-                    arg key :test (trie--construct-equality-function
-                                   (dictree--comparison-function dict)))))
+                    regexp key :test (trie--construct-equality-function
+                                      (dictree--comparison-function dict)))))
                 (dictree-fuzzy-match-cache
                  dictree--synchronize-fuzzy-match-cache
                  (lambda (string dist key)
@@ -1318,30 +1328,30 @@ PREFIX is a prefix of STR."
        (when (funcall (nth 0 cachefuns) dict)
          (maphash
           (lambda (cache-key cache-entry)
-            (destructuring-bind
-                (arg auxargs rank-function reverse filter) cache-key
-              (when (apply (nth 2 cachefuns)
-                           (append (list arg) auxargs (list key)))
+            (destructuring-bind (args rank-function reverse filter pfxfilter)
+                cache-key
+              (when (apply (nth 2 cachefuns) (append args (list key)))
                 (cond
                  ;; updating dirty cache entries
                  ((eq (dictree-cache-update-policy dict) 'synchronize)
                   (funcall (nth 1 cachefuns)
-                           dict key olddata newdata deleted cache-entry
-                           arg auxargs rank-function reverse filter))
+                           dict key olddata newdata deleted cache-entry args
+                           :reverse reverse :rank-function rank-function
+                           :filter filter :pfxfilter pfxfilter))
                  ;; deleting dirty cache entries
-                 (t (remhash (list arg auxargs rank-function reverse filter)
+                 (t (remhash (list args rank-function reverse filter pfxfilter)
                              (funcall (nth 0 cachefuns) dict)))))))
           (funcall (nth 0 cachefuns) dict)))
        ))))
 
 
 
-(defun dictree--synchronize-completion-cache
-    (dict key olddata newdata deleted cache-entry
-         arg auxargs rank-function reverse filter)
-  ;; Synchronize DICT's completion CACHE-ENTRY for a query with arguments ARG,
-  ;; AUXARGS, RANK-FUNCTION, REVERSE and FILTER, where KEY's data was either
-  ;; updated from OLDDATA to NEWDATA or DELETED,
+(defun* dictree--synchronize-completion-cache
+    (dict key olddata newdata deleted cache-entry args
+         &key reverse rank-function filter pfxfilter)
+  ;; Synchronize DICT's completion CACHE-ENTRY for a query with arguments
+  ;; ARGS, RANK-FUNCTION, REVERSE, FILTER and PFXFILTER, where KEY's data was
+  ;; either updated from OLDDATA to NEWDATA or DELETED,
 
   (let* ((completions (dictree--cache-results cache-entry))
         (maxnum (dictree--cache-maxnum cache-entry))
@@ -1354,18 +1364,24 @@ PREFIX is a prefix of STR."
     ;; for meta-dict, get old data from cache instead of OLDDATA
     (when (dictree--meta-dict-p dict) (setq olddata (cdr cmpl)))
     ;; skip cache update if key/data pair doesn't pass FILTER
-    (when (or (null filter)
-             (funcall filter key olddata)
-             (funcall filter key newdata))
+    (when (and (or (null filter)
+                  (funcall filter key olddata)
+                  (funcall filter key newdata))
+              (or (null pfxfilter)
+                  (dictree--filter-prefix (cl-subseq key (length (car args)))
+                                          pfxfilter)))
       ;; if key was...
       (cond
 
        ;; deleted and in cached result: remove cache entry and re-run the
        ;; same completion to update the cache
        ((and deleted cmpl)
-       (remhash (list arg auxargs rank-function reverse filter)
+       (remhash (list args rank-function reverse filter pfxfilter)
                 (dictree-complete-cache dict))
-       (dictree-complete dict arg rank-function maxnum reverse filter))
+       (dictree-complete dict (car args)
+                         :maxnum maxnum :reverse reverse
+                         :rank-function rank-function
+                         :filter filter :pfxfilter pfxfilter))
 
        ;; modified and not in cached result: merge it into the completion
        ;; list, retaining only the first maxnum
@@ -1390,19 +1406,22 @@ PREFIX is a prefix of STR."
                             (sort completions rankfun))
                       (equal key (car (last (dictree--cache-results
                                              cache-entry))))))
-         (remhash (list arg auxargs rank-function reverse filter)
+         (remhash (list args rank-function reverse filter pfxfilter)
                   (dictree-complete-cache dict))
-         (dictree-complete dict arg rank-function maxnum reverse filter)))
+         (dictree-complete dict (car args)
+                           :maxnum maxnum :reverse reverse
+                           :rank-function rank-function
+                           :filter filter :pfxfilter pfxfilter)))
 
        ;; deleted and not in cached result: requires no action
        ))))
 
 
-(defun dictree--synchronize-regexp-cache
-    (dict key olddata newdata deleted cache-entry
-         arg auxargs rank-function reverse filter)
-  ;; Synchronize DICT's regexp CACHE-ENTRY for a query with arguments ARG,
-  ;; AUXARGS, RANK-FUNCTION, REVERSE and FILTER, where KEY's data was either
+(defun* dictree--synchronize-regexp-cache
+    (dict key olddata newdata deleted cache-entry args
+         &key reverse rank-function filter pfxfilter)
+  ;; Synchronize DICT's regexp CACHE-ENTRY for a query with arguments ARGS
+  ;; RANK-FUNCTION, REVERSE, FILTER and PFXFILTER, where KEY's data was either
   ;; updated from OLDDATA to NEWDATA or DELETED,
 
   (let* ((completions (dictree--cache-results cache-entry))
@@ -1424,18 +1443,23 @@ PREFIX is a prefix of STR."
     ;; for meta-dict, get old data from cache instead of OLDDATA
     (when (dictree--meta-dict-p dict) (setq olddata (cdr cmpl)))
     ;; skip cache update if key/data pair doesn't pass FILTER
-    (when (or (null filter)
-             (funcall filter key olddata)
-             (funcall filter key newdata))
+    (when (and (or (null filter)
+                  (funcall filter key olddata)
+                  (funcall filter key newdata))
+              (or (null pfxfilter)
+                  (dictree--filter-prefix key pfxfilter)))
       ;; if key was...
       (cond
 
        ;; deleted and in cached result: remove cache entry and re-run the
        ;; same completion to update the cache
        ((and deleted cmpl)
-       (remhash (list arg auxargs rank-function reverse filter)
+       (remhash (list args rank-function reverse filter pfxfilter)
                 (dictree-regexp-cache dict))
-       (dictree-regexp-search dict arg rank-function maxnum reverse filter))
+       (dictree-regexp-search dict (car args)
+                              :maxnum maxnum :reverse reverse
+                              :rank-function rank-function
+                              :filter filter :pfxfilter pfxfilter))
 
        ;; modified and not in cached result: merge it into the completion
        ;; list, retaining only the first maxnum
@@ -1443,7 +1467,7 @@ PREFIX is a prefix of STR."
        (when (or (null filter) (funcall filter key newdata))
          (save-match-data
            (set-match-data nil)
-           (tNFA-regexp-match arg key
+           (tNFA-regexp-match (car args) key
                               :test (trie--construct-equality-function
                                      (dictree--comparison-function dict)))
            (when (setq group-data (nthcdr 2 (match-data)))
@@ -1467,20 +1491,22 @@ PREFIX is a prefix of STR."
                             (sort completions rankfun))
                       (equal key (car (last (dictree--cache-results
                                              cache-entry))))))
-         (remhash (list arg auxargs rank-function reverse filter)
+         (remhash (list args rank-function reverse filter pfxfilter)
                   (dictree-regexp-cache dict))
-         (dictree-regexp-search dict arg rank-function maxnum reverse filter)
-         ))
+         (dictree-regexp-search dict (car args)
+                                :maxnum maxnum :reverse reverse
+                                :rank-function rank-function
+                                :filter filter :pfxfilter pfxfilter)))
 
        ;; deleted and not in cached result: requires no action
        ))))
 
 
-(defun dictree--synchronize-fuzzy-match-cache
-    (dict key olddata newdata deleted cache-entry
-         arg auxargs rank-function reverse filter)
+(defun* dictree--synchronize-fuzzy-match-cache
+    (dict key olddata newdata deleted cache-entry args
+         &key reverse rank-function filter pfxfilter)
   ;; Synchronize DICT's fuzzy match CACHE-ENTRY for a query with arguments
-  ;; ARG, AUXARGS, RANK-FUNCTION, REVERSE and FILTER, where KEY's data was
+  ;; ARGS, RANK-FUNCTION, REVERSE, FILTER and PFXFILTER, where KEY's data was
   ;; either updated from OLDDATA to NEWDATA or DELETED,
 
   (let* ((completions (dictree--cache-results cache-entry))
@@ -1488,25 +1514,29 @@ PREFIX is a prefix of STR."
         (cmpl (catch 'found
                 (dolist (c completions)
                   (when (equal key (caar c)) (throw 'found c)))))
-        (distance (Lewenstein-distance arg key))
+        (distance (Lewenstein-distance (car args) key))
         (rankfun (dictree--construct-fuzzy-match-rankfun
                   rank-function dict)))
     ;; for meta-dict, get old data from cache instead of OLDDATA
     (when (dictree--meta-dict-p dict) (setq olddata (cdr cmpl)))
     ;; skip cache update if key/data pair doesn't pass FILTER
-    (when (or (null filter)
-             (funcall filter key olddata)
-             (funcall filter key newdata))
+    (when (and (or (null filter)
+                  (funcall filter key olddata)
+                  (funcall filter key newdata))
+              (or (null pfxfilter)
+                  (dictree--filter-prefix key pfxfilter)))
       ;; if key was...
       (cond
 
        ;; deleted and in cached result: remove cache entry and re-run the
        ;; same completion to update the cache
        ((and deleted cmpl)
-       (remhash (list arg auxargs rank-function reverse filter)
+       (remhash (list args rank-function reverse filter pfxfilter)
                 (dictree-fuzzy-match-cache dict))
-       (dictree-fuzzy-match dict arg (car auxargs)
-                            rank-function maxnum reverse filter))
+       (dictree-fuzzy-match dict (car args) (nth 1 args)
+                            :maxnum maxnum :reverse reverse
+                            :rank-function rank-function
+                            :filter filter :pfxfilter pfxfilter))
 
        ;; modified and not in cached result: merge it into the completion
        ;; list, retaining only the first maxnum
@@ -1531,18 +1561,20 @@ PREFIX is a prefix of STR."
                             (sort completions rankfun))
                       (equal key (car (last (dictree--cache-results
                                              cache-entry))))))
-         (remhash (list arg auxargs rank-function reverse filter)
+         (remhash (list args rank-function reverse filter pfxfilter)
                   (dictree-fuzzy-match-cache dict))
-         (dictree-fuzzy-match dict arg (car auxargs)
-                              rank-function maxnum reverse filter)))
+         (dictree-fuzzy-match dict (car args) (nth 1 args)
+                              :maxnum maxnum :reverse reverse
+                              :rank-function rank-function
+                              :filter filter :pfxfilter pfxfilter)))
 
        ;; deleted and not in cached result: requires no action
        ))))
 
 
-(defun dictree--synchronize-fuzzy-complete-cache
-    (dict key olddata newdata deleted cache-entry
-         arg auxargs rank-function reverse filter)
+(defun* dictree--synchronize-fuzzy-complete-cache
+    (dict key olddata newdata deleted cache-entry args
+         &key rank-function reverse filter pfxfilter)
   ;; Synchronize DICT's fuzzy completion CACHE-ENTRY for a query with
   ;; arguments ARG, AUXARGS, RANK-FUNCTION, REVERSE and FILTER, where KEY's
   ;; data was either updated from OLDDATA to NEWDATA or DELETED,
@@ -1552,7 +1584,7 @@ PREFIX is a prefix of STR."
         (cmpl (catch 'found
                 (dolist (c completions)
                   (when (equal key (caar c)) (throw 'found c)))))
-        (distance (Lewenstein-prefix-distance arg key))
+        (distance (Lewenstein-prefix-distance (car args) key))
         (pfxlen (cdr distance))
         (distance (car distance))
         (rankfun (dictree--construct-fuzzy-complete-rankfun
@@ -1560,19 +1592,23 @@ PREFIX is a prefix of STR."
     ;; for meta-dict, get old data from cache instead of OLDDATA
     (when (dictree--meta-dict-p dict) (setq olddata (cdr cmpl)))
     ;; skip cache update if key/data pair doesn't pass FILTER
-    (when (or (null filter)
-             (funcall filter key olddata)
-             (funcall filter key newdata))
+    (when (and (or (null filter)
+                  (funcall filter key olddata)
+                  (funcall filter key newdata))
+              (or (null pfxfilter)
+                  (dictree--filter-prefix key pfxfilter)))
       ;; if key was...
       (cond
 
        ;; deleted and in cached result: remove cache entry and re-run the
        ;; same completion to update the cache
        ((and deleted cmpl)
-       (remhash (list arg auxargs rank-function reverse filter)
+       (remhash (list args rank-function reverse filter pfxfilter)
                 (dictree-fuzzy-complete-cache dict))
-       (dictree-fuzzy-complete dict arg (car auxargs)
-                               rank-function maxnum reverse filter))
+       (dictree-fuzzy-complete dict (car args) (nth 1 args)
+                               :maxnum maxnum :reverse reverse
+                               :rank-function rank-function
+                               :filter filter :pfxfilter pfxfilter))
 
        ;; modified and not in cached result: merge it into the completion
        ;; list, retaining only the first maxnum
@@ -1598,10 +1634,12 @@ PREFIX is a prefix of STR."
                             (sort completions rankfun))
                       (equal key (car (last (dictree--cache-results
                                              cache-entry))))))
-         (remhash (list arg auxargs rank-function reverse filter)
+         (remhash (list args rank-function reverse filter pfxfilter)
                   (dictree-fuzzy-complete-cache dict))
-         (dictree-fuzzy-complete dict arg (car auxargs)
-                                 rank-function maxnum reverse filter)))
+         (dictree-fuzzy-complete dict (car args) (nth 1 args)
+                                 :maxnum maxnum :reverse reverse
+                                 :rank-function rank-function
+                                 :filter filter :pfxfilter pfxfilter)))
 
        ;; deleted and not in cached result: requires no action
        ))))
@@ -2070,7 +2108,7 @@ Interactively, DICT is read from the mini-buffer."
                               (car (dictree-stack-first b)))))))
 
 
-(defun dictree-stack (dict &optional type reverse)
+(defun* dictree-stack (dict &key type reverse pfxfilter)
   "Create an object that allows DICT to be accessed as a stack.
 
 The stack is sorted in \"lexicographic\" order, i.e. the order
@@ -2093,11 +2131,13 @@ cases where mapping functions `dictree-mapc', 
`dictree-mapcar' or
 `dictree-mapf' would be sufficient, it is better to use one of
 those instead."
   (if (dictree--meta-dict-p dict)
-      (dictree--meta-stack-create dict type reverse)
-    (trie-stack (dictree--trie dict) type reverse)))
+      (dictree--meta-stack-create
+       dict :type type :reverse reverse :pfxfilter pfxfilter)
+    (trie-stack (dictree--trie dict)
+               :type type :reverse reverse :pfxfilter pfxfilter)))
 
 
-(defun dictree-complete-stack (dict prefix &optional reverse)
+(defun* dictree-complete-stack (dict prefix &key reverse pfxfilter)
   "Return an object that allows completions of PREFIX to be accessed
 as if they were a stack.
 
@@ -2125,11 +2165,13 @@ in implementing efficient algorithms on dict-trees. 
However, in
 cases where `dictree-complete' is sufficient, it is better to use
 that instead."
   (if (dictree--meta-dict-p dict)
-      (dictree--complete-meta-stack-create dict prefix reverse)
-    (trie-complete-stack (dictree--trie dict) prefix reverse)))
+      (dictree--complete-meta-stack-create
+       dict prefix :reverse reverse :pfxfilter pfxfilter)
+    (trie-complete-stack (dictree--trie dict) prefix
+                        :reverse reverse :pfxfilter pfxfilter)))
 
 
-(defun dictree-regexp-stack (dict regexp &optional reverse)
+(defun* dictree-regexp-stack (dict regexp &key reverse pfxfilter)
   "Return an object that allows REGEXP matches to be accessed
 as if they were a stack.
 
@@ -2169,11 +2211,14 @@ in implementing efficient algorithms on dict-trees. 
However, in
 cases where `dictree-regexp-search' is sufficient, it is better
 to use that instead."
   (if (dictree--meta-dict-p dict)
-      (dictree--regexp-meta-stack-create dict regexp reverse)
-    (trie-regexp-stack (dictree--trie dict) regexp reverse)))
+      (dictree--regexp-meta-stack-create
+       dict regexp :reverse reverse :pfxfilter pfxfilter)
+    (trie-regexp-stack (dictree--trie dict) regexp
+                      :reverse reverse :pfxfilter pfxfilter)))
 
 
-(defun dictree-fuzzy-match-stack (dict string distance &optional reverse)
+(defun* dictree-fuzzy-match-stack (dict string distance
+                                       &key reverse pfxfilter)
   "Return an object that allows fuzzy matches to be accessed
 as if they were a stack.
 
@@ -2202,11 +2247,14 @@ they can be useful in implementing efficient algorithms 
on
 dict-trees. However, in cases where `dictree-fuzzy-match' is
 sufficient, it is better to use that instead."
   (if (dictree--meta-dict-p dict)
-      (dictree--fuzzy-match-meta-stack-create dict string distance reverse)
-    (trie-fuzzy-match-stack (dictree--trie dict) string distance reverse)))
+      (dictree--fuzzy-match-meta-stack-create
+       dict string distance :reverse reverse :pfxfilter pfxfilter)
+    (trie-fuzzy-match-stack (dictree--trie dict) string distance
+                           :reverse reverse :pfxfilter pfxfilter)))
 
 
-(defun dictree-fuzzy-complete-stack (dict prefix distance &optional reverse)
+(defun* dictree-fuzzy-complete-stack (dict prefix distance
+                                          &key reverse pfxfilter)
   "Return an object that allows fuzzy completions to be accessed
 as if they were a stack.
 
@@ -2236,8 +2284,10 @@ they can be useful in implementing efficient algorithms 
on
 dict-trees. However, in cases where `dictree-fuzzy-complete' is
 sufficient, it is better to use that instead."
   (if (dictree--meta-dict-p dict)
-      (dictree--fuzzy-complete-meta-stack-create dict prefix distance reverse)
-    (trie-fuzzy-complete-stack (dictree--trie dict) prefix distance reverse)))
+      (dictree--fuzzy-complete-meta-stack-create
+       dict prefix distance :reverse reverse :pfxfilter pfxfilter)
+    (trie-fuzzy-complete-stack (dictree--trie dict) prefix distance
+                              :reverse reverse :pfxfilter pfxfilter)))
 
 
 (defun dictree-stack-pop (dictree-stack)
@@ -2365,7 +2415,7 @@ Returns nil if the stack is empty."
 ;; generators in terms of dictree-stacks.
 
 (heap--when-generators
- (iter-defun dictree-iter (dict &optional type reverse)
+ (cl-iter-defun dictree-iter (dict &key type reverse pfxfilter)
    "Return a dictree iterator object.
 
 Calling `iter-next' on this object will retrieve the next
@@ -2382,13 +2432,15 @@ iterators created from DICT before the modification (in
 particular, calling `iter-next' will give unpredictable
 results). If DICT is a meta-dict, this includes any modifications
 to its constituent dicts."
-   (let ((stack (dictree-stack dict type reverse)))
+   (let ((stack (dictree-stack dict :type type :reverse reverse
+                              :pfxfilter pfxfilter)))
      (while (not (dictree-stack-empty-p stack))
        (iter-yield (dictree-stack-pop stack))))))
 
 
 (heap--when-generators
- (iter-defun dictree-complete-iter (dict prefix &optional reverse)
+ (cl-iter-defun dictree-complete-iter (dict prefix
+                                           &key reverse pfxfilter)
    "Return an iterator object for completions of PREFIX in DICT.
 
 Calling `iter-next' on this object will retrieve the next
@@ -2416,7 +2468,8 @@ to its constituent dicts."
 
 
 (heap--when-generators
- (iter-defun dictree-regexp-iter (dict regexp &optional reverse)
+ (cl-iter-defun dictree-regexp-iter (dict regexp
+                                         &key reverse pfxfilter)
    "Return an iterator object for REGEXP matches in DICT.
 
 Calling `iter-next' on this object will retrieve the next match
@@ -2449,12 +2502,15 @@ iterators created from DICT before the modification (in
 particular, calling `iter-next' will give unpredictable
 results). If DICT is a meta-dict, this includes any modifications
 to its constituent dicts."
-   (let ((stack (dictree-regexp-stack dict regexp reverse)))
+   (let ((stack (dictree-regexp-stack dict regexp
+                                     :reverse reverse
+                                     :pfxfilter pfxfilter)))
      (while (not (dictree-stack-empty-p stack))
        (iter-yield (dictree-stack-pop stack))))))
 
 (heap--when-generators
- (iter-defun dictree-fuzzy-match-iter (dict string distance &optional reverse)
+ (cl-iter-defun dictree-fuzzy-match-iter (dict string distance
+                                              &key reverse pfxfilter)
    "Return an iterator object for fuzzy matches to STRING in DICT.
 
 Calling `iter-next' on this object will retrieve the next match
@@ -2476,13 +2532,16 @@ iterators created from DICT before the modification (in
 particular, calling `iter-next' will give unpredictable
 results). If DICT is a meta-dict, this includes any modifications
 to its constituent dicts."
-   (let ((stack (dictree-fuzzy-match-stack dict string distance reverse)))
+   (let ((stack (dictree-fuzzy-match-stack dict string distance
+                                          :reverse reverse
+                                          :pfxfilter pfxfilter)))
      (while (not (dictree-stack-empty-p stack))
        (iter-yield (dictree-stack-pop stack))))))
 
 
 (heap--when-generators
- (iter-defun dictree-fuzzy-complete-iter (dict prefix distance &optional 
reverse)
+ (cl-iter-defun dictree-fuzzy-complete-iter (dict prefix distance
+                                                 &key reverse pfxfilter)
    "Return an iterator object for fuzzy completions of PREFIX in DICT.
 
 Calling `iter-next' on this object will retrieve the next fuzzy
@@ -2506,7 +2565,9 @@ iterators created from DICT before the modification (in
 particular, calling `iter-next' will give unpredictable
 results). If DICT is a meta-dict, this includes any modifications
 to its constituent dicts."
-   (let ((stack (dictree-fuzzy-complete-stack dict prefix distance reverse)))
+   (let ((stack (dictree-fuzzy-complete-stack dict prefix distance
+                                             :reverse reverse
+                                             :pfxfilter pfxfilter)))
      (while (not (dictree-stack-empty-p stack))
        (iter-yield (dictree-stack-pop stack))))))
 
@@ -2516,10 +2577,10 @@ to its constituent dicts."
 ;; ----------------------------------------------------------------
 ;;             Functions for building advanced queries
 
-(defun dictree--query
-    (dict triefun stackfun cachefun cachecreatefun cache-long no-cache arg
-     &optional auxargs rank-function rankfun maxnum reverse filter resultfun
-     stack-rankfun)
+(defun* dictree--query
+    (dict triefun stackfun cachefun cachecreatefun cache-long no-cache args
+         &key maxnum reverse rank-function rankfun stack-rankfun
+         filter pfxfilter resultfun)
   ;; Return results of querying DICT with argument ARG (and AUXARGS list, if
   ;; any) using TRIEFUN or STACKFUN. If DICT's cache-threshold is non-nil,
   ;; look first for cached result in cache returned by calling CACHEFUN on
@@ -2548,9 +2609,10 @@ to its constituent dicts."
                        (symbolp (car rank-function))
                        (symbolp (cdr rank-function))))
               (symbolp filter)
+              (symbolp pfxfilter)
               (setq cache (funcall cachefun dic))
               (setq cache-entry
-                    (gethash (list arg auxargs rank-function reverse filter)
+                    (gethash (list args rank-function reverse filter pfxfilter)
                              cache))
               (or (null (dictree--cache-maxnum cache-entry))
                   (and maxnum
@@ -2560,14 +2622,14 @@ to its constituent dicts."
          (when (and maxnum
                     (or (null (dictree--cache-maxnum cache-entry))
                         (> (dictree--cache-maxnum cache-entry) maxnum)))
-           (setq res (setcdr (nthcdr (1- maxnum) res) nil)))
+           (setq res (cl-subseq res 0 maxnum)))
 
        ;; if there was nothing useful in the cache, do query and time it
        (let ((time (float-time)))
          (setq res
                (dictree--do-query
-                dic triefun stackfun arg auxargs rankfun maxnum reverse
-                (when filter (dictree--wrap-filter filter))
+                dic triefun stackfun args rankfun maxnum reverse
+                (when filter (dictree--wrap-filter filter)) pfxfilter
                 stack-rankfun))
          (setq time (- (float-time) time))
          ;; if we're above the dictionary's cache threshold, cache the result
@@ -2578,13 +2640,14 @@ to its constituent dicts."
                              (symbolp (car rank-function))
                              (symbolp (cdr rank-function))))
                     (symbolp filter)
+                    (symbolp pfxfilter)
                     (dictree--above-cache-threshold-p
-                     time (length arg) (dictree-cache-policy dic)
+                     time (length (car args)) (dictree-cache-policy dic)
                      (dictree-cache-threshold dic) cache-long))
            (setf (dictree-modified dic) t)
            ;; create query cache if it doesn't already exist
            (funcall cachecreatefun dic)
-           (puthash (list arg auxargs rank-function reverse filter)
+           (puthash (list args rank-function reverse filter pfxfilter)
                     (dictree--cache-create res maxnum)
                     (funcall cachefun dic)))))
 
@@ -2606,8 +2669,8 @@ to its constituent dicts."
 
 
 (defun dictree--do-query
-    (dict triefun stackfun arg &optional auxargs rankfun maxnum reverse filter
-                                        stack-rankfun)
+    (dict triefun stackfun args
+         &optional rankfun maxnum reverse filter pfxfilter stack-rankfun)
   ;; Return first MAXNUM results of querying DICT with argument ARG (and
   ;; AUXARGS list, if any) using TRIEFUN or STACKFUN that satisfy FILTER,
   ;; ordered according to RANKFUN (defaulting to "lexicographic" order).
@@ -2617,13 +2680,17 @@ to its constituent dicts."
       ;; trie. Note: could use a dictree-stack here too - would it be more
       ;; efficient?
       (apply triefun
-            (append (list (dictree--trie dict) arg) auxargs
-                    (list rankfun maxnum reverse filter)))
+            (append (list (dictree--trie dict)) args
+                    (list :maxnum maxnum :reverse reverse
+                          :rankfun rankfun
+                          :filter filter :pfxfilter pfxfilter)))
 
     ;; for a meta-dict, use a dictree-stack
     (unless stack-rankfun (setq stack-rankfun rankfun))
     (let ((stack (apply stackfun
-                       (append (list dict arg) auxargs (list reverse))))
+                       (append (list dict) args
+                               (list :reverse reverse
+                                     :pfxfilter pfxfilter))))
          (heap (when stack-rankfun
                  (heap-create   ; heap order is inverse of rank order
                   (if reverse stack-rankfun
@@ -2660,9 +2727,10 @@ to its constituent dicts."
 ;; ----------------------------------------------------------------
 ;;                        Completing
 
-(defun dictree-complete
-  (dict prefix
-   &optional rank-function maxnum reverse filter resultfun no-cache)
+(defun* dictree-complete
+    (dict prefix
+         &key maxnum reverse rank-function filter pfxfilter
+         resultfun no-cache)
   "Return an alist containing all completions of PREFIX in DICT
 along with their associated data, sorted according to
 RANK-FUNCTION (defaulting to \"lexicographic\" order, i.e. the
@@ -2714,14 +2782,18 @@ default key-data cons cell."
    dict #'trie-complete #'dictree-complete-stack
    #'dictree-complete-cache #'dictree-create-complete-cache
    nil no-cache  ; cache short PREFIXes
-   prefix nil
-   rank-function
-   (when rank-function
-     (dictree--wrap-rankfun
-      (if (eq rank-function t)
-         (dictree--rank-function (if (listp dict) (car dict) dict))
-       rank-function)))
-   maxnum reverse filter resultfun))
+   (list prefix)
+   :rank-function rank-function
+   :maxnum maxnum
+   :reverse reverse
+   :rankfun (when rank-function
+             (dictree--wrap-rankfun
+              (if (eq rank-function t)
+                  (dictree--rank-function (if (listp dict) (car dict) dict))
+                rank-function)))
+   :filter filter
+   :pfxfilter pfxfilter
+   :resultfun resultfun))
 
 
 (defun dictree-collection-function (dict string predicate all)
@@ -2735,8 +2807,9 @@ following as the COLLECTION argument of any of those 
functions:
 Note that PREDICATE will be called with two arguments: the
 completion, and its associated data."
   (let ((completions
-        (dictree-complete dict string nil nil nil predicate
-                          (lambda (key _data) key))))
+        (dictree-complete dict string
+                          :filter predicate
+                          :resultfun (lambda (key _data) key))))
     (if all completions (try-completion "" completions))))
 
 
@@ -2745,9 +2818,9 @@ completion, and its associated data."
 ;; ----------------------------------------------------------------
 ;;                      Regexp search
 
-(defun dictree-regexp-search
-  (dict regexp
-   &optional rank-function maxnum reverse filter resultfun no-cache)
+(defun* dictree-regexp-search
+    (dict regexp &key maxnum reverse rank-function
+         filter pfxfilter resultfun no-cache)
   "Return an alist containing all matches for REGEXP in DICT
 along with their associated data, in the order defined by
 RANKFUN, defauling to \"lexicographic\" order. If REVERSE is
@@ -2843,14 +2916,18 @@ list, instead of the default key-data cons cell."
        nil  ; cache short REGEXP if it ends in .*
      t)     ; cache long REGEXPs otherwise
    no-cache
-   regexp nil
-   rank-function
-   (when rank-function
-     (dictree--wrap-regexp-rankfun
-      (if (eq rank-function t)
-         (dictree-rank-function (if (listp dict) (car dict) dict))
-       rank-function)))
-   maxnum reverse filter resultfun))
+   (list regexp)
+   :maxnum maxnum
+   :reverse reverse
+   :rank-function rank-function
+   :rankfun (when rank-function
+             (dictree--wrap-regexp-rankfun
+              (if (eq rank-function t)
+                  (dictree-rank-function (if (listp dict) (car dict) dict))
+                rank-function)))
+   :filter filter
+   :pfxfilter pfxfilter
+   :resultfun resultfun))
 
 
 
@@ -2858,9 +2935,9 @@ list, instead of the default key-data cons cell."
 ;; ----------------------------------------------------------------
 ;;                      Fuzzy queries
 
-(defun dictree-fuzzy-match
-  (dict string distance
-   &optional rank-function maxnum reverse filter resultfun no-cache)
+(defun* dictree-fuzzy-match
+    (dict string distance &key maxnum reverse rank-function
+         filter pfxfilter resultfun no-cache)
   "Return matches for STRING in DICT within Lewenstein DISTANCE
 \(edit distance\) of STRING along with their associated data, in
 the order defined by RANKFUN, defauling to \"lexicographic\"
@@ -2932,21 +3009,23 @@ of the default key-dist-data list."
    dict #'trie-fuzzy-match #'dictree-fuzzy-match-stack
    #'dictree-fuzzy-match-cache #'dictree-create-fuzzy-match-cache
    t no-cache  ; cache long STRINGs
-   string (list distance)
-   rank-function
-   (dictree--construct-fuzzy-trie-rankfun
-    rank-function (if (listp dict) (car dict) dict))
-   maxnum
-   reverse
-   filter
-   resultfun
-   (dictree--construct-fuzzy-match-rankfun
-    rank-function  (if (listp dict) (car dict) dict))))
-
-
-(defun dictree-fuzzy-complete
-  (dict prefix distance
-   &optional rank-function maxnum reverse filter resultfun no-cache)
+   (list string distance)
+   :maxnum maxnum
+   :reverse reverse
+   :rank-function rank-function
+   :rankfun (dictree--construct-fuzzy-trie-rankfun
+            rank-function (if (listp dict) (car dict) dict))
+   :stack-rankfun (dictree--construct-fuzzy-match-rankfun
+                  rank-function  (if (listp dict) (car dict) dict))
+   :filter filter
+   :pfxfilter pfxfilter
+   :resultfun resultfun))
+
+
+(defun* dictree-fuzzy-complete
+    (dict prefix distance
+         &key maxnum reverse rank-function
+         filter pfxfilter resultfun no-cache)
   "Return completion of prefixes in DICT within Lewenstein DISTANCE
 \(edit distance\) of PREFIX along with their associated data, in
 the order defined by RANKFUN, defauling to lexicographic order.
@@ -3048,15 +3127,16 @@ of the default key-dist-pfxlen-data list."
    #'dictree-fuzzy-complete-cache #'dictree-create-fuzzy-complete-cache
    nil no-cache  ; cache short PREFIXes
    prefix (list distance)
-   rank-function
-   (dictree--construct-fuzzy-trie-rankfun
-    rank-function (if (listp dict) (car dict) dict))
-   maxnum
-   reverse
-   filter
-   resultfun
-   (dictree--construct-fuzzy-complete-rankfun
-    rank-function (if (listp dict) (car dict) dict))))
+   :maxnum maxnum
+   :reverse reverse
+   :rank-function rank-function
+   :rankfun (dictree--construct-fuzzy-trie-rankfun
+            rank-function (if (listp dict) (car dict) dict))
+   :stack-rankfun (dictree--construct-fuzzy-complete-rankfun
+                  rank-function (if (listp dict) (car dict) dict))
+   :filter filter
+   :pfxfilter pfxfilter
+   :resultfun resultfun))
 
 
 
@@ -3647,10 +3727,10 @@ is the prefix argument."
 ;; ----------------------------------------------------------------
 ;;                Dumping and restoring contents
 
-(defun dictree-populate-from-file
-  (dict file
-   &optional insert-function key-loadfun data-loadfun plist-loadfun
-   balance)
+(defun* dictree-populate-from-file
+    (dict file
+         &key insert-function key-loadfun data-loadfun plist-loadfun
+         balance)
   "Populate dictionary DICT from the key list in file FILE.
 
 Each line of FILE should contain a key, either a string