describe on a tuple where at least one entry has a defined :key will return a map of the entries with a key instead of a vector of all the entries.

Author: green-coder

CHANGELOG.md

@@ -7,6 +7,11 @@ Versions prior to v0.1.0 are considered experimental, their API may change.
 
 ## [Unreleased]
 
+### Changed
+
+- `describe` on a tuple where at least one entry has a defined :key will return
+  a map of the entries with a key instead of a vector of all the entries.
+
 ## [0.0.7] - 2020-09-20
 
 ### Fixed

src/minimallist/core.cljc

@@ -288,7 +288,16 @@
                                                  (implies (contains? model :condition-model)
                                                           (:valid? (-describe context (:condition-model model) data))))]
                                  {:valid? valid?
-                                  :desc (mapv :desc entries)})
+                                  :desc (if (and (= (:type model) :sequence)
+                                                 (some #(contains? % :key) (:entries model)))
+                                          (->> (map (fn [model-entry described-entry]
+                                                      (when (contains? model-entry :key)
+                                                        [(:key model-entry) (:desc described-entry)]))
+                                                    (:entries model)
+                                                    entries)
+                                               (filter some?)
+                                               (into {}))
+                                          (mapv :desc entries))})
                                {:valid? false})
     :alt (let [[key entry] (first (into []
                                         (comp (map-indexed (fn [index entry]

test/minimallist/core_test.cljc

@@ -350,6 +350,14 @@
                     [1 2] :invalid
                     [1] :invalid]
 
+                   (h/tuple (h/fn int?)
+                            [:text (h/fn string?)])
+                   [[1 "a"] {:text "a"}]
+
+                   (h/tuple [:number (h/fn int?)]
+                            [:text (h/fn string?)])
+                   [[1 "a"] {:number 1, :text "a"}]
+
                    ;; sequence - :count-model
                    (-> (h/sequence-of (h/fn any?))
                        (h/with-count (h/val 3)))