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

          (subvec v (inc (last idxs)) (count v))))

(defn- index-conversions [^Types src idxs [[_ ^Types replacement] ^Conversion conv]]
  (vector src (types (replace-range (.types src) (.types replacement) idxs))
          (fn [vs]
            (let [vs (vec vs)]
              (replace-range vs
                             ((.f conv) (subvec vs (first idxs) (inc (last idxs))))
                             idxs)))
          (.cost conv)))

(defn- sub-conversions
  "Given an `src` types, generate all of the conversions from these types that

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