Update values of keys in a sequence of maps from the values of first map's keys

I have a sequence of maps like this:

({:autoNo "1" :title "Title1" :47652 ("name1") :47653 ("name2" "name3")} {:autoNo nil :title nil :47652 nil :47653 nil})

Only the first map contains the values for file-upload-field keys :47652 and :47653 whereas the value of same keys in the second map is nil. What I want is file-upload-field keys having only one name of file value per map like this:

({:autoNo "1" :title "Title1" :47652 "name1" :47653 "name2"} {:autoNo nil :title nil :47652 nil :47653 "name3"})

You can see above as :47652 have only one value in the seq so its value get updated whereas the value of the same key in the next map remains nil. For :47653 having multiple values, the key in first map contains the first value i.e. "name2" whereas the same key in the second map of the sequence contains the next value i.e. "name3".

To achieve so I have created a function like this:

(defn update-file-upload-field-values
  [conversation-instances]
  (let [file-field-ids [:47652 :47653]]
    (first (map (fn [x]
                  (map
                   #(update %1 x (fn [z] (str %2)))
                   conversation-instances ((first conversation-instances) x)))
                file-field-ids))))

where conversation-instances is the same sequence of maps stated at the beginning.

My solution is not working as expected. It is returning this:

({:autoNo "1" :title "Title1" :47652 "name1" :47653 ("name2" "name3")})

Which is different from the expected output shown at the beginning.

You call map with two sequences (conversation-instances and the result of ((first conversation-instances) x)), so the result will be as long as the shortest of them. I also think you can replace update with assoc.

Two nested maps with first also create some result you probably don't want. I suggest you to write your functions step by step, testing each increment in REPL, so you know whether your function does what you expect.

You can use reduce to solve this. My update-maps is similar to your inner map, I just added reduce to repeat it for each given key:

(def data '({:autoNo "1" :title "Title1" :47652 ("name1") :47653 ("name2" "name3")}
            {:autoNo nil :title nil :47652 nil :47653 nil}))

(defn update-maps [coll k]
  (let [values-seq (k (first coll))]
    (mapv #(assoc %1 k %2)
          coll
          (concat values-seq (repeat nil)))))

(defn keys-fn [coll]
  (let [ks [:47652 :47653]]
    (reduce update-maps
            coll
            ks)))

(keys-fn data)
=>
[{:autoNo "1", :title "Title1", :47652 "name1", :47653 "name2"} {:autoNo nil, :title nil, :47652 nil, :47653 "name3"}]

(require '[com.rpl.specter :as s])
(use '[plumbing.core])

(let [data         '({:autoNo "1" :title "Title1" :47652 ("name1") :47653 ("name2" "name3")}
					 {:autoNo nil :title nil :47652 nil :47653 nil})]
	(->> data
		(s/transform (s/subselect 
展开收缩
)]) aconcat)
		(s/transform (s/subselect 
展开收缩
)]) aconcat)))

basically, what you could do is something like this:

(map assoc data
     (repeat :47652)
     (concat (:47652 (first data)) (repeat nil))
     (repeat :47653)
     (concat (:47653 (first data)) (repeat nil)))

;;=> ({:autoNo "1", :title "Title1", :47652 "name1", :47653 "name2"}
;;    {:autoNo nil, :title nil, :47652 nil, :47653 "name3"})

to get rid of repetition you can do something like that:

(defn ks-vs [[k vs]] 
  [(repeat k) (concat vs (repeat nil))])

(defn process [[head :as data]]
  (->> (select-keys head [:47652 :47653])
       (mapcat ks-vs)
       (apply map assoc data)))

(process data)

;;=> ({:autoNo "1", :title "Title1", :47652 "name1", :47653 "name2"}
;;    {:autoNo nil, :title nil, :47652 nil, :47653 "name3"})

which is basically more abstract variant based on the same approach.

I hate to answer a question other than what was asked but in your question, the second map in the list appears to be derived from the first and is thus not needed.

Also many (but not all) of the current answers appear to hardcoded information i.e. keys or length of maximum items.

I think there are 3 solutions:

1. loop recur
2. lazy mapping
3. stateful transducer.

That being said I'll offer up a "lazy" solution that has neither the keys or lengths hard coded in:

(->> '{:autoNo "1" :title "Title1" :47652 ("name1") :47653 ("name2" "name3" "name4") :9999 ("foo9" "bar9")}
     (mapcat (fn [[k v]]
               [(repeat k)
                (if (coll? v)
                  (concat v (repeat nil))
                  (cons v (repeat nil)))]))
     (apply map hash-map)
     (take-while #(some second %)))

which should yield something like:

[{:47652 "name1" :47653 "name2" :9999 "foo" :autoNo "1" :title "Title1"}
 {:47652 nil     :47653 "name3" :9999 "bar" :autoNo nil :title nil}
 {:47652 nil     :47653 "name4" :9999  nil  :autoNo nil :title nil}]