Will the clojure compiler automatically evaluate expressions of literals at compile time?

Question

This might be a silly question, but:

Suppose an expression depends only on literals, or on other expressions that also only depend on literals; will the compiler evaluate this at compile time?

Suppose I have,

(def a (some-time-consuming-function some-literal))

(def b (some-other-time-consuming-function a))

Will both b and a be evaluated completely at compile time, so that the User isn't affected?

EDIT: Thanks very much, all of the answers were very helpful.

Answer 1

In your example, the time-consuming functions are called only once, when your code is loaded.

The Clojure compiler does not try to optimize constant expressions, but the Java JIT compiler may do so in some cases.

Answer 2

Firstly, there is a pretty important reason why the right-hand-sides of defs need to be evaluated at load time: they might depend on the environment somehow and in the general case it's impossible to tell whether they do or not. Take e.g.

(def *available-processors* (.availableProcessors (Runtime/getRuntime)))

Secondly, here's one approach to testing what actually happens:

1. Create a test project with Leiningen -- say, lein new testdefs.

2. Put :main testdefs.core in project.clj.

3. Put the following in src/testdefs/core.clj:

   (ns testdefs.core
     (:gen-class))
   
   
   (defn take-your-time [t]
     (printf "Taking my time (%d)...\n" t)
     (Thread/sleep t))
   
   
   (def a (take-your-time 5000))
   
   
   (defmacro frozen-def [v e]
     (let [val (eval e)]
       `(def ~v ~val)))
   
   
   (frozen-def b (take-your-time 5000))
   
   
   (defn -main [& args]
     (println "Starting...")
     (println a)
     (println b))
   

4. Run lein uberjar; surely enough, the code takes its time twice.

5. Run java -jar testdefs-1.0.0-SNAPSHOT-standalone.jar; you'll notice the code only takes its time once.