another option is to use the existing meta to look up the function. There's a built in function clojure.repl/source, but it is a little inconsistent. I adapted source to work more consistently, which you can see at: https://github.com/phronmophobic/reveal-exception/blob/main/src/com/phronemophobic/reveal_plugin/reveal_exception.clj#L83

yes, I did use that. My use case goes into "diffing" of clojure source code, but per function (instead of being file based) So I thought it could be interesting to look at the form which defined a function.

Yes you can do that if you want

But don't try to re-implement defn, just leverage the existing defn

how could I do that ?

without getting in a circle ?

are you diffing between versions in version control or redefined at the repl?

hmmm. I want to track changes in the definition of functions over time. They are defined in source files. So the source-fn approach works in principle.

Just a pitty that it gives me a String back.

So I read somewhere te idea to change the defn macro, to store the form as metdata.

it's pretty easy to get a data structure from the string, you can just use read

or read-string

???

Lets give it a try.

are you tracking changes while someone is working at the repl or some other way?

if you're trying to track changes at the repl, I might go the route of writing some repl middleware that receives each expression that will be eval 'd

if you're tracking changes in source files, I would use a tool like rewrite-clj that can parse clojure source into an AST

the source code -> read-string is fine,., probbaly

and the file parsing is as well a good idea.

thanks

also check out https://clojure-lsp.io/ which has great static analysis tools that might be helpful

You can call the core one with full qualification: clojure.core/defn

(defmacro defn
  [& body]
  `(doto
       (clojure.core/defn ~@body)
     (alter-meta!
      merge
      {:form '~&form})))

That will put the full source of the defn on the meta key named :form

You can try it with:

(defn foobar
  "This is a doc"
  {:some-attr :a1}
  ([] (foobar 1 2 3))
  ([a b c]
   {:pre [(number? a) (number? b) (number? c)]}
   (+ a b c))
  {:some-other-attribute :a2})

(:form (meta #'foobar))

It preserves all features of defn, and it should work even when AOT compiled I believe.