You could alter-var-root to the var, and use u/update-properties to assoc in the generator key of your choice

m.u/update-properties is what I was loopking for, thank you

(mg/generate
  (mu/update-properties [:vector int?] assoc :gen/elements [[3] [4]]))

gives [3] or [4]

Did you try .pretty/exception already? https://cljdoc.org/d/metosin/reitit/0.7.0-alpha3/doc/basics/error-messages#pretty-errors

I would ask in #C7YF1SBT3 if you havn’t already.

Thanks @U6N4HSMFW , I will look at that! @U051GFP2V , I was also wondering if one can get more legible exceptions from instrumented functions (not reitit-related)

There’s similar pretty reporter for malli. I don’t know how it reports instrumented functions but probably quickest way to find out is to try 😉

Also since it’s Tommi-code it’s probably extensible

Oh, I know how that works actually, @UGDTSFM4M.

There’s a wrapped humanize function you can pass.

it’s mentioned on the tips and tricks page, iirc

For instrumentation?

https://github.com/metabase/metabase/blob/master/src/metabase/util/malli.cljc#L50

yeah for any humanize call

what you want to do is plug in your :report function when you call instrument! (or -instument)

which is done here: https://github.com/metabase/metabase/blob/master/src/metabase/util/malli.cljc#L69

and then, you may want to call me/humanize, and plug in some kind of wrap function for it

Oh, wow. This looks amazing. I need to wrap my head around how this can be pieced together but shouldn’t be that hard.

let me know if u have any more questions

I could use it too, I have a couple of :sequential schemes that return thousands of complex maps and overwhelm Emacs. Isn't there already a similar reporting function? Not to reinvent the wheel 😉

I am working on a solution for instrumented functions. Happy to show my solution next week and get feedback!

So this is what I managed to achieve. For coercion errors, I added the following custom exception handler to my reitit routes

{:reitit.coercion/response-coercion
     (fn [exception request]
       (log/error "Response coercion error"
                  (with-out-str
                    (pprint/pprint
                     (malli-error/humanize
                      (ex-data exception)
                      :request))))
       {:status 500
        :body {:message "Response coercion error"
               :uri (:uri request)}})
,,,}

(defn instrument-error!
  [type data]
  (let [{:keys [input args output value arity]} data
        [cause humanized] (cond
                            input ["Invalid input" (malli-error/humanize (m/explain input args))]
                            output ["Invalid output" (malli-error/humanize (m/explain output value))]
                            arity ["Invalid arity" "Too few or too many args"])] 
    (throw (ex-info
            (str cause "\n" (with-out-str (pprint/pprint humanized)))
            {:type type :data data}))))

(defn instrument-error
  [exception request]
  (log/error (ex-message exception))
  {:status 500
   :body {:message "Application error"
          :uri (:uri request)}})

;; Custom exception handling map
{,,,
 ::m/invalid-output instrument-error
 ::m/invalid-input instrument-error
,,,}

It looks good to me, I haven’t come up with anything better.

Any idea on how to get the name of the instrumented function that failed?

It is part of the data, you should see it in the exception info

So something like this for example:

(defn instrument-error!
  [type data]
  (let [{:keys [input args output value arity]} data
        [cause humanized] (cond
                            input ["Invalid input" (malli-error/humanize (m/explain input args))]
                            output ["Invalid output" (malli-error/humanize (m/explain output value))]
                            arity ["Invalid arity" "Too few or too many args"])]
    (throw (ex-info
            (str cause " in " (:fn-name data) "\n" (with-out-str (pprint/pprint humanized)))
            {:type type :data data}))))