Let prescient-filter-regexps return flat list of regexps.

prescient.el

@@ -670,44 +670,51 @@ data can be used to highlight the matched substrings."
 
 ;;;; Sorting and filtering
 
-(defun prescient-filter-regexps (query &optional with-group)
+(defun prescient-filter-regexps (query &optional with-group separated)
   "Convert QUERY to list of regexps.
 Each regexp must match the candidate in order for a candidate to
 match the QUERY.
 
 If WITH-GROUP is non-nil, enclose the initials in initialisms
 with capture groups. If it is the symbol `all', additionally
-enclose literal substrings with capture groups."
-  (let ((subquery-number 0))
-    (mapcar
-     (lambda (subquery)
-       (prog1 (string-join
-               (cl-remove
-                nil
-                (mapcar
-                 (lambda (method)
-                   (if-let ((func (alist-get method prescient-filter-alist)))
-                       (funcall func subquery
-                                :with-group with-group
-                                :subquery-number subquery-number)
-                     ;; Don't throw error if function doesn't exist, but do
-                     ;; warn user.
-                     (message
-                      "No function in `prescient-filter-alist' for method: %s"
-                      method)))
-                 (pcase
-                     (if (functionp prescient-filter-method)
-                         (funcall prescient-filter-method)
-                       prescient-filter-method)
-                   ;; We support `literal+initialism' for backwards
-                   ;; compatibility.
-                   (`literal+initialism '(literal initialism))
-                   ((and (pred listp) x) x)
-                   (x (list x))))
-                :test #'eq)
-               "\\|")
-         (cl-incf subquery-number)))
-     (prescient-split-query query))))
+enclose literal substrings with capture groups.
+
+By default, this function returns a list containing a regexp for
+each query that combines the regexps produced by the filter method
+for each query. If SEPARATED is non-nil, this function instead
+returns a list of all regexps returned by the filter methods,
+without combining them."
+  (let ((list-of-lists
+         (cl-loop
+          with filter-methods = (pcase (if (functionp prescient-filter-method)
+                                           (funcall prescient-filter-method)
+                                         prescient-filter-method)
+                                  ;; We support `literal+initialism' for backwards
+                                  ;; compatibility.
+                                  (`literal+initialism '(literal initialism))
+                                  ((and (pred listp) x) x)
+                                  (x (list x)))
+          for subquery in (prescient-split-query query)
+          for subquery-number from 0
+          collect
+          (cl-loop with temp-regexp = nil
+                   for method in filter-methods
+                   for func = (alist-get method prescient-filter-alist)
+                   if (null func)
+                   do (message
+                       "No function in `prescient-filter-alist' for method: %s"
+                       method)
+                   else
+                   ;; Can't use "for =" here.
+                   do (setq temp-regexp (funcall func subquery
+                                                 :with-group with-group
+                                                 :subquery-number subquery-number))
+                   and if temp-regexp collect temp-regexp end
+                   end))))
+    (if separated
+        (apply #'append list-of-lists)
+      (mapcar (lambda (list) (string-join list "\\|"))
+              list-of-lists))))
 
 ;;;###autoload
 (defun prescient-filter (query candidates &optional pred)