               [src -> String]"
   [g ^Types src]
   (if (> (.arity src) max-arity)
-    (vector)
+    []
     (->> (continuous-combinations (.arity src))
          (mapcat
            (fn [idxs]

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

(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)]
    (convert-via path)))

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