you can write that case with a macro around s/or :)

but maybe a different kind of spec is better, like s/multi-spec?

Writing a macro around s/or was my first attempt:

(defn- schema-type->pair
  [type->spec schema-type]
  (case schema-type
    "null"    `[:null ::null]
    "boolean" `[:boolean ::boolean]
    "integer" `[:integer ::integer]
    "number"  `[:number (~type->spec "number")]
    "string"  `[:string (~type->spec "string")]
    "array"   `[:array (~type->spec "array")]
    "object"  `[:object (~type->spec "object")]))

(defmacro coll-schema-spec
  [type->spec schema-types]
  (let [schema-type->pair (partial schema-type->pair type->spec)]
    `(s/or ~@(mapcat schema-type->pair schema-types))))

Unfortunately it did not go very well: I ended up encountering a lot of

Don't know how to create ISeq from: clojure.lang.Symbol

well I think you're on the right track there, but you don't want ~@ - this is one of those cases that might be easier as literal construction with list cons etc

~ turns off quoting and turns eval back on, but you don't want to eval

also, schema-type->pair is just a map

Still getting the same error; I think the fundamental issue is that schema-types is a coll whose values are only known as runtime, so trying to fit it inside any compile-time macro like s/or will only result in failure.

(And it’s these times when I wished we used malli in our projects)

can you just register these schemas at runtime then?

think about it as dynamically making static specs, not statically making dynamic specs

So you actually get that already with the ::null, ::boolean, and ::integer specs

The issue comes with those other specs whose implementations depend on the JSON Schema user input (the type->spec function elides a lot of complexity)

For example with array and object you’re basically creating s/coll-of and s/keys specs from user input - not really conducive for registering static specs

not conducive at compile time, but totally fine at runtime

You can dispatch on the count of schema-types to unrolled calls to s/or

I tried doing that, but that didn’t work either

Since s/or requires keyword literals as keys, not variables representing those keywords

Oh right

Well you can use eval

I used eval to pass in my schema-types variable to the macro, but that gave a “can’t eval locals” error

Anyways, going back to @U064X3EF3’s point, I’m not sure what he meant by “register these schemas at runtime” since when I think of registering specs, I automatically think of s/def

I guess you can also generate the spec keywords at runtime, but given the potentially infinite schema values that does not seem to be a good idea

ultimately, the spec registry is a map in your Clojure runtime. you can put things in it anytime, not just when you load a namespace that calls s/def

(all of this is more readily available in the spec 2 api, both making specs and registering them without s/def)

And spec 2 is supposed to have more support for dynamic, data-driven specs like the varardic s/or I’m trying to make, right?

Anyways I think I’m going to go with or-spec-impl as my near-term solution

It works like a charm just like any other spec, and there’s not really any downside other than a strongly worded docstring

spec 2 has a data form you can use to make a spec, and a non-macro way to register a spec