I think I can build (a), the transformer has access to the parent schema

Also reminds me, I think an interleaved transformer/validator will be good

doing both in a single pipeline?

yes

The decoder can end up doing lots of allocations

you can short circuit on it

but, you can’t validate before it’s transformed, right?

right

so, it would need to happen on :leave -> it’s all transformed already?

you'll have something like a coercer which transforms and validates in one pass

think so

how would it allocate less if that happens after the transformation?

wouldn’t all the nested childs get re-validated when you are leaving them?

[:map [:a [:map [:b [:map [:c [:map [:d :boolean]]]]]

unless the walking knows which childs are already transformed & validated.

hm, generally, you have no way of knowing if you need to re-walk the children

especially if you do interesting transformations

my assumption is that having validation and transformation as separate steps is the fastest way to do it. 2 simple sweeps instead of one (more complex) sweep.

but, all ears if there is a better way.

originally, i though of doing all the workers using just -walk. there would be walker to create a validator, decoder etc. but as all schemas should have all of those and as performance was a one of the primary goals - they got separate (protocol) methods.

the one walker would have allowed to compose a chain of validate + transform in an easier way, I think.

Figured out how to strip invalid optional keys, feel free to add it to tips, after some beautifying

(defn strip-invalid-optional-keys-transformer
  ([]
   (let [transform
         {:compile
          (fn [schema _]
            (let [entries (filter #(:optional (m/properties (second %))) (m/entries schema))
                  fs (map (fn [[k v]]
                            (let [validator (m/validator v)]
                              (fn [m]
                                (if-let [e' (find m k)]
                                  (let [v' (val e')]
                                    (if (validator v')
                                      m
                                      (dissoc m k)))
                                  m))))
                          entries)]
              (reduce comp fs)))}]
     (mt/transformer
      {:decoders {:map transform}
       :encoders {:map transform}}))))

(m/decode [:map [:a {:optional true} int?] [:b {:optional true} int?]] {:a 1 :b 2.2} strip-invalid-optional-keys-transformer)

👍