Assuming you use leiningen, this is exactly what :managed-dependencies is for

I have a monolithic project similarly structured to this and I use managed dependencies to ensure if several projects depend on X then they all use the exact same version specified in a root project.clj file

Thank you @U0479UCF48H!

It depends. If you're more likely to be accessing those maps by :id than by index, use a map of maps instead of a vector of maps.

Then (update-in data [12 :age] inc) will do what you need.

Otherwise, yes, map'ing a conditional update is probably the best you're going to do...

(into {} (map (juxt :id identity)) mymap) will give you the map of maps BTW.

right yes I guess it should be obvious to use a map of maps

thankyou!

need to learn juxt too

Assuming that you did need to keep this as a sequence for whatever reason, I think just pulling the transform function out from the map call helps a lot with the ugliness and readability problems of your example.

(let [transform
      #(if (= (% :id) 12)
              (update % :age inc)
              %)
 (map transform mymap)

(defn modify-if [pred f x]
                (if (pred x) (f x) x))

(let [id=12 #(= 12 (:id %))
      inc-age #(update % :age inc)
      inc-except-12 #(modify-if id=12 inc-age %)]
  (map inc-except-12 mymap))

yes that's definitely nicer. I'll do that for now as I'll have to do some substantial refactoring to make it use a map of maps.

didn't think to put function definitions in a let before for some reason

you can also change #(if (= (% :id) 12) (update % :age inc) %) into #(cond-> % (= (% :id) 12) (update :age inc)) which I think is pretty idiomatic to modify something conditionally and a little easier to extend if you add more modifications under more conditions

just adding this as a walk example

(->> mymap
     (clojure.walk/postwalk
       (fn [{:keys [id] :as form}]
         (cond-> form
           (= id 12) (update :age inc)))))

You can create a custom reader tag that would resolve a symbol.

edn is a text format. Can’t hold references to functions. Just put the symbol there and then map it to the var wherever you use the config

Thanks! I changed it to

:daemons/test                   {:heartbeat "xxx"
                                  :fn 'webapp.backend/email-daemon}

however

(resolve (:fn (env :daemons/test)))

returns nil

but

(resolve 'webapp.backend/email-daemon)

works in the repl

Try requiring-resolve.

Execution error (FileNotFoundException) at webapp.backend/eval84119 (backend.clj:120).
Could not locate 'webapp/backend__init.class, 'webapp/backend.clj or 'webapp/backend.cljc on classpath.

even though i'm running in the actual file

do I need to pass in an env to (resolve)?

So you need the apostrophe in the edn?

yeah. don’t quote your edn

table-test=> (resolve (:a (clojure.edn/read-string "{:a inc}")))
#'clojure.core/inc
table-test=> (resolve (:a (clojure.edn/read-string "{:a 'inc}")))
nil

ok that worked, I didn't realize the literal was a symbol already in the edn

thanks yall 🙂

Other approach to the problem: I added a reader called #clj/var - eg https://github.com/wardle/pc4/blob/main/pc4-server/resources/config.edn and https://github.com/wardle/pc4/blob/main/pc4-server/src/clj/com/eldrix/pc4/system.clj so that the var is resolved automatically by those ingesting the config data and they don’t need to be concerned re how resolved.