   (coerce umm-c-schema
           {:EntryTitle "This is a test"
            :TemporalExtents [{:EndsAtPresentFlag "true"
-                              :SingleDateTimes ["2000-01-01T00:00:00.000Z"]}]
-           :MetadataDates [{}]
-           :Distributions [{:Fees "123.4"}]})
+                              :SingleDateTimes ["2000-01-01T00:00:00.000Z" nil "banana"]}]
+           :Distributions [{:Fees "123.4"
+                            :DistributionSize "123 junk"}]})
   )

    (recur (apply lookup-ref pair))
    pair))

(defn coerce
  "Returns x coerced according to a JSON schema type type definition."
  ([schema x]

                   (= "true" x)
                   (boolean x))

       ;; The most important job of this function:
       "object"  (let [ctor (record-ctor schema type-name)
                       ;; Reduce an empty map with each pair of (non-nil) key/vals in x, trying to
                       ;; parse each value or else add error messages in the map under :_errors.
                       m (reduce
                          (fn [m [k v]]
                            (let [prop-type-definition (get-in type-definition [:properties k])
                                  item-type-def (:items prop-type-definition)]
                              (if (= "array" (:type prop-type-definition))
                                (let [results (for [x v]
                                                (try
                                                  {:value (coerce schema item-type-def x)}
                                                  (catch Exception e
                                                    (let [msg (parse-error-msg item-type-def x)]
                                                      (log/warn e msg)
                                                      {:error msg}))))
                                      results (filter #(or (:value %)
                                                           (:error % ))
                                                      results)]
                                  (cond-> m
                                    (some :value results) (assoc k (util/seqv (map :value results)))
                                    (some :error results) (assoc-in [:_errors k] (map :error results))))
                                ;; non-array types
                                (try
                                  (let [parsed (coerce schema prop-type-definition v)]
                                    (if (some? parsed)
                                      (assoc m k parsed)
                                      m))
                                  (catch Exception e
                                    (let [msg (parse-error-msg prop-type-definition v)]
                                      (log/warn e msg)
                                      (assoc-in m [:_errors k] msg)))))))
                          nil
                          (filter val x))]
                   ;; Return nil instead of empty maps/records here.
                   (when m
