question: a new schema for "map or a sequence of map entries" or just an new property to :map schema? Relates to https://clojure.org/news/2021/03/18/apis-serving-people-and-programs.

a) (m/validate [:map-like [:a :int]] [[:a 1]]) ;=> true b) (m/validate [:map {:coerce true}: [:a :int]] [[:a 1]]) ;=> true

I'm currently thinking of going with a, as this is a special case. Both ways, it's just few lines of extra code I think

also, what would be a good name for a new schema type, :map-like ? :every ?

do you @nbtheduke the opinion for this?

:entries

Then :map is :entries + map?

spec seems to have s/keys* for this

thing is, transformers, parsers and explainers need separate code if we want to retain the original entry sequence. forcing the data to be a map allows us to reuse the current code.

for the Keyword argument functions now also accept maps thing, we just need a map, so a simple new way to coerce the entry sequence into a map would do.

One thing to note, the input isn't a sequence of map entries, but a sequence of alternating keys and values, which can be in any order

yes. I guess this is correct:

(require '[malli.destructure :as md])
(require '[malli.generator :as mg])

(defmethod mg/-schema-generator :any [_ _] (mg/generator :string))

(-> '[& {:as m :keys [id before after]}]
    (md/parse)
    :schema
    (mg/sample {:size 10, :seed 42}))
;(({:after ""})
; (:id "F")
; ()
; ({:after ""})
; (:before "n" :after "ai2" :id "5FI0" :id "")
; ({:after "qP3t"})
; ()
; ({:id "j"})
; ()
; (:before
;  "2"
;  :after
;  "HW5Mn3"
;  :after
;  "gv9m93"
;  :before
;  "GVDI2b"
;  :before
;  "fhR"
;  :before
;  "F8562"
;  :after
;  "lS"
;  :before
;  "Z7y0nz"
;  :before
;  "7G"))

a thought experiment, should we have more argument relationship markers, e.g. :- (is a) and :< (a subset of)? could also go EXTREME EVIL and introduce real math symbols like :⊂ 👿

(def User 
  [:map 
   [:id :uuid] 
   [:name :string] 
   [:age :int]])

;; argument is exactly User
[{:keys [id age]} :- User]
; => [:cat [:map [:id :uuid] [:name :string] [:age :int]]]

;; argument should be subset of user (mark others as optional)
[{:keys [id age]} :< User]
; => [:cat [:map [:id :uuid] [:name {:optional true} :string] [:age :int]]]

also, would be awesome if tools like #cursive and #calva would have special markers for the type hints, e.g. dim them out so it’s easier to read.

… for fully qualified keys, the key definitions could be pulled from the registry:

(mm/def ::id :uuid)
(mm/def ::name :string)
(mm/def ::age :int)

;; argument is exactly User
[{::keys [id age]}]
; => [:cat [:map ::id ::age]]

We use (still 😞 ) compojure-sweet for some of our APIs, and I see a lot of :- in the path-params, body.... etc...and well, personally, I found it hard to know what :- meant etc...

in compojure-api, there is a lot of extra syntax, also the fnk syntax. sorry for all that 🙂

I have to deal with it every day 😞 I definitely see lessons where learnt with the new improved reitit library 🙂

So, I'm not for, nor against, additional markers, I'm rather on the fence (just more stuff to learn I suppose!)

yeah, any support for inline typehints is a compromise. If IDEs would support that properly and there would be just one way to doing those, would be great.

i think i’d prefer words instead of single characters for such things. :exact or :exactly or :is-a are easier to parse than :- in my opinion. subset feels like Typescript-style structural typing, which clojure supports out of the box with open maps

I'm with Noah on this one too, I would have to translate :- into is-a in my head as well. Nothing wrong in being wordy, when it comes to comprehension.

my 2c`s 🪙

^:-- that’s what I would love to have, to remove the type/schema clutter if used.

ah, i understand now that :- is supposed to be like static type declarations, that makes more sense

Is there a commonly agreed way to document the meaning of each value in a :enum?

@viebel don’t think there is. ideas welcome