Merge pull request #1250 from alexander-yakushev/recursive-ref-transform

Reuse recursive ref-transformers

Author: opqdonut

src/malli/core.cljc

@@ -2012,9 +2012,16 @@
            (-parser [_] (->parser -parser))
            (-unparser [_] (->parser -unparser))
            (-transformer [this transformer method options]
-             (let [this-transformer (-value-transformer transformer this method options)
-                   deref-transformer (-memoize (fn [] (-transformer (rf) transformer method options)))]
-               (-intercepting this-transformer (fn [x] (if-some [t (deref-transformer)] (t x) x)))))
+             (let [key [(-identify-ref-schema this) method]]
+               (or (some-> (get-in options [::ref-transformer-cache key]) clojure.core/deref)
+                   (let [knot (atom nil)
+                         this-transformer (-value-transformer transformer this method options)
+                         deref-transformer (-memoize
+                                            (fn [] (-transformer (rf) transformer method
+                                                                 (assoc-in options [::ref-transformer-cache key] knot))))
+                         f (-intercepting this-transformer (fn [x] (if-some [t (deref-transformer)] (t x) x)))]
+                     (compare-and-set! knot nil f)
+                     f))))
            (-walk [this walker path options]
              (let [accept (fn [] (-inner walker (rf) (into path [0 0])
                                          (-update options ::walked-refs #(conj (or % #{}) ref))))]

test/malli/core_test.cljc

@@ -3681,3 +3681,19 @@
              "world" [:enum "maailma"])
       (is (= ["hello" "maailma"]
              (mapv (comp peek m/form m/deref-all) (m/children schema)))))))
+
+(deftest recursive-coercer-test
+  (let [count-into-schemas (atom 0)
+        reg (mr/simple-registry (assoc (m/default-schemas)
+                                       ::counting (m/-proxy-schema {:type ::counting
+                                                                    :fn (fn [p c o]
+                                                                          (assert (empty? c))
+                                                                          (swap! count-into-schemas inc)
+                                                                          [[] [] (m/schema :int o)])})))
+        ConsCell (m/schema [:schema {:registry {::cons [:maybe [:tuple ::counting [:ref ::cons]]]}} ::cons]
+                           {:registry reg})]
+    (is (= @count-into-schemas 2))
+    (is (m/coerce ConsCell [1 [2 [3 [4 nil]]]]))
+    (is (= @count-into-schemas 3)) ;; was 6
+    (is (m/coerce ConsCell [1 [2 [3 [4 [1 [2 [3 [4 nil]]]]]]]]))
+    (is (= @count-into-schemas 3)))) ;; was 10