Here is the solution we had in place to be "good neighbors", perhaps clerk could do something similiar?

(defmacro defpatchmethod
  "An anaphoric macro for patching existing multimethods. Original method is bound to the symbol 'this'.
   Safe to execute multiple times, 'this' will always refer to the original implementation and never
   the previously patched implementation."
  [multifn dispatch-val bindings & body]
  `(let [multi#    ~multifn
         dispatch# ~dispatch-val
         original# (get-method multi# dispatch#)]
     (letfn [(define# [orig#]
               (.addMethod ^clojure.lang.MultiFn multi# dispatch#
                           (let [~'this orig#]
                             (with-meta (fn ~bindings ~@body)
                                        (merge (meta orig#)
                                               {::original orig#})))))]
       (define# (or (some-> original# meta ::original) original#)))))

(def ^:dynamic *my-edn-print-mode* false)

(defpatchmethod print-method clojure.lang.Keyword [v w]
  (if *my-edn-print-mode*
    (let [writer (java.io.StringWriter.)]
      (if (try
            (this v writer)
            (= v (edn/read-string (str writer)))
            (catch Exception e
              false))
        (.write w (str writer))
        (print-method (tagged-literal 'keyword [(.getNamespace v) (name v)]) w)))
    (this v w)))

The key thing here is to use the existing print method unless in our own edn print mode

also, we don't use an eval there, tho I grok why clerk may. We do keyword tagged literal.

In the end, I think there needs to be a totally distinct edn printing stack 8^)

Not filing an issue with clerk, because I think clerk is doing the best it can here

I’ll take a look, thanks!

Prolly best just to leap to transit for this use case 8^). Enjoying using Clerk, thanks for all the great work!

yeah transit doensn’t have this problem, still like being able to use a zero-dep solution