doit => run!

Author: frenchy64

CHANGELOG.md

@@ -6,8 +6,10 @@
 
 * #78(liquidz): Add missing chrono fields (v0.3.3 has breaking changes)
 * #81(terop): Remove clj-tuple - no advantages over Clojure vector anymore
-* Remove java-time.util/get-static-fields-of-type
+* Remove `java-time.util/get-static-fields-of-type`
   * set Java property `java-time.util.get-static-fields-of-type=true` to revert
+* Remove `java-time.potemkin.util/doit`
+  * set Java property `java-time.potemkin.util/doit=true` to revert
 
 ## 0.3.3
 

bin/bb-test-runner.clj

@@ -3,33 +3,10 @@
   (:require [clojure.test :as t]
             [babashka.classpath :as cp]))
 
-(def require-nsyms ['java-time.potemkin.util
-                    'java-time.potemkin.namespaces
-                    'java-time.joda
-                    'java-time.core
-                    'java-time.properties
-                    'java-time.util
-                    'java-time.temporal
-                    'java-time.amount
-                    'java-time.zone
-                    'java-time.single-field
-                    'java-time.local
-                    'java-time.chrono
-                    'java-time.convert
-                    'java-time.sugar
-                    'java-time.seqs
-                    'java-time.adjuster
-                    'java-time.interval
-                    'java-time.format
-                    'java-time.clock
-                    'java-time.pre-java8
-                    'java-time
-                    ])
-;;TODO
-(def test-nsyms [#_'java-time-test
-                 #_'java-time.graph-test])
+(def test-nsyms ['java-time-test
+                 'java-time.graph-test])
 
-(some->> (seq (concat require-nsyms test-nsyms))
+(some->> (seq test-nsyms)
          (apply require))
 
 (def test-results

src/java_time/graph.cljc

@@ -111,14 +111,15 @@
 
 (defn- search-for-possible-sources
   [vresult m types-so-far k more-arity-steps]
-  (u/doit [[t r] m]
-    (when (assignable-type? k t)
-      (if-not more-arity-steps
-        (vswap! vresult concat (mapv #(as-source types-so-far t %) r))
-        (search-for-possible-sources vresult r
-                                     (conj types-so-far t)
-                                     (first more-arity-steps)
-                                     (next more-arity-steps))))))
+  (run! (fn [[t r]]
+          (when (assignable-type? k t)
+            (if-not more-arity-steps
+              (vswap! vresult concat (mapv #(as-source types-so-far t %) r))
+              (search-for-possible-sources vresult r
+                                           (conj types-so-far t)
+                                           (first more-arity-steps)
+                                           (next more-arity-steps)))))
+        m))
 
 (defn- collect-targets [v]
   (reduce
@@ -193,8 +194,8 @@
     (let [path (ConversionPath. (vector) (vector) #{src} 0)]
       (if (assignable? src dst)
         path
-        (let [q #?(:bb (atom (list path))
-                   :default (doto (PriorityQueue.) (.add path)))
+        (let [q #?(:bb (atom ())
+                   :default (PriorityQueue.))
               add #?(:bb #(swap! q (fn [prev]
                                      (sort-by (fn [^ConversionPath p]
                                                 [(.cost p) (count (.path p))])
@@ -203,18 +204,19 @@
                      :default #(.add q %))
               poll #?(:bb #(-> (swap-vals! q next) first first)
                       :default #(.poll q))
+              _ (add path)
               dsts (equivalent-targets g dst)]
           (loop []
-            (when-let [^ConversionPath p (poll)]
+            (when-some [^ConversionPath p (poll)]
               (let [curr (or (-> p .path last second) src)]
                 (if (some #(assignable? curr %) dsts)
                   p
-                  (do
-                    (u/doit [[[src dst] c] (possible-conversions g curr)]
-                      (when (and (> max-path-length (count (.path p)))
-                                 (not ((.visited? p) dst)))
-                        (add (conj-path p src dst c))))
-                    (recur)))))))))))
+                  (do (run! (fn [[[src dst] c]]
+                              (when (and (> max-path-length (count (.path p)))
+                                         (not ((.visited? p) dst)))
+                                (add (conj-path p src dst c))))
+                            (possible-conversions g curr))
+                      (recur)))))))))))
 
 (defn- replace-range [v replacement idxs]
   (concat (subvec v 0 (first idxs))

src/java_time/potemkin/util.cljc

@@ -65,14 +65,15 @@
                          (let [v (de-nil (apply f k))]
                            (or (.putIfAbsent m k v) v))))))))))
 
-(defmacro doit
-  "A version of doseq that doesn't emit all that inline-destroying chunked-seq code."
-  [[x it] & body]
-  (let [it-sym (gensym "iterable")]
-    `(let [~it-sym ~it
-           it# (.iterator ~(with-meta it-sym {:tag 'java.lang.Iterable}))]
-       (loop []
-         (when (.hasNext it#)
-           (let [~x (.next it#)]
-             ~@body)
-           (recur))))))
+(when (some-> (System/getProperty "java-time.potemkin.util.doit") (= "true"))
+  (defmacro doit
+    "A version of doseq that doesn't emit all that inline-destroying chunked-seq code."
+    [[x it] & body]
+    (let [it-sym (gensym "iterable")]
+      `(let [~it-sym ~it
+             it# (.iterator ~(with-meta it-sym {:tag 'java.lang.Iterable}))]
+         (loop []
+           (when (.hasNext it#)
+             (let [~x (.next it#)]
+               ~@body)
+             (recur)))))))