Hello, Malli looks very cool. Is it possible in Malli to retain values generated during validation like spec/conform and spec/conformer? Or if not maybe you can think of some Malli-ish way to solve this: I have some expensive validations, for example I accept an xpath as input and validate by compiling it. I don't want to throw the resulting value away and have to re-generate it later. So I transform (with s/conformer) the xpath string to a map with a compiled version (object) of it during validation and this map is the result of validation (with s/conform):

(require '[clj-xpath.core :as xpath])

(defn expr-or-nil
  [maybe-expr]
  (try
    (xpath/xp:compile maybe-expr)
    (catch org.xml.sax.SAXException e)
    (catch javax.xml.xpath.XPathException e)))

(s/def ::xpath (s/and string?           
                      (s/conformer (fn [value] {:value value
                                                :expr (expr-or-nil value)})
                                    :value)
                       #(:expr %))) 

(s/conform ::xpath "//a/@href")
;; {:value "//a/@href",
;;  :expr
;;  #object[org.apache.xpath.jaxp.XPathExpressionImpl 0x1aa56eab "org.apache.xpath.jaxp.XPathExpressionImpl@1aa56eab"]}     <---DONT HAVE TO RE-PARSE LATER, YAY! :-)

(s/conform ::xpath "%#^@")
;; :clojure.spec.alpha/invalid

@ryantate you have two models there: a string and a parsed map. With malli, you should describe either the string (source) or the target (a map). If the map presentation is what you expect, describe that and add a decoder from string->it. A naive impl:

(defn expr-or-nil [maybe-expr]
  (when (= maybe-expr "//a/@href") identity))

(defn decoder [value]
  {:value value
   :expr (expr-or-nil value)})

(def Xpath
  (m/schema
   [:map {:decode/string decoder}
    [:value :string]
    [:expr fn?]]))

(defn coerce [value]
  (let [decoded (m/decode Xpath value (mt/string-transformer))]
    (if-not (m/validate Xpath decoded)
      ::invalid
      decoded)))

(coerce "//a/@href")
; => {:value "//a/@href", :expr #object[clojure.core$identity 0x2c879e65 "clojure.core$identity@2c879e65"]}

(coerce "invalid")
;; => :user/invalid

but yes, the transform and validation are separated. There might be use cases where this is not good, but for most cases, it’s easy to compose the two using public apis. If/when someone finds out a need for one-pass-do-it-all &/ stateful transformers, would like to hear those 😎

@ikitommi Ah thanks for the comprehensive reply!! 👍 string -> compiled-xpath is the goal, the map is just there to allow s/unform which is not essential. In my case I would probably just accept the cost of two passes because I need the xpath compilation in order to validate the string) and also the xpath string needs to be composed into a more complicated validation so I can just do one m/validate call on the larger structure (which can have many xpath strings). So I think the coerce function would be tricky to use. I could just validate all xpath as string in the larger value and then m/validate and m/parse the larger value and then walk it and call coerce on each xpath item but I would have to do that also for regex and anything else that gets compiled - becomes basically building a new validation layer which defeats the point a bit. I did a benchmark and compiling xpath is only about 2 μs and regex is even less so I will just put those checks in the schema so it is part of a compostable validation and then do it again in m/decode. It is a performance hit but a small one, hopefully not too bad 😅

Issue with :orn schema inside decode. Any idea why this works:

(m/decode  [:string {:decode/string (fn [s] (try (re-pattern s) (catch java.util.regex.PatternSyntaxException e)))}] "foo" mt/string-transformer)
;;#"foo"

(m/decode [:orn [:v vector?] [:re-string [:string {:decode/string (fn [s] (try (re-pattern s) (catch java.util.regex.PatternSyntaxException e)))}]]] "foo" mt/string-transformer)
;;"foo"

Can I combine parse and encode functionality using a single schema? I can parse:

(def re-schema [:string {:encode/string (fn [s] (try (re-pattern s) (catch java.util.regex.PatternSyntaxException e)))}])
(def re-w-opts-schema [:and vector? [:catn [:pattern re-schema] [:opts [:* [:enum :i :s :u]]]]])
(def re-maybe-w-opts [:orn [:pattern re-schema] [:pattern-w-opts re-w-opts-schema]])

(m/parse re-maybe-w-opts ["foo" :i])
;;[:pattern-w-opts {:pattern "foo", :opts [:i]}]

(m/encode re-maybe-w-opts ["foo" :i] mt/string-transformer)
;;[#"foo" :i]

[:pattern-w-opts {:pattern #"foo", :opts [:i]}]