                                :req-un [:fig-opt/build-config])
                               {;:http-server-root 1
                                :server-por 1
-                               :asdf 1
-                               :badly 3
+                               ;:asdf 1
+                               ;:badly 3
                                :build-confi {:id "asdf"
                                              :source-paths [""]
                                              :assert 1
-                                             :madly 2
+                                             ;:madly 2
 
                                               }}
                               )
+
   )
+
+
 
 ;; strict-keys
 


;; to do this right this should be done with probabilities
(defn score-suggestion [k->s map-x ky [suggested-key score]]
  (let [key-val (get map-x ky)
        valid  (s/valid? (k->s suggested-key) key-val)]
    [suggested-key (cond-> (/ score 10)
                     (and valid (coll? key-val)) dec
                     valid dec)]))

(defn spelling-suggestion [{:keys [k->s known-keys]} map-x ky]
  (->> (spelling-suggestions known-keys ky)

       (map (juxt identity #(similar-key ky %)))
       (filter second)))


(defprotocol FuzzySpec
  (fuzzy-conform-score [_ x]))

(defn spec-from-registry [spec-key]
  (get (s/registry) spec-key))

(defn fuzzy-spec? [spec-key]
  (when-let [s (and spec-key (spec-from-registry spec-key))]
       (satisfies? FuzzySpec s)))



;; score a spelling suggestion
;;  + 1 the value is a collection and conforms
;;  + 1 the value is complex and fuzzy conforms <-- TODO
