doseq but with work broken out into thread pools of specified sizes

workseq.clj

(defmacro workseq [bindings & body]
  (let [bind (first (partition 2 bindings))]
    (if (empty? bindings)
      `(do ~@body nil)
      `(let [right#      ~(second bind)
             value#      (first right#)
             workers#    (second right#)
             num-values# (count value#)]
         (if (and (< 1 workers#) (< 1 num-values#))
           (let [thread-pool# (Executors/newFixedThreadPool workers#)
                 latch#       (CountDownLatch. num-values#)]
             (doseq [x# value#]
               (let [~(first bind)
                     x#
                     thunk#
                     (bound-fn*
                       (^:once fn* []
                         (try
                           (workseq ~(vec (drop 2 bindings)) ~@body)
                           (finally
                             (.countDown latch#)))))]
                 (.submit ^ThreadPoolExecutor thread-pool# ^Runnable thunk#)))
             (.await latch#)
             (.shutdownNow thread-pool#)
             nil)
           (doseq [x# value#]
             (let [~(first bind) x#]
               (workseq ~(vec (drop 2 bindings)) ~@body))))))))

(comment

  (workseq [x [(range 200) 12]]
    (locking *out*
      (println x))))