Could it be merged upstream?

Sean, this is a bit off-topic but I noticed (reduce into #{}) in the gist. Is there any specific reason you use that instead of (into #{} cat)? It's the second time I notice this use of into with reduce today. Also, the entire thread this is part of could be run as a transducer inside an into, any reason you aren't using that?

No real reason. I built the code up incrementally and just threaded it together. It was pretty much scratch code so I didn't spend any time refactoring it.

@U08BJGV6E You made me curious so I changed it to a transducer form -- but it isn't quite (into #{} cat) -- because it needs to cat items to get a flat collection and then remove certain things. Here's the old code:

(->> all-files
              (filter #(str/ends-with? (str %) "/deps.edn"))
              (map #(t/slurp-deps %))
              (map #(into (set (when-not (= :test type) (:deps %)))
                          (set (when-not (= :dev  type)
                                 (-> % :aliases :test :extra-deps)))))
              (reduce into #{})
              ;; just the actual libraries:
              (remove #(:local/root (val %)))
              (set))

(into #{}
               (comp
                (filter #(str/ends-with? (str %) "/deps.edn"))
                (map #(t/slurp-deps %))
                (mapcat #(into (set (when-not (= :test type) (:deps %)))
                               (set (when-not (= :dev  type)
                                      (-> % :aliases :test :extra-deps)))))
                ;; just the actual libraries:
                (remove #(:local/root (val %))))
               all-files)

There were a few other ->> expressions that could easily become (into #{} xf all-files):

sources   (into #{}
                        (comp
                         (filter #(str/ends-with? (str %) "/src"))
                         ;; we want just the project folders:
                         (map #(str/replace (str %) #"/src$" "")))
                        all-files)
        tests     (into #{}
                        (comp
                         ;; but we do want test folders:
                         (filter #(str/ends-with? (str %) "/test"))
                         (map str))
                        all-files)

And this one further down in the gist:

{:missing-dev-deps
     ;; verify all source :local/root deps are present:
     (set/difference
      sources
      (into #{}
            (comp (filter :local/root) (map :local/root) (map #(str root %)))
            (-> root-deps :aliases :dev :extra-deps (vals))))

I updated the Gist https://gist.github.com/seancorfield/f7aeb115b33f13cc21f8dbbf4f408706/revisions

Nice! Using transducers (mostly with into) became a habit for me in the past few years and I was curious if there was a hidden caveat against them here. The first form after your refactor ended up almost what I had in mind (I might have left map and cat different steps)

I need to get into the habit of using transducers in my RCFs when I'm gradually building code up. That way I don't have to remind myself to refactor a ->> pipeline into transducers after the fact 🙂