Check for the presence of multiple files

Question

Given the following code, I have written a for loop that returns a key and value (0 or 1) of file names passed. 1 means present, and 0 means not present.

Is there a way to construct a flat map without having to use into?

(defn kind-stat
  [filename expected-type]
  (let [f (File. filename)
        s (cond
              (.isFile f)      "f"
              (.isDirectory f) "d"
              (.exists f)      "o" 
              :else            "n" )]

      (if (= expected-type s)
        0
        1)))

(defn look-for 
  [filename expected-type]
    (let [find-status (kind-stat filename expected-type)]
      find-status))

(defn all-files-present?
"Takes a list of real file names, and returns a sequence of maps 
 indicating the file name and its availability status 1 for present 
 and 0 for not present. Please note look-for returns 0 for success, 
 so its return logic needs to be reversed for the return sequence 
 of maps."
  [file-seq]
  (for [fnam file-seq
    :let [stat-map {(keyword fnam) 
       (if (= (look-for fnam "f") 0)
           1
           0)}]]
   stat-map))

(into {}  
 (all-files-present? '("Makefile" "build.sh" "real-estate.csv")))

{:Makefile 1, :build.sh 1, :real-estate.csv 0}

Answer 1

You could use zipmap:

(defn all-files-present?
  [file-seq]
  (let [f  #(bit-flip (look-for % "f") 0)]
    (zipmap (map keyword file-seq) (map f file-seq))))

or juxt:

(defn all-files-present?
  [file-seq]
  (let [f  #(bit-flip (look-for % "f") 0)]
    (into {} (map (juxt keyword f) file-seq))))

Note that I use bit-flip instead of the if to flip 1<->0.

---

It would be nicer if kind-stat would just return a boolen value, so you would simply use

(defn kind-stat
  [filename expected-type]
  (let [f (File. filename)]
      (= expected-type 
        (cond
          (.isFile f)       "f"
          (.isDirectory f)  "d"
          (.exists f)       "o" 
           :else            "n"))))

(defn all-files-present?
  [file-seq]
  (let [f  #(if (kind-stat % "f") 1 0)]
    (into {} (map (juxt keyword f) file-seq))))

I removed look-for, since it is virtually useless.