(defn is-wsp?
  [c]
  (if (#{space tab newline return} c) true))

(defn collapse-wsp
  [coll]
  (mapcat
   (fn [[first-elem :as s]]
     (if (is-wsp? first-elem) [space] s))
   (partition-by is-wsp? coll)))

=> (apply str (collapse-wsp "t    ar          std  t r n         f rn"))
" a s d f "

(defn lazy-collapse
  ([coll is-collapsable-item? collapsed-item-representation] (lazy-collapse coll is-collapsable-item? collapsed-item-representation false))
  ([coll is-collapsable-item? collapsed-item-representation in-collapsable-segment?]
  (let [step (fn [coll in-collapsable-segment?]
               (when-let [item (first coll)]
                 (if (is-collapsable-item? item)
                   (if in-collapsable-segment?
                     (recur (rest coll) true)
                     (cons collapsed-item-representation (lazy-collapse (rest coll) is-collapsable-item? collapsed-item-representation true)))
                   (cons item (lazy-collapse (rest coll) is-collapsable-item? collapsed-item-representation false)))))]
    (lazy-seq (step coll in-collapsable-segment?)))))

user=> (map
   (fn [collapse]
     (println (class collapse) (str "|" (apply str (collapse test-str is-wsp? space)) "|"))
     (time (dotimes [_ 1000000] (collapse test-str is-wsp? space)))
     (time (dotimes [_ 1000000] (first (collapse test-str is-wsp? space))))
     (time (dotimes [_ 1000000] (second (collapse test-str is-wsp? space))))
     (time (dotimes [_ 1000000] (last (collapse test-str is-wsp? space)))))
   [collapse-overthink collapse-smith collapse-normand lazy-collapse])

user$collapse_overthink | a s d f |
"Elapsed time: 153.490591 msecs"
"Elapsed time: 3064.721629 msecs"
"Elapsed time: 4337.932487 msecs"
"Elapsed time: 24797.222682 msecs"

user$collapse_smith | a s d f |
"Elapsed time: 141.474904 msecs"
"Elapsed time: 812.998848 msecs"
"Elapsed time: 2112.331739 msecs"
"Elapsed time: 10750.224816 msecs"

user$collapse_normand | a s d f |
"Elapsed time: 314.978309 msecs"
"Elapsed time: 1423.779761 msecs"
"Elapsed time: 1669.660257 msecs"
"Elapsed time: 8074.759077 msecs"

user$lazy_collapse | a s d f |
"Elapsed time: 169.906088 msecs"
"Elapsed time: 638.030401 msecs"
"Elapsed time: 1195.445016 msecs"
"Elapsed time: 6050.945856 msecs"

(defn collapse [xs pred rep]
  (when-let [x (first xs)]
    (lazy-seq
      (if (pred x)
        (cons rep (collapse (drop-while pred (rest xs)) pred rep))
        (cons x (collapse (rest xs) pred rep))))))

(defn collapse [col pred rep]
  (let [f (fn [[x & more :as xs]] (if (pred x) [rep] xs))]
    (mapcat f (partition-by #(if (pred %) true) col))))

$ clj collapse.clj
     SuperHorst: "Elapsed time: 58535.737037 msecs"
      Overthink: "Elapsed time: 70154.744605 msecs"
        M Smith: "Elapsed time: 89484.984606 msecs"
   Eric Normand: "Elapsed time: 83121.309838 msecs"

(def test-str "t ar      std t r n          f rn")
(def is-ws? #{space tab newline return})

user=> (apply str (collapse test-str is-ws? space))
" a s d f "

user=> (collapse (range 1 110) #(= 2 (count (str %))) X)
(1 2 3 4 5 6 7 8 9 X 100 101 102 103 104 105 106 107 108 109)

user=> (type (collapse test-str is-ws? space))
clojure.lang.LazySeq
user=> (type (collapse (range 1 110) #(= 2 (count (str %))) X))
clojure.lang.LazySeq

(defn collapse-bug [col pred rep]
  (let [f (fn [x] (if (pred x) rep x))]
    (map (comp f first) (partition-by f col))))

user=> (.replaceAll "t    ar          std  t r n         f rn" "\s+" " ")
" a s d f "

(defn is-blank? [^Character c] (not (nil? (#{space tab newline return} c))))

(defn collapse [coll fun replacement]
  (first (reduce (fn [[res replaced?] el]
                   (if (fun el)
                     (if replaced?
                       [res replaced?]
                       [(conj res replacement) true])
                     [(conj res el) false]))
                 [[] false] coll)))

(def aa-str "t    ar          std  t r n         f rn")

user> (apply str (collapse aa-str is-blank? space))
" a s d f "

user> (collapse [1 1 2 3 1 1 1 4 5 6 1 1] #(= % 1) 9)
[9 2 3 9 4 5 6 9]

<!-- language: lang-clojure -->
(defn collapse [ss pred replacement]
    (lazy-seq
          (if-let [s (seq ss)]
              (let [[f & rr] s]
               (if (pred f)
                   (cons replacement (collapse (drop-while pred rr) pred replacement))
                   (cons f (collapse rr pred replacement)))))))

USER> (remove #(Character/isWhitespace %) "t    ar          std  t r n         f rn")
(a s d f)

(defn collapse [l p v]
  (cond
    (nil? (seq l))
    nil
    (p (first l))
    (lazy-seq (cons v (collapse (drop-while p l) p v)))
    :otherwise
    (lazy-seq (cons (first l) (collapse (rest l) p v)))))