Is there a way to make a function var dynamic after definition?

Question

Post updated to make it relevant to the course of events (responses and eliminating clutter).

Thank you very much for your time and help !

In some previous version of Clojure every var could be bound with a "binding" form. Nowadays you get "Can't dynamically bind non-dynamic var" if not defined as dynamic.

In some contexts making a function var dynamic after definition could be useful (stubbing/mocking in testing).

Don't try:

(def ^{:dynamic true} log-call #'log-call)

It will eventually cause StackOverflowError since you are defining a function that calls itself (thank you for your explanation).

The updated question:

The approach suggested does not seem to work.

Forms called from the binding form don't get the binding defined.

Could you please help to figure out what I'm missing??

Here is the updated code:

(def all-expenses [{:amount 33.0 :date "today"}
                   {:amount 44.0 :date "yesterday"}])

(defn fetch-all-expenses [])

(defn fetch-expenses-greater-than [threshold]
  (let [all (fetch-all-expenses)]
    ;calling from a nested form does not see the dynamically bound definition!
    (println "2) from fetch-expenses-greater-than:" (fetch-all-expenses))
    all))

(defn wrap [f]
  (fn [& args] (apply f args)))

(def ^{:dynamic true} fetch-all-expenses (wrap fetch-all-expenses))

(binding [fetch-all-expenses (constantly all-expenses)]
  (let [filtered (fetch-expenses-greater-than 15.0)]
    (println "1) from inside binding:" (fetch-all-expenses))));calling from binding form OK!

The result of executing the in the repl is:

2) from fetch-expenses-greater-than: nil
1) from inside binding: [{:date today, :amount 33.0} {:date yesterday, :amount 44.0}]
nil

If I change the definition of fetch-all-expenses to

(defn ^:dynamic fetch-all-expenses [])

The result is as expected:

2) from fetch-expenses-greater-than: [{:date today, :amount 33.0} {:date yesterday, :amount 44.0}]
1) from inside binding: [{:date today, :amount 33.0} {:date yesterday, :amount 44.0}]
nil

Answer 1

Thank you very much for your answer @MichałMarczyk. That explains it.

With code using the var before making it dynamic:

(def foo 0)
(defn bar []
  foo)
(.setDynamic #'foo)
(binding [foo 1]
     ;; prints foo 1 . bar 0
     (println  "foo" foo ". bar" (bar)))

With code using the var after making it dynamic:

(def foo 0)
(.setDynamic #'foo)
(defn bar []
  foo)
(binding [foo 1]
     ;; prints foo 1 . bar 1
     (println  "foo" foo ". bar" (bar)))

And yes!....with with-redefs instead of binding everything works as expected. That's exactly what I was needing.

Answer 2

It is possible to make a Var dynamic after it's been defined, but this will have no effect on code compiled before this change (it will still use the root binding). Use with-redefs to install custom replacements for functions during tests and the like.

The reason for this is that whether a Var is marked dynamic or not determines the way code using this Var is compiled. If it is not dynamic, such code will just get the root binding directly, saving some work; if it is dynamic, it will go through the somewhat more complex process of checking whether there is a thread-local binding in place for it.

So, there is no way to cause already compiled code use a custom function installed with binding after marking the Var holding the function dynamic. However, those calls still go through the Var, they just happen to go directly to the root binding, so you can use custom replacement functions for testing and the like if you install them as root bindings for the appropriate Vars. with-redefs encapsulates all the necessary logic for doing this cleanly.

Let's see how this works at the REPL:

;; define a non-dynamic Var:
(def foo 0)

;; this will throw an exception complaining about the attempt
;; to bind a non-dynamic Var:
(binding [foo 1]
  foo)

;; let's define a function using foo;
;; we'll use it further down:
(defn bar []
  foo)

;; now let's mark the Var dynamic:
(.setDynamic #'foo)

;; this will now evaluate to 1:
(binding [foo 1]
  foo)

;; however, this will still return 0:
(binding [foo 1]
  (bar))

Answer 3

(def ^{:dynamic true} log-call #'log-call) This statement says: "Create a var log-call and bind it to the var log-call. So when you try to use log-call var it will keep refering itself forever and hence StackOverflow exception.

You can try something like this:

(defn wrap [f]
  (fn [& args] (apply f args)))

(def ^{:dynamic true} log-call (wrap log-call))

(def ^{:dynamic true} fetch-all-expenses (wrap fetch-all-expenses))