When to use `constantly` in clojure, how and when are its arguments evaluated?

Question

In the accepted answer to another question, http://stackoverflow.com/questions/3997910/setting-clojure-constants-at-runtime the clojure function constantly is used.

The definition of constantly looks like so:

(defn constantly
  "Returns a function that takes any number of arguments and returns x."
  {:added "1.0"}
  [x] (fn [& args] x))

The doc string says what it does but not why one would use it.

In the answer given in the previous question constantly is used as follows:

(declare version)

(defn -main
  [& args]
 (alter-var-root #'version (constantly (-> ...)))
 (do-stuff))

So the function returned by constantly is directly evaluated for its result. I am confused as to how this is useful. I am probably not understanding how x would be evaluated with and without being wrapped in `constantly'.

When should I use constantly and why is it necessary?

Answer 1

The constantly function is useful when an API expects a function and you just want a constant. This is the case in the example provided in the question.

Most of the alter-* functions (including alter-var-root) take a function, to allow the caller to modify something based on its old value. Even if you just want the new value to be 7 (disregarding the old value), you still need to provide a function (providing just 7 will result in an attempt to evaluate it, which will fail). So you have to provide a function that just returns 7. (constantly 7) produces just this function, sparing the effort required to define it.

Edit: As to second part of the question, constantly is an ordinary function, so its argument is evaluated before the constant function is constructed. So (constantly @myref) always returns the value referenced by myref at the time constantly was called, even if it is changed later.