I don’t think instrumenting the HOF is applied to the incoming fn args

same for return values which are fns from a HOF. I guess that anon fns cannot be instrumented because instrumentation requires a fn var?

you can instrument functions too.

from https://github.com/metosin/malli/blob/master/docs/function-schemas.md:

(def pow
  (m/-instrument
    {:schema [:=> [:cat :int] [:int {:max 6}]]}
    (fn [x] (* x x))))

but, in Clojure, there is no way to check the function arities, argument or return types - but we can use generative testing to brute force the inputs to see if they are of correct type.

(def =>plus 
  (m/schema
    [:=> [:cat :int :int] :int] 
    {::m/function-checker mg/function-checker}))

(m/validate =>plus plus)
; => true

(m/validate =>plus str)
; => false

(m/explain =>plus str)
;{:schema [:=> [:cat :int :int] :int],
; :value #object[clojure.core$str],
; :errors ({:path [],
;           :in [],
;           :schema [:=> [:cat :int :int] :int],
;           :value #object[clojure.core$str],
;           :check {:total-nodes-visited 0,
;                   :depth 0,
;                   :pass? false,
;                   :result false,
;                   :result-data nil,
;                   :time-shrinking-ms 1,
;                   :smallest [(0 0)],
;                   :malli.generator/explain-output {:schema :int,
;                                                    :value "00",
;                                                    :errors ({:path []
;                                                              :in []
;                                                              :schema :int
;                                                              :value "00"})}}})}

also, not sure if there is an option to enable the generative function testing into or malli.instrument. If not, PR most welcome!

side-note: only non-side effecting functions should be tested.

Thanks. I found the -instrument method which will work