(-> (map (fn [[op key val]] `(.addFilter ~(name key) ~(op {:a 1, :b 2}) ~val))
         [[:a :b :c] [:e :f :g]])
    (conj '(Query. "X"))
    (conj 'doto))

(doto (Query. "X") (user/.addFilter "b" 1 :c) (user/.addFilter "f" nil :g))

(-> (map (fn [[op key val]] `(.addFilter ~(name key) ~(op {:a 1, :b 2}) ~val))
         [[:a :b :c] [:e :f :g]])
    (conj '(doto (Query. "X")))
    (conj 'doto))

(doto (doto (Query. "X"))
  (user/.addFilter "b" 1 :c)
  (user/.addFilter "f" nil :g))

(-> '((E (C) (F I) F)
      (A A)
      H
      ((G) B)
      ((E G (I (I I A)) H I) (B) (A) C (D (H)))
      (F C C))
    pr-str
    (clojure.string/replace " " ""))

"^{:line1,:column6}(^{:line1,:column7}(E^{:line1,:column10}(C)^{:line1,:column14}(FI)F)^{:line1,:column23}(AA)H^{:line1,:column31}(^{:line1,:column32}(G)B)^{:line1,:column39}(^{:line1,:column40}(EG^{:line1,:column45}(I^{:line1,:column48}(IIA))HI)^{:line1,:column62}(B)^{:line1,:column66}(A)C^{:line1,:column72}(D^{:line1,:column75}(H)))^{:line1,:column81}(FCC))"

(let [qsort (fn qs [[p :as l]]
              (if p
                (let [{f 1, p 0, l -1} (-> (partial compare p)
                                           (group-by l))]
                  (lazy-cat (qs f) p (qs l)))))]
  (qsort [5 1 8 3 2 0]))

(0 1 2 3 5 8)

(let [sorted-coll (-> (range 25)
                      sort)
      target 18]
  (loop [vs (range (count sorted-coll))
         res {}]
    (let [v (first vs)]
      (if (get res (- v target))
        res
        (recur (next vs) (assoc res v (- target v)))))))

{0 18,
 1 17,
 2 16,
 3 15,
 4 14,
 5 13,
 6 12,
 7 11,
 8 10,
 9 9,
 10 8,
 11 7,
 12 6,
 13 5,
 14 4,
 15 3,
 16 2,
 17 1}

((fn [v]
   (->> v
        (map-indexed vector)
        (mapcat (fn [[i x]]
                  (map #(-> [i %])
                    (range 2 (inc x)))))
        (reductions (fn [v [i x]] (assoc v i x)) (vec (repeat (count v) 1)))))
  [2 1 4])

([1 1 1] [2 1 1] [2 1 2] [2 1 3] [2 1 4])

(let [coll [:N :NE :E :SE :S :SW :W :NW]
      reversed (zipmap coll (range))
      shift #(nth coll (mod (% (reversed %2)) (count coll)))
      left (partial shift dec)
      right (partial shift inc)]
  (-> :N
      left
      left
      left
      right))

:W

(let [better-age-atom (atom {:agec 0, :ages 0})]
  (defn age-avg [] (let [{:keys [agec ages]} @better-age-atom] (/ ages agec)))
  (defn age+
    [age]
    (if (and (< 0 age) (> 120 age))
      (swap! better-age-atom #(-> %1
                                  (update-in [:agec] inc)
                                  (update-in [:ages] + age))))))

#'user/age+

(let [sym (gensym)
      h #(with-meta % {sym true})
      g #(if (-> %
                 meta
                 sym)
           (constantly %)
           %)
      f #(if (fn? %) [(%) (%) (%)] %)
      x 'foo]
  (= ((comp f g h) x) ((juxt f g h) x) [x x x]))

true

(let [❄ inc
      ☃ 1]
  (->
    ☃
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄
    ❄))

42