 (defn- fset [f m]
   (into #{} (map (partial deepfmap f) m)))
 
-(defn- fassc [f m]
-  (reduce (fn [acc [k v]]
-            (assoc acc k (deepfmap f v)))
-    {} m))
+(defn- group-vals [ms k]
+  (let [matches (map #(find % k) ms)]
+    (when-not (every? nil? matches)
+      (vals (remove nil? matches)))))
+
+(defn apply-key [f ms k]
+  [k (apply (partial deepfmap f)
+       (group-vals ms k))])
+
+(defn- fassc
+  ([f m]
+   (reduce (fn [acc [k v]]
+             (assoc acc k (deepfmap f v)))
+     {} m))
+  ([f m ms]
+   (let [mcoll (cons m ms)]
+     (reduce-kv (fn [acc mk mv]
+                  ;; find all the matching keys in mcoll
+                  (when-let [keys (into #{} (flatten (map keys mcoll)))]
+                    (into {}
+                      ;; eval the nested maps and bind them to the output
+                      (map (partial apply-key f mcoll) keys))))
+       m m))))
 
 (defn deepfmap
   "Like fmap but it will recursively evalute all nested collections"

                (if-let [[_ mv] (find m fk)]
                  (assoc acc fk (filterapply f mv))
                  acc))
     {} 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)]
                    (assoc acc fk
                      ;; eval the nested maps and bind them to the output
                      (apply (partial filterapply f) vals))
                    acc))
       {} fs))))

(defn filterapply

       (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)))))
