collect-prop-pairs.clj

;; Transducer to transform
;;
;; [user [name email] foo bar [baz]]
;;
;; into
;;
;; [[user [name email]] [foo nil] [bar [baz]]]
;;
;; when transducing like this:
;;
;; (transduce (collect-prop-pairs) conj [] '[user [name email] foo bar [baz]])

(defn collect-prop-pairs
  []
  (fn [rf]
    (let [pair (volatile! [])]
      (letfn [(flush-pair [result]
                (let [values @pair]
                  (assert (or (empty? values)
                              (and (= (count values) 1)
                                   (or (symbol? (values 0))
                                       (map? (values 0))))
                              (and (= (count values) 2)
                                   (or (symbol? (values 0))
                                       (map? (values 0)))
                                   (vector? (values 1)))))
                  (if (empty? values)
                    result
                    (do
                      (vreset! pair [])
                      (rf result (cond-> values
                                   (= 1 (count values))
                                   (conj nil)))))))]
        (fn
          ([] (rf))
          ([result]
           (let [result (rf (flush-pair result))]
             ;; `(~'cljs.core/ensure-reduced result)
             result))
          ([result input]
           (cond
             (vector? input)
             (do
               (vswap! pair conj input)
               (flush-pair result))

             (or (symbol? input) (map? input))
             (do
               (let [result (flush-pair result)]
                 (vreset! pair [input])
                 result)))))))))