Impressed, I thought “What would that look like in Clojure?” After a few questions in #beginners I ended up with

(ns map-comp.core
  (:require [clojure.pprint]
            [clojure.string :refer [split]]))

;; Functions to replicate python's os.walk functionality

(def directory? (memfn ^java.io.File isDirectory))
(def list-files (memfn ^java.io.File listFiles))

(defn separate-dirs-from-files
  [files-list]
  (reduce (fn [[dirs files] file]
            (let [name (.getName file)]
              (if (directory? file)
                [(conj dirs name) files]
                [dirs (conj files name)])))
          []
          files-list))

(defn build-file-tree
  [^java.io.File file]
  (cons file
        (separate-dirs-from-files (list-files file))))

(defn file-tree-seq
  [root-dir]
  (->> root-dir
       ()
       (file-seq)
       (filter directory?)
       (map build-file-tree)))

;; Replicates the functionality of the python snippet

(defn relative-name
  [path dir]
  (let [dir-path (str dir)]
    (string/replace dir-path (re-pattern path) "")))

(defn directory-with-no-files?
  [[file dirs files]]
  (empty? files))

(defn pair-file-with-dirs
  [root-path [file dirs]]
  [(relative-name root-path (.getPath file))
   (vec dirs)])

(defn dir->map
  [root-path]
  (->> (file-tree-seq root-path)
       (drop 1)
       (filter directory-with-no-files?)
       (map #(pair-file-with-dirs root-path %))
       (into {})
       (clojure.pprint/pprint)))

(comment
 (dir->map "/Users/jay/Projects/map-comp/test/fixtures"))

Realizing that is just not the same I realized I could write a library that behaves like Python’s os.walk, then another library to add map comprehension as a macro:

(ns example.core
  (:refer-clojure :exclude [replace])
  (:require [file-tree.core :refer [walk-seq]]
            [for-map.core :refer [for-map]]
            [clojure.string :refer [replace]]
            [clojure.pprint :refer [pprint]]))

(defn relative-name
  [root path]
  (replace path (re-pattern root) ""))

(def root-dir "/Users/jay/Downloads/test/resources")

(for-map [[path dirs filenames] (walk-seq root-dir)
          :let [parent (relative-name root-dir path)]
          :when (and parent (empty? filenames))]
 {parent dirs}))

In retrospect it’s kind of a shit story. Needs a better villain… which I’m pretty sure is me. But it is my first published macro!

Any story involving significant learning is a good one in my book.

I did learn a lot. It REALLY reinforced that Clojure code is just data and that with tools like macros, we can evolve the language to our problems. If it’s valuable, it will catch on; otherwise, time will pass it by. It will still work for a while probably, even without maintenance. There’s something beautiful about that.

Wait, I wrote a for-map today

(defmacro for-map
  "Shortcut for putting the results of a for block into
  a map. Requires that each iteration in the for resolve
  to a vector of two items [key value].

  (for-map [x (range 3)]
    [x (inc x)])
  ;; => {0 1, 1 2, 2 3}

  (for-map [x (range 8)
            :when (even? x)]
    [x (* x x)])
  ;; => {0 0, 2 4, 4 16, 6 36}"
  [bindings & exprs]
  (when-not (vector? bindings)
    (throw (IllegalArgumentException.
             "for-map requires bindings to be in a vector.")))
  (when-not (even? (count bindings))
    (throw (IllegalArgumentException.
             "for-map requires an even number of forms in binding vector.")))

  `(into {}
         (for ~bindings
           (let [result# (do [email protected])]
             (if-not (and (vector? result#) (= (count result#) 2))
               (throw (IllegalArgumentException.
                        (str "The expression in a for-map must evaluate to a vector of two items. "
                             "Got "
                             result#)))
               result#)))))

not even joshing

@U3JH98J4R Hah! That’s awesome. Mine is a very naive implementation https://github.com/jayzawrotny/for-map/blob/master/src/for_map/core.clj

Should I be validating from a macro similarly to yours?

I think validating what you can statically is nice, since errors during macro expansion are annoying. I have one check in there which occurs at runtime, which is not ideal. I am considering maybe restricting the macro even more by making it so that the body of for-map has to be a 2 item vector at macro time

Compare the errors I get with my macro with and without the explicit checks

clojure
;; Without explicit error check
(for-map [a (range 10)]
         (list a (inc a)))
Execution error (ClassCastException) at rubidium.quotes/eval9283 (form-init5967951676652970669.clj:1).
java.lang.Long cannot be cast to java.util.Map$Entry

;; With explicit error check
(for-map [a (range 10)]
         (list a (inc a)))
Execution error (IllegalArgumentException) at rubidium.quotes/eval9476$iter$fn$fn (form-init5967951676652970669.clj:1).
The expression in a for-map must evaluate to a vector of two items. Got (0 1)

@U3JH98J4R Thank you, that makes sense, the second one is a lot more clear. I’ll add some similar validation if nothing else but for practice. I take it static validation means before the macro returns a list of expressions?

Also, we even used the same examples in our documentation. Craziness.