combinación idiomática de mapas en un mapa de conjuntos de valores con clojure

Question

Estoy intentando combinar de manera idiomática varios mapas en un solo mapa usando clojure.

entrada

{:a 1 :b "a"} 
{:a 2 :b "b"} 
{:a 3 :b "c"} 
{:a 4 :b "a"} 

preverse

{:a #{1,2,3,4}, :b #{"a" "b" "c"}} 

Los valores para cada clave se convierten en un conjunto de valores en los mapas originales.

Answer 1

que haría uso de merge-with, utilizando una estructura pre-construidos que contiene conjuntos vacíos:

(def data [{:a 1 :b "a"} 
      {:a 2 :b "b"} 
      {:a 3 :b "c"} 
      {:a 4 :b "a"}]) 

(let [base {:a #{} :b #{}}] 
    (apply merge-with conj base data)) 

=> {:a #{1 2 3 4}, :b #{"a" "b" "c"}} 

El truco de utilizar conjuntos vacíos en el mapa base es para que conj tenga un objeto concreto sobre el cual trabajar, y por lo tanto funciona correctamente.

Answer 2

merge-with se puede utilizar para esto como:

(def d [{:a 1 :b "a"} 
     {:a 2 :b "b"} 
     {:a 3 :b "c"} 
     {:a 4 :b "a"}]) 

(def initial (into {} (map #(vector %1 []) (keys (apply merge d))))) 

(into {} (map (fn [[a b]] [a (set b)]) 
      (apply merge-with (fn [a b] (conj a b)) initial d))) 

Answer 3

(defn value-sets [& maps] 
    (reduce (fn [acc map] 
      (reduce (fn [m [k v]] 
         (update-in m [k] (fnil conj #{}) v)) 
        acc 
        map)) 
      {} maps)) 

Edición o tal vez

(defn value-sets [& maps] 
    (reduce (fn [acc [k v]] 
      (update-in acc [k] (fnil conj #{}) v)) 
      {} 
      (apply concat maps))) 

---

hacer otras modificaciones, muchos años después: Me gustaría escribir esto de manera diferente ahora:

(defn value-sets [maps] 
    (apply merge-with into (for [m maps, [k v] m] 
          {k #{v}}))) 

Answer 4

Al ver la solución de amalloy implica reduce sugirió este para mí:

(def maps [{:a 1 :b 2} 
      {:a 11 :b 22 :c 5} 
      {:c 6 :a 7}]) 

(defn my-merge-maps 
    [maps] 
    (reduce (fn [accum [k v]] 
      (if (accum k) 
       (assoc accum k (conj (accum k) v)) 
       (assoc accum k #{v}))) 
      {} 
      (apply concat maps))) 

(defn -main 
    [] 
    (println (my-merge-maps maps))) 

El resultado es: {:C#{5 6}, :b #{2 22}, :a #{1 7 11}}

(gfredericks gracias por señalar que estaba usando accidentalmente varargs. :))

Editar: Y aquí hay otra manera, utilizando merge-with:

(def maps [{:a 1 :b 2} 
      {:a 11 :b 22 :c 5} 
      {:c 6 :a 7}]) 

(defn build-up-set 
    [curr-val new-val] 
    (if (set? curr-val) 
    (conj curr-val new-val) 
    #{curr-val new-val})) 

(defn my-merge-maps 
    [maps] 
    (apply merge-with build-up-set maps)) 

(defn -main 
    [] 
    (println (my-merge-maps maps))) 

Answer 5

Y aquí es un método pipeline:

(defn my-merge-maps [stuff] 
    (->> stuff 
     (apply concat) 
     (group-by first) 
     (map (fn [[k vs]] [k (set (map second vs))])) 
     (into {}))) 

Podría ser este hecho en los mapas si tuviéramos la derecha funciones centrales para manipularlos?

Answer 6

(def data [{:a 1 :b "a"} 
      {:a 2 :b "b"} 
      {:a 3 :b "c"} 
      {:a 4 :b "a"}]) 

(apply 
    merge-with 
    clojure.set/union 
    (map #(zipmap (keys %) (map hash-set (vals %))) data)) 
;{:b #{"a" "b" "c"}, :a #{1 2 3 4}} 

Answer 7

Amalloy redujo la siguiente solución en el mismo problema en el IRC ayer:

(defn value-sets [& maps]              
    (apply merge-with into (for [m maps, [k v] m] {k #{v}})))