RutledgePaulV

(defn gc-managed-pool
  "Wraps a manually managed pool to create an automatically managed pool
   that returns resources to the pool as the doled out references are 
   garbage collected by the jvm."
  [pool borrow return]
  (letfn [(interfaces [x]
            (->> (ancestors (class x))
                 (filter class?)
                 (filter #(.isInterface %))))
          (create-facade [x]

RutledgePaulV

(defmacro evaluate* [bindings & code]
  (letfn [(eval-with-bindings [bindings code]
            (let [ks (keys bindings)]
              ((eval `(fn [{:syms [~@ks]}] ~code)) bindings)))]
    `(~eval-with-bindings ~bindings '(do ~@code))))

RutledgePaulV

(def ^:dynamic *hook* false)

(defn hook [var f]
  (alter-var-root var
    (fn [original]
      (fn [& args]
        (if *hook*
          (apply f args)
          (apply original args))))))

RutledgePaulV

(defonce ^:dynamic *hooked* false)

(defn hook [var f]
  (alter-var-root var
    (fn [original]
      (fn [& args]
        (if *hooked*
          (apply f args)
          (apply original args))))))

RutledgePaulV

(defmacro cached [& body]
  (let [dependencies (transient #{})
        resolved     (walk/postwalk
                       (fn [form]
                         (if (symbol? form)
                           (if-some [resolved (resolve &env form)]
                             (when (var? resolved)
                               (conj! dependencies resolved)
                               (.toSymbol ^Var resolved))
                             form)

RutledgePaulV

(require '[clojure.core.async :as async])
(require '[mount.core :as mount])

(defn work-queue [buffer max-retries parallelism]
  (let [chan (async/chan buffer)]
    (dotimes [_ parallelism]
      (async/go-loop []
        (when-some [i (async/<! chan)]
          (let [{:keys [f retries]} (if (map? i) i {:retries 0 :f i})]
            (try (f)

RutledgePaulV

(require '[clojure.test :refer :all])
(require '[clojure.core.async :as async])

(deftest from-channel-still-consumed-after-to-channel-is-closed
  (let [from-counter (atom 0)
        xf-counter   (atom 0)
        from         (async/chan)
        to           (async/chan 1000)
        xf           (map #(do (Thread/sleep 100)
                               (swap! xf-counter inc)

RutledgePaulV

(def ^:dynamic *locks* (atom {}))

(defn new-lock []
  {:count 1 :ref (Object.)})

(defn inc-lock [lock]
  (when lock (update lock :count inc)))

(defn dec-lock [lock]

RutledgePaulV

(defmacro nor [& more]
  (conj `~(partition 2 (interleave (repeat 'not) more)) 'and))

RutledgePaulV

(defn attach-channel-cleanup [chan f]
  (add-watch (.closed chan)
    "channel-resource-cleanup"
    (fn [_ _ old-state new-state]
      (when (and (not old-state) new-state)
        (f))))
  chan)