You'll want to us a combination of update, assoc, and map

(let [m {:cast "muppets"
        :characters
        [{:name    "kermit"
          :address "foo"}
         {:name    "gonzo"
          :address "faa"}
         {:name    "pepe"
          :address "fii"}]}
    m (update m :characters (fn [characters]
                                (map (fn [character]
                                        (if (= (:name character) "gonzo")
                                        (assoc character :address "sesame street")
                                        character)))))]
;; m now has the updated nested map
)

the alternative is to no keep characters as

[{:name "kermit"
   :address "foo"}
  {:name "gonzo"
   :address "faa"}
  {:name "pepe"
   :address "fii"}]

{id {:name "kermit"
   :address "foo"}
id2   {:name "gonzo"
   :address "faa"}
}

right, if your characters were a map keyed by name or id or whatever, it changes it quite a bit

where id can be for example a :name

(let [m {:cast "muppets"
           :characters
           {:kermit {:name    "kermit"
                     :address "foo"}
            :gonzo  {:name    "gonzo"
                     :address "faa"}
            :pepe   {:name    "pepe"
                     :address "fii"}}}
        m (update-in m [:characters :gonzo :address] "sesame street")]
;; m now has the updated nested map
)

Much simpler, for sure

I'm using something in the lines of:

(defn- index-of [pred coll]
  (first (keep-indexed #(when (pred %2) %1) coll)))
.....
   (let [idx (index-of #(= (:name %) muppet) (get-in m [:characters]))]
     (assoc-in db [:characters idx :address] address))))

I just don't know if it idiomatic / good practice

in my personal taste simplicity is always on the first place. Unless it has to be be really good performance, then it can be a little more complex, but not too much 😉

others may have a different view, but I tend to arrange my data structures as maps if I need keyed access/update into them. You're traversing the data structure several times, first to get the index, and then to do the assoc-in. Obviously depending on the size of the structure that may be cumbersome

though of course if your data is coming from some source in that format, you'll have to traverse it to make it accessible, so perhaps it's not as problematic?

in other words answer yourself what is simpler and more readable for you

Thanks for the suggestions guys

(defn group-by-key
    [k ms]
    (reduce (fn [acc m] (assoc acc (get m k) m))
            {}
            ms))

  (group-by-key :name [{:name :foo}
                       {:name :bar}])
  ;; => {:foo {:name :foo}, :bar {:name :bar}}

  (def local-data (atom (-> data-from-source
                            (update :characters (partial group-by-key :name)))))

  (def update-character
    [name address]
    (swap! local-data
           (fn [data]
             (update-in data
                        [:characters name :address]
                        address)))

Code below not tested: If you want to use the index, you can at least take advantage to short circuit on a match.

(defn index-of [pred coll]
  (some (fn [i] (and (pred (coll i)) i)) (range (count coll))))

(update m :characters
  #(map (fn [c]
                  (if (pred c) (transform c) c))
               %))

If you don’t mind bringing in Specter as a dependency, you could do something like this: (Specter/transform [:characters ALL (pred #(= (:name %) "gonzo"))] #(assoc % :address "Sesame Street") <data>). This is totally untested, so might even be wrong, but Specter is built to handle this sort of nested transforms and selects.

Maybe it used to be a part of luminus… I can check there

Maybe not

That is the default log format that java.util.logging produces

time class method level message

but it shouldn’t be clojure.tools.logging$eval3401$fn__3404, but the ns$fn from my code right?