malli.error — metosin/malli 0.9.1

-concat clj/s

(-concat x y)

-error clj/s

(-error e)

-error-value clj/s

(-error-value {:keys [errors value]} options)

-error? clj/s

(-error? x)

-fill clj/s

(-fill x i fill)

-get clj/s

(-get x k)

-masked clj/s

(-masked mask x y)

-pred-min-max-error-fn clj/s

(-pred-min-max-error-fn {:keys [pred message]})

-push clj/s

(-push x k v fill)

-push-in clj/s

(-push-in a v [p & ps] e)

-replace-in clj/s

(-replace-in a v [p & ps] e fill)

-resolve-direct-error clj/s

(-resolve-direct-error _ error options)

default-errors clj/s

error-message clj/s

(error-message error)

(error-message {:keys [schema type] :as error}
               {:keys [errors unknown locale default-locale]
                :or {errors default-errors unknown true default-locale :en}
                :as options})

error-path clj/s

(error-path error)

(error-path error options)

error-value clj/s

(error-value explanation)

(error-value explanation {mask :malli.error/mask-valid-values :as options})

Returns the parts of value that are in error. Accepts the following options:

• ::mask-valid-values, value to mask valid values with
• ::keep-valid-values, keep valid values (overrides mask)
• ::accept-error, function to accept errors
• ::wrap-error, function to wrap the error map (default: :value)

humanize clj/s

(humanize explanation)

(humanize {:keys [value errors] :as explanation}
          {:keys [wrap resolve]
           :or {wrap :message resolve -resolve-direct-error}
           :as options})

Humanized a explanation. Accepts the following options:

• :wrap, a function of error -> message, defaulting to :message
• :resolve, a function of explanation error options -> path message

with-error-message clj/s

(with-error-message error)

(with-error-message error options)

with-error-messages clj/s

(with-error-messages explanation)

(with-error-messages explanation {f :wrap :or {f identity} :as options})

with-spell-checking clj/s

(with-spell-checking explanation)

(with-spell-checking explanation {:keys [keep-likely-misspelled-of]})