Clojure def vs defn for a function with no arguments

Question

I have written a program in clojure but some of the functions have no arguments. What would be the advantages of coding such functions as a \"def\" instead of a \"defn\" with no

Answer 1

The def special form creates a Var object identified by a symbol given as its first argument. Identification is created by associating the given symbol with a Var in a map called namespace.

The Var holds a reference to some value, which could be expressed (among others):

• as a constant form, which always evaluates to its own value:

(def x 1)
x
;; => 1             ; x holds a reference to a number 1

• as a function form, which at first is evaluated to its resulting value:

(def x (+ 2 2))
x
;; => 4             ; x holds a reference to a number 4

• as a Java method form, which at first is evaluated to its resulting value:

(def x (System/currentTimeMillis))
x
;; => 1417811438904 ; x holds a reference to a number 1417811438904
x
;; => 1417811438904 ; still the same number!

• as a lambda form (anonymous function), which at first is evaluated to a function object:

(def x (fn [] (System/currentTimeMillis)))
x
;; => #
(x)                             ; function form, function evaluated
;; => 1417811438904
(x)                             ; function form, function evaluated
;; => 1417812565866

There is a simple rule for all of the above. In case of def special form an S-expression given as its second argument is recursively evaluated before binding is created, so the resulting Var is bound to the result of this evaluation.

Even fn is evaluated before, but its resulting value is a function object that holds a code. This code will be executed (and evaluated) each time the function is called. That's why there are different results.

The defn macro is just like def but internally it creates an anonymous function and then binds a Var object to it. Its second argument becomes a body of this function and it's not evaluated in a "regular" way. One could also say it is evaluated but as a lambda form – the result of the evaluation is a function object, not the result of some instant calculation.

So writing:

(defn fun [] 1)

Is synonymous to:

(def fun (fn [] 1))