           (graph-conversion-path g' src dst))))))
 
 (defn- convert-via [path]
-  (condp = (count (:path path))
-    0 (vector path (fn [x] x))
-    1 (vector path (->> path :fns first))
-    (let [fns (->> path :fns vec)]
-      (vector path (fn [v] (reduce (fn [v f] (f v)) v fns))))))
+  (case (count (:path path))
+    0 [path identity]
+    1 [path (-> path :fns first)]
+    [path (fn [v] (reduce (fn [v f] (f v)) v (:fns path)))]))
 
 (defn conversion-fn
   "Create a function which will convert between the `src` and the `dst`
   `Types`."
   [g src dst]
-  (when-let [path (conversion-path g src dst)]
+  (when-some [path (conversion-path g src dst)]
     (convert-via path)))


(defn- conj-path [^ConversionPath p src dst ^Conversion c]
  (ConversionPath.
    (conj (.path p) (vector src dst))
    (conj (.fns p) (.f c))
    (conj (.visited? p) dst)
    (+ (.cost p) (.cost c))))

      (conj srcs src)))
  (possible-sources [_] srcs)
  (equivalent-targets [_ dst]
    (into #{} (comp (mapcat collect-targets)
                    (map first)
                    (filter #(assignable? % dst)))
          (vals m-by-arity)))
  (possible-conversions [_ src]
    (let [^Types src src
          result (volatile! [])]
      (search-for-possible-sources
        result
        (m-by-arity (.arity src))
        []
        (first (.types src))
        (next (.types src)))
      @result)))

(defn conversion-graph []
