   ([fs m]
    (cond
      ;; map the fn for sequential/set types
-     (list? fs) (lst-fapply fs m)
-     (seq? fs) (seq-fapply fs m)
-     (vector? fs) (vec-fapply fs m)
-     (set? fs) (set-fapply fs m)
+     (list? fs) (with-meta (lst-fapply fs m) (meta m))
+     (seq? fs) (with-meta (seq-fapply fs m) (meta m))
+     (vector? fs) (with-meta (vec-fapply fs m) (meta m))
+     (set? fs) (with-meta (set-fapply fs m) (meta m))
      ;; match keys for maps and if found apply the fn (otherwise
      ;;  just leave it)
-     (map? fs) (assc-fapply fs m)
+     (map? fs) (with-meta (assc-fapply fs m) (meta m))
      ;; base cases:
      ;; either use the fn
      (fn? fs) (fs m)

  ([f m]
   (cond
     ;; map deepfmap over all the entries until it thunks out
     (list? m) (reverse (flst f m))
     (vector? m) (fvec f m)
     (seq? m) (fseq f m)
     (set? m) (fset f m)
     ;; map deepfmap over all the vals (nested too)
     (associative? m) (fassc f m)
     ;; two base cases here:
     ;; compose fns
     (fn? m) (comp f m)

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