Clojure - Split a collection into partitions on boundaries specified by supplied function.

partition-between.clj

(defn partition-between 
  "Splits coll into a lazy sequence of lists, with partition 
   boundaries between items where (f item1 item2) is true.
   (partition-between = '(1 2 2 3 4 4 4 5)) =>
   ((1 2) (2 3 4) (4) (4 5))"
  [f coll]
  (lazy-seq
    (when-let [s (seq coll)]
      (let [fst (first s)]
        (if-let [rest-seq (next s)]
          (if (f fst (first rest-seq))
            (cons (list fst) (partition-between f rest-seq))
            (let [rest-part (partition-between f rest-seq)]
              (cons (cons fst (first rest-part)) (rest rest-part))))
          (list (list fst)))))))

; more idiomatic perhaps, but 3 times slower than the above
(defn partition-between 
  "Splits coll into a lazy sequence of lists, with partition 
   boundaries between items where (f item1 item2) is true.
   (partition-between = '(1 2 2 3 4 4 4 5)) =>
   ((1 2) (2 3 4) (4) (4 5))"
  [f coll]
  (lazy-seq
    (if-not (seq coll) 
      '()
      (let [pairs (map list coll (rest coll))
            [h t] (map #(map last %) (split-with #(not (apply f %)) pairs))]
        (cons (cons (first coll) h) (partition-between f t))))))

Shorter one from StackOverflow:

(defn partition-between [pred? coll] 
  (let [switch (reductions not= true (map pred? coll (rest coll)))] 
    (map (partial map first) (partition-by second (map list coll switch)))))