is there a way to have different map layouts, I wanted to do something like this

[:map [:coord [:or 
               [:map {:closed true}]
               [:map {:closed true} [:x int? :y int?]]]]]
{:coord {}}
{:coord {:x 1 :y 1}}

@oliver.marks I think this works if you use for the second :map:

[:map {:closed true} [:x int?] [:y int?]]

yeah that works for the second map, just not sure how to make it work also for an empty map I tried putting optional in various places and tried :or and a few other things oh I might have missed some brackets above but its more an an illustration of one of the methods I tried

[:map {:closed true :optional true} [:x int?] [:y int?]]

I tried it with your :or above and that worked (after adding the missing brackets)

this passes ? {:coord {}} when I run it through m/valid i get missing keys or I was yesterday when I was testing 😛

nice, I will re check what I have maybe there was a different error which I did not spot

@alpox

[:map [:coord [:or 
               [:map {:closed true}]
               [:map {:closed true}
               [:x {:optional false} int?]
               [:y {:optional false} int?]]]]]

what about that, I think because the key do not have the optional map the :or is irrelevant anyway

although perhaps thats it, perhaps its optional thats messing me up looking at your screenshot again I can see it fails when one of the keys are missing

@alpox thanks for your rubber ducking, not an issue with malli I had 2 schmeas with similar name and was updating the wrong one 😕

Oups 🙂 np

I constantly get the feeling that I'm missing a schema to talk about map schemas in terms of key-value pairs

an annoying example to implement is mutual exclusion, such as a map which can have x, y and (z or u)

where z and u have different value types, too

Hear hear. I think something like malli-keys-relations should be there. With qualified keywords, it’s less boilerplate (but, still has):

[:or 
 [:map ::x ::y ::z]
 [:map ::x ::y ::u]]

spec-style would be:

[:map ::x ::y [:keys/or ::y ::u]]

maybe:

[:and
 [:map ::x ::y ::z ::u]
 [:keys/or ::z ::u]]

… and the mandatory JSON Schema way for this: https://json-schema.org/understanding-json-schema/reference/conditionals.html

JSON Schema's BNF was one of the motivations for it

> map which contains at least one ::x where ::x is [:or [:x int?] [:y float?]]

If we had it we could define JSON Schema with malli (translating the ebnf is straightforward), then define encoders and decoders to transform between the two

added a video of the new function instrumention. three apis: advanced, normal users and for the lazy: https://github.com/metosin/malli/pull/471

comments welcome