   (possible-conversions [_ src]))
 
 (defn- expand [[a b]]
-  (when-not (empty? b)
+  (when-some [[bf & br] (seq b)] 
     (cons
-      [(conj a (first b)) (rest b)]
-      (expand [a (rest b)]))))
+      [(conj a bf) br]
+      (expand [a br]))))
 
 (defn- combinations [n s]
   (letfn [(combos [n s]
             (if (zero? n)
-              (list (vector (vector) s))
+              (list [[] s])
               (mapcat expand (combos (dec n) s))))]
     (map first (combos n s))))
 

              [new-conversions g'] (with-conversions g more-conversions)
              accepted-conversions (filter (fn [[conv-src _ _ cost]]
                                             (>= max-cost cost)) new-conversions)]
          (recur g' (reduce (fn [q [_ dst _ _]] (conj q (vector dst (inc step))))
                            (pop q) accepted-conversions))))
      g)))


(defn- collect-targets [v]
  (reduce
    (fn [r [k v]]
      (concat r (cond-> v
                  (map? v) collect-targets)))
    [] v))

(defn- add-conversion [m ^Types src dst conversion]
  (let [add #(update % (peek (.types src))
