Clojurians Log v2

Code puzzle and a review rolled into one. I need a way to translate essential the get-in list args into a datomic where clause.

[] -> [[]]
[:a] -> [[?r0 :a ?r1]]
[:a :b] -> [[?r0 :a ?r1] [?r1 :b ?r2]]

fn: expression, in-binding, find-binding -> where-clause

where expression is like the get-in arg [:a :b ... ]

(defn expression->where-clause
  [attrs in-binding find-binding]
  (let [->b #(symbol (str "?" %))
        f_attrs (first attrs)
        l_attrs (last attrs)]
    (cond
      (= 0 (count attrs)) []
      (= 1 (count attrs)) (into [find-binding] (conj attrs in-binding))
      (= 2 (count attrs)) [[find-binding f_attrs (->b (name f_attrs))]
                           [(->b (name f_attrs)) l_attrs in-binding]]
      :else
      (let [b    (butlast (rest attrs))
            body (:coll (reduce
                         (fn [{:keys [coll c]} n]
                           {:coll (conj coll (->b c) n (->b (inc c)))
                            :c    (inc c)})
                         {:coll []
                          :c    0}
                         b))
            fb   (first body)
            lb   (last body)]
        (partition 3
                   (into [find-binding f_attrs fb]
                         (conj body lb l_attrs in-binding)))))))

just some initial thoughts: • 0 and 1 numbers of attributes don't seem like special cases. making them special cases in the code just makes it more verbose. the only reason to do that is if performance is especially important • why f_attrs instead of f-attrs? • b is only used once and its name is confusing. i would inline it into the reduce call • you use c to represent a number and the n to represent a keyword. if you're going to use single character names, use i ,`num` or n for the number (not c). use k to for the keyword, not n. • I think coll should be a vector of subqueries. ie.

(conj coll [ (->b c) n (->b (inc c))])

in general, I would try to structure the code to reveal the high level algorithm (which is sort of subjective). for me, the high level algorithm psuedo code is like:

(defn expression->where-clause
  [attrs in-binding find-binding]

  (let [->b #(symbol (str "?" %))
         ;; make queries using (drop (butlast attrs))
        middle-queries (stuff (drop (butlast attrs)) ...)

        first-query [find-binding (first attrs) (->b 0)]
        last-query [(->b (dec (count attrs))) (last attrs) in-binding]
        ]
    (vec
     (concat
      [first-query]
      middle-queries
      [last-query])))
  )

if you are going to have special cases based on the number of attrs, I would prefer a case to a cond:

(case (count attrs)
  0 []
  1 (into [find-binding] (conj attrs in-binding))
  2 [[find-binding f_attrs (->b (name f_attrs))]
     [(->b (name f_attrs)) l_attrs in-binding]]
  
  ;; else
  (let [] ...))