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

   (let [mcoll (cons m ms)]
     (cond
       ;; mapcat all the results for sequential/set types
       (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)
       ;; match all keys for maps and apply the fn if ther was a match
       (map? fs) (assc-fapply fs m ms)
       ;; apply the fn to the args
       (fn? fs) (apply fs mcoll)
       :else

  ([fs m]
   (cond
     ;; map the fn for sequential/set types
     (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) (with-meta (assc-fapply fs m) (meta m))
     ;; base cases:
     ;; either use the fn
     (fn? fs) (fs m)
