I think option #1 is clearer to read.

What about just [::m/default [:int :string]]? Just "special case" like other :map values. But OK, I see the value that it is a real Malli schema.

I think it would be nice to make it explicit that it's either a tuple of values or a map-of values, rather than relying upon special "knowledge" that [:int :string] means a map. However, I'm have not that strong a feeling, and thus I can see the value in just [:int :string] too 🙂

I think option 2 is strange. Because the extra values are some number of those tuples, which :map-of describes. If we want to match regular :map keys drop :tuple.

1 is clearer

1 it is then. Draft here https://github.com/metosin/malli/pull/871

by default stripping works like this:

(m/decode
 [:map
  [:x :boolean]
  [:y :int]]
 {:x 1, "kikka" "kukka", 3 4}
 (mt/strip-extra-keys-transformer))
; => {:x 1}

disabled for explixitely open maps:

(m/decode
 [:map {:closed false}
  [:x :boolean]
  [:y :int]]
 {:x 1, "kikka" "kukka", 3 4}
 (mt/strip-extra-keys-transformer))
; => {:x 1, "kikka" "kukka", 3 4}

whatbout :map + ::m/default?

(m/decode
 [:map
  [:x :boolean]
  [:y :int]
  [::m/default [:map-of :int :int]]]
 {:x 1, "kikka" "kukka", 3 4}
 (mt/strip-extra-keys-transformer))
; 1) => {:x 1, "kikka" "kukka", 3 4}
; 2) => {:x 1, 3 4}

I think: • 1️⃣ is more consistent with current behavior (and easier to implement) • 2️⃣ sounds what I would expect

"kikka" "kukka" is an extra entry, so I think it should be stripped. so 2️⃣ seems more right

if I had an API that had ::m/defaults, I'd be pretty peeved if they got stripped

perhaps we need a separate strip-extra-keys-transformer and strip-unknown-keys-transformer

I've always kinda understood strip-extra-keys as meaning strip-unknown-keys

One can run apply the mt/strip-extra-keys-transformer in two phases: 1. before the ::m/default values have been transformed, e.g. we don’t know the validity of extra keys/values. With this, I would like to keep all extra keys 2. after ::m/default values have been transformed -> we could validate all (non-explicitly defined key-values) and strip away everything that doesn’t match the schema

same numbers (1 & 2) as before, just with more context. For example, in current reitit, the mt/strip-extra-keys-transformer is applied BEFORE the normal transformers, so 2 would not work => the childs are not transformed and thus, all the entries could be invalid.

I think this could be handled in mt/strip-extra-keys-transformer: 1. check if the schema has ::m/default key 2. If it has, mount a :leave transformer that validates all the extra key-values and strips away the invalid ones.

boils down to what does “unknown” keys mean, ping @US1LTFF6D.

yeah exactly

> after ::m/default values have been transformed -> we could validate all (non-explicitly defined key-values) and strip away everything that doesn’t match the schema I think this is the right way to go

that is non-trivial to solve. Given schema:

[:map
 [:x :int]
 [::m/default [:map-of :int :int]]]

{:x 1, 1 1, 2 2, "3" "3", "4" "4"}

{1 1, 2 2, "3" "3", "4" "4"}

hmm

dissoc the "known" keys, validate the rest using the default schema

so it would fail with {:max 2}

I'm not sure I see the problem. What were you thinking of?

for extra keys:

{1 1, 2 2, "3" "3", "4" "4"}

{1 1, 2 2}

maybe this is just something to document, “best effort for ::m/default keys”

and a option to disable it.

hmm

I would've expected

(m/decode [:map-of :int :int] {1 1, 2 2, "three" "3"} (mt/strip-extra-keys-transformer))

but it seems strip-extra-keys-transformer doesn't do anything for map-of?

currently, it does not, noticed the same, I’ll make it work too.

yeah, well after that works, can't you just reuse that behaviour for ::m/default ?

so (m/decode [:map [:x :int] [::m/default def]] val) would delegate to (m/decode def (dissoc v :x))

the -transformer of :map already covered the delegation, so just needed to add the :map-of stripping and it works. I’m surprised how well this played out!

(m/decode
 [:map
  [:x :int]
  [::m/default [:map
                [:y :int]
                [::m/default [:map-of :int :int]]]]]
 {:x 1, :y 2, :z 3, 1 1, "2" 2, 3 "3", "4" "4"}
 (mt/strip-extra-keys-transformer))
; => {:x 1, :y 2, 1 1}

… and contructed a :tuple schema of the :map-of so we can iterate over key-values without stuffing those into a map. less garbage and don’t have to worry about :map-of level constraints like :min and :max properties.

yeah it's pretty nice