                             (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 fn-in (t/All[x]
+               [[t/Any x -> t/Any] (t/Map t/Any t/Any) (t/Vec t/Any) -> x]))
 (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

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

(defn filter-in
  [m ks f]
  (fn-in (fn [coll _] (if (vector? coll)
                        (vec (filter f coll))
                        (filter f coll))) m ks nil))

(defn remove-in
  [m ks f]
  (fn-in (fn [coll _] (if (vector? coll)
                        (vec (remove f coll))
                        (remove f coll))) m ks nil))

(defn some-in
  [m ks f]
  (fn-in (fn [coll _] (if (vector? coll)
                        (vec (some f coll))
                        (some f coll))) m ks nil))

(defn remove-in
  [m ks f]
  (fn-in (fn [coll _] (if (vector? coll)
                        (vec (remove f coll))
                        (remove f coll))) m ks nil))

(defn update-in-matching
  [m ks p f]
  (if (fn? p)

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

(t/ann concat-in (t/All [x]
                   (t/IFn [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)
