Q:

Simple "R-like" melt : better way to do?

Today I tried to implement a "R-like" melt function. I use it for Big Data coming from Big Query.
I do not have big constraints about time to compute and this function takes less than 5-10 seconds to work on millions of rows.
I start with this kind of data :
(def sample 
  '({:list "123,250" :group "a"} {:list "234,260" :group "b"}))

Then I defined a function to put the list into a vector :
(defn split-data-rank [datatab value]
  (let [splitted (map (fn[x] (assoc x value (str/split (x value) #","))) datatab)]
    (map (fn[y] (let [index (map inc (range (count (y value))))] 
                  (assoc y value (zipmap index (y value))))) 
         splitted)))

Launch :
(split-data-rank sample :list)

As you can see, it returns the same sequence but it replaces :list by a map giving the position in the list of each item in quoted list.
Then, I want to melt the "dataframe" by creating for each item in a group its own row with its rank in the group.
So that I created this function :
(defn split-melt [datatab value]
  (let [splitted (split-data-rank datatab value)]
    (map (fn [y] (dissoc y value))
      (apply concat
        (map
          (fn[x]
            (map
              (fn[[k v]]
                (assoc x :item v :Rank k))
              (x value)))
     splitted)))))

Launch :
(split-melt sample :list)

The problem is that it is heavily indented and use a lot of map. I apply dissoc to drop :list (which is useless now) and I have also to use concat because without that I have a sequence of sequences.
Do you think there is a more efficient/shorter way to design this function ?
I am heavily confused with reduce, does not know whether it can be applied here since there are two arguments in a way.
Thanks a lot !

A:

If you don't need the split-data-rank function, I will go for:
(defn melt [datatab value]
  (mapcat (fn [x]
            (let [items (str/split (get x value) #",")]
              (map-indexed (fn [idx item]
                             (-> x
                                 (assoc :Rank (inc idx) :item item)
                                 (dissoc value)))
                           items)))
          datatab))

