It's kind of hard to tell what you're trying to do. The data format from your example looks really awkward. I might try to normalize it or even put it in a database. Having said that, I often use a library called https://grishaev.me/en/zippo/ for generic search. You can use it something like:

(require
 '[clojure.zip :as z]
 '[zippo.core :as zippo])

(def data
  [[:a [:foo "y" :matches [[:bar "x" :matches [:baz "b" :line "this is what i want"]]]]]
   [:b [:foo "y" :matches [[:bar "x" :matches [:baz "b" :line "this is what i want"]]]]]])

(->> (zippo/loc-find-all
      (z/vector-zip data)
      ;; find all the :line keywords
      (zippo/->loc-pred #(= :line %)))
     ;; navigate to the next element in the structure
     (map (fn [zv]
            (z/next zv)))
     ;; unwrap the data
     (map z/node))
;; ("this is what i want" "this is what i want")

this is helpful, thank you!

Use for

Nested maps, calling concat, that is all for

This just general info. I have not delved into your example at all to see if fit fits your specific case: If you ignore the automatic coercion of Seqable -> Seq (and of course follow the practice of not injecting side-effects), then map holds the property of being associative. This means that, in general, you can always replace mapping fn f over the result of mapping g with instead just mapping the composition of f and g . All the following should return the same output, with the number of traversals required being the only meaningful difference.

; 3 traversals
(map f (map g (map h m)))

; 3 traversals
(->> m (map h) (map g) (map f)

; 2 traverals
(map f (map (comp g h) m))

; 2 traversals
(map (comp f g) (map h m))

; 1 traversal
(map (comp f g h) m)

; 1 traversal
(map #(-> % h g f) m)

Map is also lazy

So traversal accounting is not an open and shut case

So the 3 traversal case may result in more allocations, but is still O(count(m)) not 0(count(m)*3)

fair points

Regardless, upon full realization, there should be no difference in the final results of any above. 😉

clojure.walk is helpful for when you know the shape of the data fragment you care about working on, but don't know/care where it is in your data

I would also look into: https://github.com/redplanetlabs/specter . There are some great youtube videos on it showing how it works in practice.

And if you are looking to reshape your data so that you can put it in a database or use a dataset (from http://Tech.Ml) this is a great library as well: https://github.com/turtlegrammar/faconne

Yes, or just use a regular channel, depending

Same as with any other blocking op – wrap it in a thread: (go ... (<! (thread @my-promise))) (but if you can use a promise-chan instead that's even better)