Question

Based on command-line input, I need to set some run-time constants which a number of downstream functions are going to use. The code in those functions may execute in other threads so I am not considering the “declare var and use binding macro” combination. What are the pros/cons of using a var (with alter-var-root) for this versus using an atom? That is,

(declare *dry-run*) ; one of my constants

(defn -main [& args]
   ; fetch command line option
   ;(cli args ...)
   (alter-var-root #'*dry-run* (constantly ...))
   (do-stuff-in-thread-pool))

versus

(def *dry-run* (atom true))   

(defn -main [& args]
   ; fetch command line option
   ;(cli args ...)
   (reset! *dry-run* ...)
   (do-stuff-in-thread-pool))

If there is another option besides these two which I should consider, would love to know.

Also, ideally I would’ve preferred not to provide an initial val to the atom because I want to set defaults elsewhere (with the cli invocation), but I can live with it, especially if using the atom offers advantages compared to the alternative(s).

Answer 1

Write-once values are exactly the use case promises are designed for:

(def dry-run (promise))

(defn -main []
  (deliver dry-run true))

(defn whatever [f]
  (if @dry-run
    ...))