    (repeat x))
   ([fs x]
    (cond
-     (vector? fs) (vec-zip fs x)
-     (seq? fs) (reverse (vec-zip fs x))
-     (map? fs) (map-zip fs x)))
+     (vector? fs) (with-meta (vec-zip fs x) (meta x))
+     (seq? fs) (with-meta (reverse (vec-zip fs x)) (meta x))
+     (map? fs) (with-meta (map-zip fs x) (meta x))))
   ([fs x y]
    (cond
-     (vector? fs) (vec-zip fs x [y])
-     (seq? fs) (reverse (vec-zip fs x [y]))
-     (map? fs) (map-zip fs x y)))
+     (vector? fs) (with-meta (vec-zip fs x [y]) (meta x))
+     (seq? fs) (with-meta (reverse (vec-zip fs x [y])) (meta x))
+     (map? fs) (with-meta (map-zip fs x y) (meta x))))
   ([fs x y & args]
    (let [more-args (cons y args)]
      (cond
-       (vector? fs) (vec-zip fs x more-args)
-       (seq? fs) (reverse (vec-zip fs x more-args))
-       (map? fs) (apply (partial map-zip fs x y) args)))))
+       (vector? fs) (with-meta (vec-zip fs x more-args) (meta x))
+       (seq? fs) (with-meta (reverse (vec-zip fs x more-args)) (meta x))
+       (map? fs) (with-meta (apply (partial map-zip fs x y) args) (meta x))))))
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

   ;; same thing here but we'll mutually walk ms
   (let [mcoll (cons m ms)]
     (cond
       (list? m) (map (partial flst f) mcoll)
       (vector? m) (map (partial fvec f) mcoll)
       (seq? m) (map (partial fseq f) mcoll)
       (set? m) (map (partial fset f) mcoll)
       (associative? m) (fassc f m ms)
       (fn? m) (map #(comp f %) mcoll)
       :else
       (apply f mcoll)))))

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