   [t rule-set]
   (let [normalized-rules (rules/normalize rule-set)]
     (when (rules/balanced? normalized-rules)
-      (mapcat #(validate-vec t %) normalized-rules))))
+      (*mapper-fn* #(validate-vec t %) normalized-rules))))
+
+(def ^:dynamic *validation-seq-fn* validation-seq)
 
 (defn validation
   "Validate a data structure, `t`,

  ([t rule-set]
   ;; TODO: This can definitely be done better
   (apply merge-with #(flatten (concat [%1] [%2]))
          (mapcat (fn [result-seq]
                    (map #(apply hash-map %) (partition-all 2 result-seq)))
                  (validation-seq t rule-set))))
  ([t rule-set merge-fn]
   (merge-fn (validation-seq t rule-set))))


(comment


  (let [[coordinates validations] validation-vec]
    (partition-all 2
      (mapcat (fn [[validation-fn opt-map]]
                (raw-validation t coordinates validation-fn (assoc opt-map ::coordinates coordinates)))
              validations))))

(def ^:dynamic *mapper-fn* mapcat)

(defn validation-seq
  "Create a lazy sequence of validating a given data structure
