        (map add-required-keys)
        (map add-error-type)))
 
+
+;; *** combine errors for single location
 ;; Sometimes there are multiple errors on the same path location
 
 (defn combined-or-pred [errors]

  (:require
   [strictly-specking.parse-spec]
   [strictly-specking.strict-keys :as strict-impl]
   [clojure.pprint :as pp]
   [clojure.string :as string]
   [clojure.set :as set]

(defn format-predicate-str [{:keys [pred val]}]
  (cond
    (seq-with-first 'or pred)
    (str (if (every? symbol-type-table (rest pred))
           "It should be one of: "
           "It should satisfy one of: ")
         (string/join " | "
                      (map #(color % :good-pred)
                           (map (some-fn symbol-type-table str) (rest pred)))))
    (seq-with-first '+ pred)
    (str "It should be a non-empty sequence of: " (color
                                                   (pred-symbol->str (rest pred))
                                                   :good-pred))
    (seq-with-first '* pred)
    (str "It should be a sequence of: " (color (pred-symbol->str (rest pred)) :good-pred))
    :else
    (str (if (resovlable-predicate? pred)
           "It should be a "
           "It should satisfy ")
         (color (pred-symbol->str pred) :good-pred))))

(defn format-seq-with-end [s end]
  (let [f (color (pr-str (first s)) :focus-key)]
    (condp = (count s)
      1 f
      2 (str f " " end " "(color (pr-str (second s)) :focus-key))
      (str f ", " (format-seq-with-end (rest s) end)))))

(defn format-seq-with-and [s]
  (format-seq-with-end s 'and))

(defn format-seq-with-or [s]
  (format-seq-with-end s 'or))

(defn format-summarized-value [v]
  (string/trim-newline
