From what I can tell, it's a pretty common practice for when you need to have such optional functionality that doesn't make sense as a separate package.

Ok, thank you !

I wrote a for-map macro for myself at one point

Not that what you’ve said is necessarily bad, but there are options. For instance:

(zipmap (map some-function some-seq) some-seq)

So that would look like

(for-map [el some-seq]
  [el (some-function el)])

(into {} (map (juxt identity f)) the-seq) also, if you pull that into a helper that takes f and the seq the call sites could be quite trim

Ooops, I mixed up key/value (narrow screen):

(zipmap some-seq (map some-function some-seq))

There is also a map vals somewhere for simple cases (idk if there is a standard one yet)

Looking at some of the suggestions, it appears that every version here creates a temporary vector (which is extremely common in Clojure, and not a big deal), with the exception of zipmap. Both zipmap and everything else uses transient maps. The only real difference is that zipmap loops through using assoc!, while using into loops through using conj! (which accepts the 2 element vector)

for-map doesn’t need to - it just needs a syntax literal vector - it can translate to zipmap like stuff hypothetically

Thanks for the ideas!

You can use reduce: (reduce #(assoc %1 %2 (some-fn %2)) {} some-seq))

Yes! Though the advantage of using into or zipmap is the transient. So:

(persistent! (reduce #(assoc! %1 %2 (some-fn %2)) (transient {}) some-seq)))

bound-fn?

Ah, yeah, that should work. Thanks!

There was some subtle difference between them that I don’t remember now You can also use #’binding-conveyor-fn