Question

the motivation is for checking what has changed in a deeply nest map, kind of like a reverse of update-in.

This is a simple example:

(def p1 {:a {:a1 :1 :a2 :2}
         :b {:b1 :1 :b2 :2}})

(def p2 (update-in p1 [:a :a1] (constantly :updated))
;; => {:a {:a1 :updated :a2 :2}
;;     :b {:b1 :1 :b2 :2}}

(what-changed? p1 p2) 
;; => {:keys [:a :a1] :value :updated)

(what-changed? p2 p1) 
;; => {:keys [:a :a1] :value :2)

I’m hoping that because clojure maps are persistent data-structures, there may be a smart algorithm to figure this out by looking at the underlying structure as opposed to walking through the nested maps and comparing the difference.

Answer 1

Persistent data structures is only about implementation and not about “looking at the underlying structure”.
As Joost said (+1) you can use “diff”. It only needs to convert the answer using your “{:keys … :value …}” pattern:

(def p1 {:a {:a1 :1 :a2 :2}
         :b {:b1 :1 :b2 {:b11 :11 :b22 :22}}})

(def p2 {:a {:a1 :updated1 :a2 :2}
         :b {:b1 :1 :b2 {:b11 :updated2 :b22 :updated3}}})

(defn what-changed?* [m]
  (if (not (map? m))
    [(list m)]
    (apply concat (map (fn [k]
                         (map (fn [nest-k]
                                (conj nest-k k))
                              (nested-keys (m k))))
                       (keys m)))))

(defn what-changed? [m1 m2]
  (map (fn [l] {:keys (drop-last l) :value (last l)})
       (nested-keys (second (data/diff m1 m2)))))

Test:

(what-changed? p1 p2)
-> ({:keys (:a :a1), :value :updated1}
    {:keys (:b :b2 :b11), :value :updated2}
    {:keys (:b :b2 :b22), :value :updated3})

(what-changed? p2 p1)
-> ({:keys (:a :a1), :value :1}
    {:keys (:b :b2 :b11), :value :11}
    {:keys (:b :b2 :b22), :value :22})

BTW in your case you can modify hashmap by “assoc-in” instead of “update-in”:

(assoc-in {:a {:a1 :1 :a2 :2}
           :b {:b1 :1 :b2 :2}}
          [:a :a1] :updated)
-> {:a {:a2 :2, :a1 :updated}
    :b {:b2 :2, :b1 :1}}