reducing multiple functions

gistfile1.clj

lambda.match> (time (sidelong-count-and-sum (range 100000000)))
"Elapsed time: 89361.517429 msecs"
[100000000 4999999950000000]
  
lambda.match> (time (reduce #((juxt 
                               (partial (fn [x y] (+ x 1)) (first %))  ; count
                               (partial +                  (second %))) ; sum
                              %2) 
                            [1 0]  
                            (range 1 100000000)))
"Elapsed time: 51670.058838 msecs"
[100000000 4999999950000000]
  
; the macro is faster than the function below since it 
; creates the juxted function statically

(defmacro reduce-multi [fns init args]
  (let [acc (gensym)
        n   (gensym)]
    `(reduce (fn [~acc ~n]
               [~@(map-indexed (fn [arg# f#] `(~f# (nth ~acc ~arg#) ~n)) fns)])
             ~init
             ~args)))

(defn reduce-multi [fns init args]
  (reduce (fn [acc n]
            ((apply juxt
                    (map-indexed #(partial %2 (nth acc %)) fns))
             n))
          init
          args))

Reducer version, theoretically data-parallel via fork/join. Uses a map instead of tuple to simplify merging and avoid accidental seq. A vector would work too, it's more a matter of taste considering both types can be reducer'd.

(require '[clojure.core.reducers :as r])

(defn count-sum
  ([] {:count 0 :sum 0})
  ([{:keys [count sum]} n]
   {:count (inc count)
    :sum   (+ sum n)}))

(defn merge-counts-sums
  ([] {:count 0 :sum 0})
  ([& counts-sums]
   (reduce merge-with + counts-sums)))

(time (r/fold merge-counts-sums count-sum (range 100000000)))