   (doall (parents-for-type2 'D)))
 
 (defn get-paths-for-type [root typ]
+  (prn root)
+  (prn typ)
+  (prn (parents-for-type typ))
   (vec
      (mapcat (fn [[ky pt]]
-            (if (= pt root)
-              [[ky]]
-              (mapv #(conj % ky) (get-paths-for-type root pt))))
+               (if (= pt root)
+                 [[ky]]
+                 (mapv #(conj % ky) (get-paths-for-type root pt))))
              (parents-for-type typ))))
 
 (defn get-paths-for-key [root type ky]

                          (if (neg? pos) 100 pos))) res-groups)))

(defn type-check-one-error [root-type value]
    (when-let [results (not-empty (type-checker root-type value {}))]
      (when-let [[[typ errors] & xs] (not-empty (->> results
                                                   (map #(assoc % :orig-config value))
                                                   group-and-sort-first-pass-errors))]
        ;; TODO process one error?
        (when-let [errors (not-empty (doall (handle-type-error-groupp root-type [typ errors])))]
          (when-let [[[typ errors] & xs] (not-empty (->> errors
                                                         (map #(assoc % :orig-config value))
                                                         group-and-sort-first-pass-errors))]
            (first errors))))))

#_(with-schema
  (index-spec

    (seq? v) (summerize-seq v)
    :else (pr-str v)))

(defn summerize-value-unwrap-top [v]
  (let [res (summerize-value v)]
    (if (map? v)
      (nth res 3)
      res)))

#_(pprint-document (summerize-value-unwrap-top {:aasdfasdfasdf 1
                                                :basdfasdfasdf 2
                                                :casdfasdfasdf 2
                                                :dasdfasdfasdf 2})
                   {:width 10})

(defn format-key
  ([k] (pr-str k))
  ([k colr] (color (format-key k) colr)))
