[:map ["key" {:optional true} :string]] is also a valid schema, so one can’t guess from the JSON example that the "key" should be handled as a keyword.

but, if someone would write schemas of all malli schema syntaxes, one could do everything else (but not guess the string->kw things)

Ok. That means that a dumbed-down version would work :thinking_face:

yes. If you want all maps to have keyword keys, you can: 1. read in from json 2. clojure-walk all vectors to have first arg as keyword 3. m/schema 4. m/walk and convert all map keys into keyword 5. profit

There is also a difference between keyword and symbol . And that's also significant because :inst? ,`inst?` and "inst?" are different :thinking_face:

maybe Tagged JSON? https://github.com/metosin/jsonista#tagged-json

I was thinking about dumbing down the schema and making everything a keyword or a number :thinking_face: I don't need all power.

If you know all your map keys are going to be keywords, you could use walker and transform to change map keys to keywords from strings, in the read schema.

Or you if just write limited Malli schema for the Malli schemas you need to support, you can use :keyword there to read the JSON strings as keys for the map keys.

I was thinking about making a subset of malli by doing something similar to a custom parser. And then use :inst instead of inst? and :number instead of number? to make it all very uniform for the reader and parser. And after parsing I would do clojure.walk/postwalk or something similar to replace into the functions that malli understands. So I should probably implement parsing for all basic types, :map , :set and some basic options like :optional. I think I don't need seq regex matching in this specific use as this will only be used to define a data structure and sequences, maybe lists with order too but there shouldn't be tuples.

The malli playground is a great place to discover malli features. Maybe https://malli.io/?value=%7B%3Ax%201%2C%20%3Ay%202%7D&schema=%5B%3Aand%0A%20%5B%3Amap%20%5B%3Ax%20int%3F%5D%20%5B%3Ay%20int%3F%5D%5D%0A%20%5B%3Afn%0A%20%20%7B%3Aerror%2Fmessage%20%22x%20should%20be%20greater%20than%20y%22%7D%0A%20%20(fn%20%5B%7B%3Akeys%20%5Bx%20y%5D%7D%5D%20(%3E%20x%20y))%5D%5D will give you inspiration?

Ooohh, that's very nice! Thanks very much 😃

You are most welcome! I find it a great place to explore.

For sure! For whatever reason, I hadn't registered that was a thing before. Much appreciated 👍

Not at my dev box right now, but maybe due to {:default {}}?

Doesn’t make a difference I’m afraid… I’ve tried a large number of combinations, but apparently not the right one 😅

I don’t want to to think I know malli well at all, so there might be other ways. Moving the :default {} up seems to work:

(require '[malli.core :as m]
         '[malli.transform :as mt])

(def Conf
  [:map
   [:polling {:default {}}
    [:and
     [:map 
      [:min-delay-seconds [int? {:default 60}]]
      [:max-delay-seconds [int? {:default 120}]]]
     [:fn
      {:error/message "max polling delay must be >= min polling delay"}
      (fn [{:keys [min-delay-seconds max-delay-seconds]}]
        (> min-delay-seconds max-delay-seconds))]]]])

(m/decode Conf {} mt/default-value-transformer)
;; => {:polling {:min-delay-seconds 60, :max-delay-seconds 120}}

(m/decode Conf {:polling {:min-delay-seconds 1231}} mt/default-value-transformer)
;; => {:polling {:min-delay-seconds 1231, :max-delay-seconds 120}}

Wow, it does! I must have tried pretty much any combination but that one Thanks again, Lee! ⭐️

My pleasure, more experienced mallites might chime in, but the above looks ok to me.

I'm aware of: https://github.com/dvingo/malli-code-gen/blob/main/thoughts.md#clojurespecalpha https://github.com/dvingo/malli-code-gen/blob/main/src/main/space/matterandvoid/malli_gen/clojure_alpha_specs.cljc I remember reading the docs, but have no idea how complete the actual implementation is.

I will track this, can be a point where I can start. Thanks

I also remember this presentation showing how to generate domain models from malli (similar to the above repo thoughts). It's not directly related to clojure.spec, but perhaps you may gleam some insights if you go down the road of actually implementing this kind of generator. https://www.youtube.com/watch?v=ww9yR_rbgQs

I think both of these things came about before malli introduced https://github.com/metosin/malli#qualified-keys-in-a-map - perhaps with some clever use of macros and custom malli registries, you can get 80% there without much effort?

Lets see, there is a lot of duplication going on so I need to solve it through some clever strategy

Yea, I paused working on that, but the good news is that since then malli added malli.core/ast which makes it a lot easier to parse and walk schemas. I have a transform for taking malli schemas describing a hashmap and producing pathom output vectors that is working: https://gist.github.com/dvingo/213633acfdd520bddcdc91fc1c7b9e44 you should be able to do something similar to output clojure specs. The Kondo output has a more complete set of schema types: https://github.com/metosin/malli/blob/master/src/malli/clj_kondo.cljc

🙌

I think @U0A5V8ZR6 continued working on something similar https://github.com/Blasterai/malli-datomic/blob/master/src/blasterai/malli_datomic/spec_utils.cljc

yea that should be possible with a little custom code. Underneath => just calls -register-function-schema https://github.com/metosin/malli/blob/bf92680ad76e57697261dd45c52dd31ffa9a8e1e/src/malli/instrument.clj#L41 which takes an ns symbol, a name symbol, a schema and a metadata map

maybe m/=> should allow qualified symbols too? e.g.

(m/=> my.domain/foo ...)

would not be a big change I guess: https://github.com/metosin/malli/blob/master/src/malli/core.cljc#L2440-L2442

try [:tuple :int :nil :string]

Exactly right! In hindsight I could have also:

(mp/provide
 [[1 nil "x"]
  [2 nil "y"]
  [1 nil "z"]]
 {:malli.provider/tuple-threshold 3})