There are some libraries out there for structural diff'ing of Clojure data structures. Not sure whether they'd handle metadata and other reader tags.

Maybe one of those more general libs could be used as a base for some the function-specific diffing that you’ve built?

Possibly yes, the less I’d need to do by hand the better, unless of course absolutely needed. What would be the names of those libs? 🙂

Ray and the #repl-acement’s have been looking at using spec to conform clojure code into a canonical representation that can be stored, queried and diffed and so on. Maybe that approach would be easier to deal with rather than the literal sexeps?

Depending on what you mean by structure and what “etc.” entails, you might be able to glean everything you need by just inspecting the runtime. Something like:

(transduce
  (comp
    (map ns-interns)
    (mapcat vals)
    (map meta)
    (map #(select-keys % [:ns :name :private :arglists])) ; whatever meta you need
    )
  (completing
    (fn [qualified-symbol->meta {:keys [ns name] :as meta}]
      (assoc qualified-symbol->meta (symbol (str ns) (str name)) (dissoc meta :ns :name))))
  (sorted-map)
  ['my.ns1 'my.ns2] ; or filter your namespaces from (all-ns)
  )

Could just run that on the old version, spit the result into an EDN file, then run it on the new version, slurp, and throw clojure.data/diff or something at it.

(defn subcoll? [sub coll]
  (let [diff (clj-data/diff sub coll)]
    (nil? (first diff))))

(testing "spec"
    (is (test-utils/subcoll? {:response {:status 200}}
                             (-> (gen/generate (s/gen ::spec-labels/labels-orders))
                                 (assoc :data-structure "atomstore/labels")
                                 (assoc-in [:api-client :code] "kh")
                                 (request-generate-labels)))
        "random request"))

(is (test-utils/subcoll?
          {:response {:status 400,
                      :body {:logs {:cause {:pdf-template "examples/foo"}
                                    :type "error"
                                    :code "pdf-template"
                                    :message "One of label-template doesn't exist or you don't have access."}}}}
          (request-generate-labels
            {:data-structure "atomstore/labels"
             :api-client {:code "kh"}
             :orders [{:code "1"
                       :lang "pl"
                       :products [{:pdf-template "examples/foo"
                                   :name "Nazwa Produktu"
                                   :ingredients "pszenica kamut, cukier, żyto, sól, orzeszki ziemne"
                                   :countries-of-origin "Polska"
                                   :expiry-days 365
                                   :unit "szt."
                                   :quantity 1
                                   :custom {:ingredients "pszenica kamut, cukier, żyto, sól, orzeszki ziemne"
                                            :countries-of-origin "Poland"
                                            :expiry-days 365}}]}]}))

But you can use diff in different way, than in this examples

to extract differencnes

https://github.com/lambdaisland/deep-diff2

I probably should've been a bit more clear: I don't really need structural diff but semantic diff or at least something which cuts the input sexprs into its components; meta partially works for what I'm trying to achieve, but it's not the full picture either. #repl-acement seems to be on similar track at least partially, so there's that.

I would look into conforming the function forms using clojure.spec, and comparing the conformed values.

I imagine rewrite-clj would be quite useful here. https://github.com/clj-commons/rewrite-clj/blob/main/doc/01-user-guide.adoc

cat transducer or apply concat to stitch results together

gotcha, yea that makes sense

I find I almost always (sequence cat (iteration …))

Thanks @U02EA2T7FEH i need to internalize how sequence and cat work together.