Avoiding global state in DAO layer of a Clojure application

Question

I'm trying to implement the ideas from http://thinkrelevance.com/blog/2013/06/04/clojure-workflow-reloaded into my codebase.

I have a dao layer, where I now need to pass in a database in order to avoid global state. One thing that is throwing me off is the phrase:

Any function which needs one of these components has to take it as a parameter. This isn't as burdensome as it might seem: each function gets, at most, one extra argument providing the "context" in which it operates. That context could be the entire system object, but more often will be some subset. With judicious use of lexical closures, the extra arguments disappear from most code.

Where should I use closures in order to avoid passing global state for every call? One example would be to create an init function in the dao layer, something like this:

(defprotocol Persistable
  (collection-name [this]))

(def save nil)

(defn init [{:keys [db]}]
  (alter-var-root #'save (fn [_] (fn [obj] (mc/insert-and-return db (collection-name obj) obj WriteConcern/SAFE)))))

This way I can initiate my dao layer from the system/start function like this:

(defn start
  [{:keys [db] :as system}]
  (let [d (-> db
              (mc/connect)
              (mc/get-db "my-test"))]
    (dao/init d)
    (assoc system :db d)))

This works, but it feels a bit icky. Is there a better way? If possible I would like to avoid forcing clients of my dao layer to have to pass a database every time it uses a function.

Answer 1

You can use higher order function to represent your DAO layer - that's the crux of functional programming, using functions to represent small to large parts of your system. So you have a higher order function which takes in the DB connection as param and return you another function which you can use to call various operations like save, delete etc on the database. Below is one such example:

(defn db-layer [db-connection]
  (let [db-operations {:save (fn [obj] (save db-connection obj))
                       :delete (fn [obj] (delete db-connection obj))
                       :query (fn [query] (query db-connection query))}]
    (fn [operation & params]
      (-> (db-operations operation) (apply params)))))

Usage of DB layer:

(let [my-db (create-database)
      db-layer-fn (db-layer my-db)]
  (db-layer-fn :save "abc")
  (db-layer-fn :delete "abc"))

This is just an example of how higher order functions can allow you to sort of create a context for another set of functions. You can take this concept even further by combining it with other Clojure features like protocols.