@seancorfield I have an example here: https://pastebin.com/Kuat3MPV . That's what i'm doing now, but is there a better way of "namespacing" specs?

@ackerleytng OK... and what's the question again? That seems OK to me on the face of it...

ah ok. I just thought there might be a better way of namespacing all of that

thanks then!

so I have this spec:

(s/def ::projection
  (s/* (s/alt :key keyword?
              :sym symbol?
              :projection ::projection)))

(s/valid? ::projection [:a :b])

I’m not sure if you’re intending to validate nested collections, but you can do this:

(s/def ::projection
  (s/* (s/alt :key keyword?
              :sym symbol?
              :projection (s/spec ::projection))))

(s/valid? ::projection [:a :b 'c])
=> true
(s/valid? ::projection [:a :b 'c "x"])
=> false

😄 okay awesome. yes, I am intending to validated nested collections

what’s the difference between writing :projection ::projection and :projection (s/spec ::projection)?

by default all the regex-type specs “flatten” themselves when nested

wrapping a regex-type spec in s/spec prevents that flattening, so you can use them to describe nested sequences of things

I don’t understand what you mean by flattening

or why something “flattening” would cause a stackoverflow

@lilactown FWIW you can also define your spec using s/or instead of s/alt, and then you don’t need the s/spec call to prevent the regex flattening:

(s/def ::projection
  (s/* (s/or :key keyword? :sym symbol? :projection ::projection)))

by “flattening” I mean that when you nest the regex-type specs, by default they merge/compose/combine/maybe-a-better-word to describe a single sequence

(s/conform
  (s/+ (s/alt :n number? :s string?))
  [1 "2" 3])
=> [[:n 1] [:s "2"] [:n 3]]

(s/conform
  (s/+ (s/alt :n (s/+ number?) :s (s/+ string?)))
  [1 "2" 3])
=> [[:n [1]] [:s ["2"]] [:n [3]]]

but what if you wanted to use regex specs to describe nested sequences? the “flattening” behavior wouldn’t allow it, so you could use s/spec to avoid it:

(s/conform
  (s/+ (s/alt :n (s/spec (s/+ number?)) :s (s/spec (s/+ string?))))
  [[1 2 3] ["1 2 3"]])
=> [[:n [1 2 3]] [:s ["1 2 3"]]]