 (def- conexp-version-map
   (let [[_ major minor patch qualifier] (re-find #"(\d+)\.(\d+)\.(\d+)(?:-(.+))?"
                                                  internal-version-string)]
-    {:major (Integer/parseInt major),
-     :minor (Integer/parseInt minor),
-     :patch (Integer/parseInt patch),
+    {:major ^int (Integer/parseInt major),
+     :minor ^int (Integer/parseInt minor),
+     :patch ^int (Integer/parseInt patch),
      :qualifier qualifier}))
 
 (defn conexp-version

      (instance? clojure.lang.Seqable x)
      (nil? x)
      (instance? Iterable x)
      (-> x .getClass .isArray)
      (string? x)
      (instance? java.util.Map x)))


(defn has-version?
  "Compares given version of conexp and returns true if and only if
  the current version of conexp is higher or equal than the given one"
  [{^int my-major :major, ^int my-minor :minor, ^int my-patch :patch}]
  (assert (and my-major my-minor my-patch))
  (let [{:keys [^int major, ^int minor, ^int patch]} conexp-version-map]
    (or (and (< my-major major))
        (and (= my-major major)
             (< my-minor minor))
