                 (if-let [[_ mv] (find m fk)]
                   (assoc acc fk (filterapply f mv))
                   acc))
+     ;; start with an empty map to filter vals not in applicative
      {} fs))
   ([fs m ms]
    (let [mcoll (cons m ms)]
      (reduce-kv (fn [acc fk f]
                   ;; find all the matching keys in mcoll
-                  (if-let [vals (group-keys mcoll fk)]
+                  (if-let [vals (group-vals mcoll fk)]
                     (assoc acc fk
                       ;; eval the nested maps and bind them to the output
                       (apply (partial filterapply f) vals))
                     acc))
+       ;; use the empty map here too
        {} fs))))
 
 (defn filterapply

  ([fs m ms]
   (apply vector
     (mapcat #(apply map (partial deepfapply %) m ms) fs))))

(defn- group-keys [ms k]
  (let [matches (map #(find % k) ms)]
    (when-not (every? nil? matches)
        (vals matches))))

(defn- assc-fapply
  ([fs m]

       (filterapply f m))))
  ([fs m]
   (cond
     (list? fs) (lst-fapply fs m)
     (seq? fs) (seq-fapply fs m)
     (vector? fs) (vec-fapply fs m)
     (set? fs) (set-fapply fs m)
     (map? fs) (assc-filterapply fs m)
     (fn? fs) (fs m)
     :else
     ((constantly fs) m)))
  ([fs m & ms]
   (let [mcoll (cons m ms)]
     (cond
       (list? fs) (lst-fapply fs m ms)
       (seq? fs) (seq-fapply fs m ms)
       (vector? fs) (vec-fapply fs m ms)
       (set? fs) (set-fapply fs m ms)
       (map? fs) (assc-filterapply fs m ms)
       (fn? fs) (apply fs mcoll)
       :else
       (map (constantly fs) mcoll)))))
