                         (filter f coll))) m ks nil))
 
 (t/ann remove-in (t/All [x]
-                   [x (t/Vec t/Any) [t/Any -> t/Any] -> x]))
+                   [x (clojure.lang.Associative t/Any t/Any) [t/Any -> t/Any] -> x]))
 (defn remove-in
   [m ks f]
   (fn-in (fn [coll _] (if (vector? coll)

  [f m ks v]
  (update-in m ks (fn [coll] (f coll v))))

(t/ann concat-in (t/All [x]
                   [x (t/Vec t/Any) t/Any -> x]))
(defn concat-in
  [m ks v]
  (fn-in concat m ks v))

(t/ann conj-in (t/All [x]
                 (t/IFn [x (t/Vec t/Any) t/Any -> x])))
(defn conj-in
  [m ks v]
  (fn-in conj m ks v))

(t/ann map-in (t/All [x]
                [x (t/Vec t/Any) [t/Any -> t/Any] -> x]))
(defn map-in
  [m ks f]
  (fn-in (fn [coll _] (if (vector? coll)

                            (cons (f x y) (if (empty? xs) [] (fill-missing pred f ys xs)))
                            (cons x (if (empty? xs) [] (fill-missing pred f vcoll xs)))))))

(t/ann ^:no-check clojure.core/update-in (t/All [x [y :< (clojure.lang.Associative t/Any t/Any)]]
                                           [y (t/Seqable t/Any) [t/Any -> t/Any] -> y]))
(t/ann fn-in (t/All [x
                     [y :< (clojure.lang.Associative t/Any t/Any)]]
               [[t/Any x -> t/Any] y (t/Seqable t/Any) x -> y]))
(defn fn-in
  "Applies a function to a value in a nested associative structure and an input value.
   ks sequence of keys and v is the second arguement to f. The nested value will be
