Question

I’ve noticed while on my quest to lean functional programming that there are cases when parameter lists start to become excessive when using nested immutable data structures. This is because when making an update to an object state, you need to update all the parent nodes in the data structure as well. Note that here I take “update” to mean “return a new immutable object with the appropriate change”.

e.g. the kind of function I have found myself writing (Clojure example) is:

(defn update-object-in-world [world country city building object property value]
  (update-country-in-world world
    (update-city-in-country country
      (update-building-in-city building
        (update-object-in-building object property value))))) 

All this to update one simple property is pretty ugly, but in addition the caller has to assemble all the parameters!

This must be a fairly common requirement when dealing with immutable data structures in functional languages generally, so is there a good pattern or trick to avoid this that I should be using instead?

Answer 1

There are two approaches that I know of:

Collect multiple parameters in some sort of object that is convenient to pass around.
Example:

; world is a nested hash, the rest are keys
(defstruct location :world :country :city :building)
(defstruct attribute :object :property)

(defn do-update[location attribute value]
  (let [{:keys [world country city building]} location
        {:keys [object property]} attribute ]
    (update-in world [country city building object property] value)))

This brings you down to two parameters that the caller needs to care about (location and attribute), which may be fair enough if those parameters do not change very often.

The other alternative is a with-X macro, which sets variables for use by the code body:

(defmacro with-location [location & body] ; run body in location context
  (concat
    (list 'let ['{:keys [world country city building] :as location} `~location])
    `(~@body)))

Example use:
(with-location location (println city))

Then whatever the body does, it does to the world/country/city/building set for it, and it can pass the entire thing off to another function using the “pre-assembled” location parameter.

Update: Now with a with-location macro that actually works.