I suck at clojure.

gistfile1.clj

(defn magic [row]
  (if (map? (first row)) (for [x row] (into [] (flatten (seq x)))) (into [] x)))

(defn collapser [incoming]
  (reduce (fn [a b] (conj a (magic b))) [["header" "information"]] (remove nil? incoming)))

;for an input like
;([:a a :b b] nil nil [{:c c, :d d} {:e e, :f f}] nil [:a g :b h]) =>
;[["test" "two"] [:a "a" :b "b"] ([:c "c" :d "d"] [:e "e" :f "f"]) [:a "g" :b "h"]]
;but what I want is
;[["test" "two"] [:a "a" :b "b"] [:c "c" :d "d"] [:e "e" :f "f"] [:a "g" :b "h"]]

Will this work for you? It assumes that there will always be "two pairs" of some kind in sets of two.

(def input '([:a "a" :b "b"]
               nil
               nil
               [{:c "c" :d "d"} {:e "e" :f "f"}]
               nil
               [:a "g" :b "h"]))

;; Assumes that coll only contains collections with 4 elements
;; This also means maps with only two key value pairs.
(defn collapse
  [coll]
  (letfn [(f [form] (if (map? form) (seq form) form))]
    (->> coll
         (remove nil?)             ;; Removes all top-level nil values
         (clojure.walk/postwalk f) ;; Converts maps to seq of pairs
         (flatten)                 ;; Flatten all sequential colls
         (partition 4 4)           ;; Create a seq for every 4 values
         (map vec)                 ;; Convert each seq into a vector
         (cons ["foo" "bar"])      ;; Add header information to front
         (vec))))                  ;; Convert entire thing to a vector

In action:

user> (collapse input)
[["foo" "bar"] [:a "a" :b "b"] [:c "c" :d "d"] [:e "e" :f "f"] [:a "g" :b "h"]]