map operations

Code

;; map_ops.clj

(defn maps-op ([func map-1 map-2 default-value]
               (let [map-1-keys (keys map-1)
                     map-2-keys (keys map-2)
                     keys (distinct (concat map-1-keys map-2-keys))]
                 (->> (map #(assoc {} %
                                   (func
                                    (get map-1 % default-value)
                                    (get map-2 % default-value))) keys)
                      (apply merge))))
  ([func map-1 map-2]
     (maps-op func map-1 map-2 nil)))

(defn map-op
  ([func map-1]
   (let [keys (keys map-1)]
     (->> (map #(assoc {} %
                       (func
                        (get map-1 %))) keys)
          (apply merge))))
  ([func m val]
   (maps-op func m {} val)))

(maps-op + {:a 1 :b 2 :c 5} {:a 3 :b 4} 0)
;;=> {:a 4, :b 6, :c 5}

(maps-op + {:a 1 :b 2} {:a 3 :b 4})
;;=> {:a 4, :b 6}

(map-op + {:a 1 :b 2 :c 5} 5)
;;=> {:a 6, :b 7, :c 10}

(map-op inc {:a 1 :b 2 :c 5})
;;=> {:a 2, :b 3, :c 6}

;; how it works 

(def map-1 {:a 1 :b 2})
(def map-2 {:a 3 :b 4})

(def map-1-keys (keys map-1))

map-1-keys
;;=> (:a :b)

(def map-2-keys (keys map-2))

map-2-keys
;;=> (:a :b)

(distinct (concat map-1-keys map-2-keys))
;;=> (:a :b)

(+ (get map-1 :a) (get map-2 :a))
;;=> 4

(assoc {} :a
       (+ (get map-1 :a) (get map-2 :a)))

;;=> {:a 4}
                         
(def func +)

(map #(assoc {} %
              (func
               (get map-1 %)
               (get map-2 %))) '(:a :b))
;;=> ({:a 4} {:b 6})

(merge {:a 4} {:b 6})
;;=> {:a 4, :b 6}

(apply merge [{:a 4} {:b 6}])
;;=> {:a 4, :b 6}