Given that both those calls to update use a constantly function, you can just use assoc with two kv pairs. And you can always combine multiple calls to update or any other functions with e.g. ->.

And the constantly function is not needed in this case because it is created newly on each iteration. So a (map (-> (update :created_at time-ago) (update :updated_at time-ago)) @data-combined) should be fine

Almost. Gotta turn that -> into a function. Either with #(...) and % or with (fn [...] ...). And yeah, I didn't notice that the same field was passed to time-ago so consequent application of update makes more sense than a single assoc.

You are right. I missed that. Sorry could not test on my laptop before posting …

Right! Thatnks. assoc worked for both, and now I changed it to this also and works too:

(map #(-> % (update :created_at time-ago) (update :updated_at time-ago)) @data-combined)

Can I also add a new key based on some condition in the map? Like a new key for each called :type ?

You can do anything with a combination of assoc/`update`/`dissoc`. There's also cond-> that might be useful. And condp. And many, many other things.

Okay yeah its working. Thanks a lot!! 🙏

remember that the thing passed to map is a full function, so you're allowed to use things like if, let, and other constructs like that within them.

I just ended up stringifying it and then parsing the json string

If you need a more performance, it's a few lines of code to parse into Clojure's data structures:

(defprotocol Parseable
  (parsed [x]))

(extend-protocol Parseable
  JsonArray
  (parsed [x]
    (into [] (map parsed x)))
  JsonObject
  (parsed [x]
    (into {} (map (fn [[k v]] [k (parsed v)]) x)))
  JsonNumber
  (parsed [x]
    (if (.isIntegral x)
      (.longValue x)
      (.doubleValue x)))
  JsonString
  (parsed [x]
    (.getString x))
  JsonValue
  (parsed [x]
    (case x
      JsonValue/TRUE true
      JsonValue/FALSE false
      JsonValue/NULL nil)))

(with-open [reader (Json/createReader (io/reader (io/resource "test.json")))]
  (parsed (.read reader)))

This worked great, though for some reason I couldn't extend the protocol to the JsonStructure interfaces, I had to extend to the classes that implement them. But that's fine, I don't need the flexibility. 👍

You can also use destructuring:

(let [{:keys [id]} peer]
  {:id id})

(select-keys peer [:id])

Depending on your sensibilities

I think select-keys is most idiomatic in this case.

clojure.core even 🙂

I must have been thinking of clojure.set/rename-keys