Clojure: Semi-Flattening a nested Sequence

Solution 1:

If you only want to flatten it one level you can use concat

(apply concat '(([1 2]) ([3 4] [5 6]) ([7 8])))
=> ([1 2] [3 4] [5 6] [7 8])

Solution 2:

To turn a list-of-lists into a single list containing the elements of every sub-list, you want apply concat as nickik suggests.

However, there's usually a better solution: don't produce the list-of-lists to begin with! For example, let's imagine you have a function called get-names-for which takes a symbol and returns a list of all the cool things you could call that symbol:

(get-names-for '+) => (plus add cross junction)

If you want to get all the names for some list of symbols, you might try

(map get-names-for '[+ /]) 
=> ((plus add cross junction) (slash divide stroke))

But this leads to the problem you were having. You could glue them together with an apply concat, but better would be to use mapcat instead of map to begin with:

(mapcat get-names-for '[+ /]) 
=> (plus add cross junction slash divide stroke)

Solution 3:

The code for flatten is fairly short:

(defn flatten
  [x]
  (filter (complement sequential?)
    (rest (tree-seq sequential? seq x))))

It uses tree-seq to walk through the data structure and return a sequence of the atoms. Since we want all the bottom-level sequences, we could modify it like this:

(defn almost-flatten
  [x]
  (filter #(and (sequential? %) (not-any? sequential? %))
    (rest (tree-seq #(and (sequential? %) (some sequential? %)) seq x))))

so we return all the sequences that don't contain sequences.