1

I am trying to create a kind of a reverted index from an input map. The input map I got is:

{"id-1" {"values" ["a" "b" "c"]}, "id-2" {"values" ["a" "b" "c"]}}

Then I want to have this other map as result:

{"a" ["id-1" "id-2"], "b" ["id-1" "id-2"], "c" ["id-1" "id-2"]}

However, I think that my mind did go crazy, and I think I painted myself into the corner without being able of thinking out of the box. Here is what I got so far, and it looks like that it stinks:

(->> {"id-1" {"values" ["a" "b" "c"]} "id-2" {"values" ["a" "b" "c"]}}
       (map #(->> (get (second %) "values")
              (map (fn [x y] (hash-map y x)) (into [] (repeat (count (get (second %) "values")) (first %))))
              (apply merge-with concat)))
       (apply merge-with concat))

Basically, I use a first map used to "iterate" over all my input values. Then I use a second map to create a series of individual maps that looks like that:

({"a" "id-2"} {"b" "id-2"} {"c" "id-2"} {"a" "id-1"} {"b" "id-1"} {"c" "id-1"})

To get to that map, I create an intermediary array using into [] (repeat ..) to feed to the map along with the array of values.

Then I merge them together to get my expected value.

Two issues here:

  1. This seems really much more complex than I have the intuition that it is

  2. The current end result is not yet perfect since I am getting this:

    {"a" (\i \d - \1 \i \d - \2), "b" (\i \d - \1 \i \d - \2), "c" (\i \d - \1 \i \d - \2)}

Improve this question

2 Answers 2

Reset to default
8

Using map destructuring:

(apply merge-with into (for [[k {vs "values"}] input, v vs] {v [k]}))

Clearer

(apply merge-with into
  (for [[k m] input
        v (get m "values")] 
    {v [k]}))
Improve this answer
Sign up to request clarification or add additional context in comments.

8 Comments

@a-webb this is really nice! But I am not sure I am fully getting it. Could you explain what happens with [[k {vs "values"}] input, v vs], I think it is the first time I see this destructuring syntax. What I understand is that k is bound to the keys id-x then vs get bound to the vector or values (not sure how {} affects the destructuring). But then, the , v vs, is this to destructure what you just destructured, so that v get bound with the value of the previous destructuring? If so, is there some documentation about this kind of destructuring syntax?
@Neoasimov This syntax, (let [{a-value :a} my-map]), is map destructuring, to bind the value of the :a key in the map to a-value. The , v vs, is a continuation of the for, as in (for [row [[1 2 3] [4 5 6]], element row] element) ;=> (1 2 3 4 5 6). The comma is just whitespace, more typically you'd see a linebreak and indentation.
@A.Webb I like this answer substantially better than the accepted one; as a matter of style I like (for [[k m] input, v (get m "values")] ...) a bit better, if only because it's a little unusual to use the explicit map-destructuring style.
+1 Agree, it's better than mine :-) Didn't know that you can use string keys to destructure a hash-map. I always thought it only works with symbols :-(
@sloth I think you mean keywords, not symbols. So cute!
|
2

Given this input:

(def input {"id-1" {"values" ["a" "b" "c"]}, "id-2" {"values" ["a" "b" "c"]}})

it's easier to do:

(defn extract [key values]
  (for [v (get values "values")] {v [key]}))

(->> input 
    (mapcat (partial apply extract))
    (apply merge-with concat))

or, without an additional function:

(->> (for [[k vs] input]
        (for [v (get vs "values")] {v [k]}))
     (flatten)
     (apply merge-with concat))

which works the way you intended.

The trick is to wrap key in a vector in the extract function so merge-with concat works without concatenating the strings.

Improve this answer

5 Comments

thanks, it works exactly as intended, and is certainly much much cleaner than what I did. However I am not clear on how partial works in that context, could you elaborate a bit on how it works there?
@Neoasimov It basically creates a function that takes an argument (or more) and then calls apply extract with that argument. Is nicer than #(apply extract %), IMHO.
ok good, thanks for the explanation. Yes, I noticed that variant, and I am analyzing it atm. This example was great for finding new ways working with that kind of data in Clojure, thanks! I got everything I needed and even more :)
maybe one last question, is there a way to get an array for the resulting values (currently a list; that is another issue I had with my tests). Would need to put into [] somewhere, but not sure where :|
Just change the last line to (apply merge-with (comp vec concat))). concat creates a lazy sequence, and you can then use vec to turn it into a vector.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.