yep, but you can also put m/=> before the defn and it is supposed to work, and I'd like to have the option to put the function schema close to the top of the defn

I understand

In this case it's better to write a hook. Optimally malli itself would bundle this in the library and export it

cool!

alternatively you can use {:linters {:unresolved-symbol {:exclude [(malli.core/=>)]}}}

this will suppress all unresolved symbols in =>

but that config could also be exported by malli so it would work for everyone. cc @ikitommi

so, definetely. so, whoever knows better what to put into malli repo so it would work, please do.

oh, that, I can do it

@UKW2FUL4D https://github.com/metosin/malli/pull/559. thing is, that if that is merged, clj-kondo will not warn on cases where you define the m/=>, but not the actual function that it points to. Not good either.

but, that’s stops the warnings.

@ikitommi That's a step in the right direction, but you can make it better using an exported macro hook

but this is more time consuming and I understand the trade-offs

it would be better to export it as part of the malli library though, then people don't have to run malli first to get the better linting

nice! what about a hook that interprets m/=> as (fn [sym _schema] (clojure.core/declare %1))? kondo doesn't seem to complain about

(def thing)
(declare thing)

I would say:

(do (declare thing) schema)

right! I'll try this 🙂

@UA2U3KW0L that’s not good. I guess (re-)calling (dev/start!) after definitions would work.

so, that’s just dev-time annoyance, but then again, it’s supposed to be dev-time tooling. Ideas welcome

I would assume m/=> with dev running, should put a var-watcher that takes care of that, but guess not :thinking_face:

it seems to put a watch on the function schema, so what seems to be happening is the watch fn is called, the function gets instrumented properly, but when you eval the defn again you lose the instrumentation

yep! as a quick test, I did

(defn start!
   ,,,
   (let [watch (fn [_ _ old new]
                 (println "watched")
                 (future ;; <-
                   (Thread/sleep 500) ;; <-
                   (mi/instrument! ,,,))]
     (add-watch @#'m/-function-schemas* ::watch watch))
   (mi/instrument! ,,,)
   ,,,))

so, we should get an event when the var is redefined, e.g. via defn. I guess that's doable?

add-watch supports this, apparently:

(def changes* (atom []))  
  (def a 1)
  (add-watch #'a nil (fn [_ _ & old+new] (swap! changes* conj old+new)))
  (def a 2)
  (def a 3)
  @changes* ;; => [(1 2) (2 3)]

just noticed I use clojurians through 2 different slack accounts