在clojure中分组一系列bool？

Question

I would like to transform the following sequence:

(def boollist [true false false false true false true])

Into the following:

[[true] [false false false true] [false true]]

My code leads to a Stackoverflow:

(defn sep [boollst]
  (loop [lst boollst
         separated [[]]
         [left right] (take 2 lst)]
    (if (nil? left) separated)
    (recur (next lst) 
           (if (false? left)
             (conj (last separated) left)
             (conj separated [left]))
           (take 2 (next lst)))))

Is there an elegant way of transforming this?

Answer 1

There's probably a much more elegant way, but this is what I came up with:

(defn f 
  ([xs] (f xs [] []))
  ([[x & xs :as all] acc a]  
     (if (seq all)
       (if x
         (recur xs [] (conj a (conj acc x)))
         (recur xs (conj acc x) a))
       a)))

It just traverses the sequence keeping track of the current vector of falses, and a big accumulator of everything so far.

Answer 2

A short, "clever" solution would be:

(defn sep [lst]
  (let [x (partition-by identity lst)]
    (filter last (map concat (cons [] x) x))))

The "stack overflow" issue is due to the philosophy of Clojure regarding recursion and is easily avoided if approached correctly. You should always implement these types of functions* in a lazy way: If you can't find a trick for solving the problem using library functions, as I did above, you should use "lazy-seq" for the general solution (like pmjordan did) as explained here: http://clojure.org/lazy

* Functions that eat up a list and return a list as the result. (If something other than a list is returned, the idiomatic solution is to use "recur" and an accumulator, as shown by dfan's example, which I would not consider idiomatic in this case.)

Answer 3

Here's a version that uses lazy evaluation and is maybe a little more readable:

(defn f [bools]
  (when-not (empty? bools)
    (let
      [[l & r] bools
       [lr rr] (split-with false? r)]
      (lazy-seq (cons
        (cons l lr)
        (f rr))))))

It doesn't return vectors though, so if that's a requirement you need to manually pass the result of concat and of the function itself to vec , thus negating the advantage of using lazy evaluation.

Answer 4

The stack overflow error is because your recur is outside of the if. You evaluate the if form for side effects , then unconditionally recur. (feel free to edit for format, I'm not at a real keyboard).