so the first spec seems easy enough:

(s/def ::T #{:t1 :t2 ,,,})

(s/def ::attribute-that-is-a-number number?
,,,

hopefully that's enough to get the brain flowing

Lol, why did I have to pick this as my first venture into specs 😛. Let’s try making it more concrete.

(s/def ::T #{:t1 :t2})
(s/def ::height number?)
(s/def ::name string?)
(s/def ::A #{::height ::name})
(s/def ::Goal (s/cat :R1 int? :R2 ???))

… That’s all I got so far! Can I get a hint on the rest of the syntax?

Maybe

(s/def ::Goal (s/cat :R1 int? :R2 (s/* (s/cat :e (set (range (count R1))) :a ??? v: ???)))

R1 is a vector right? not an int

if you don't think about ::Goal as a spec but more a function that takes the whole 2-tuple what would that function look like

Yeah, you’re right, :R1 is more like (s/col-of ?int).

and ::R2 is (s/coll-of ::R2-elem :kind set?)

Yeah, technically, t

There’s more to it though, right @UCF779XFS? I need some predicate function that @U0HJD63RN was alluding to.

you’d need to a predicate that will take the R2/a and verify the R2/v passes s/valid?

so you’d have something like:

(defn valid-val?
  [[idx a v]]
  (s/valid? a v)) 

(s/and (s/cat _ _ _ _ _ _)
             valid-val?)

something like that/ where the empty cat is whatever you’re using for the three values in the R2 element

Ok.. this is starting to come together!

take with a grain of salt, just woke up and may be stupid

well from the description of the specification - R2's permissible values for e depends on R1

so you need the whole 2-tuple

so you would want a predicate that can compare R1 and R2

Yeah, that's right.

(let [[r1 r2] tup
     allowed-e? (->> r1 count inc (range 1) (into #{}))]
    (->> r2 (map first) (every? allowed-e?))

I’ll give that a shot later, thanks!

so I guess you could split the spec for your tuple into three checks: That R1 is valid all e are valid wrt R1 all v conform to their corresponding a

Yes! That sounds very doable

I was hoping to get generators for free, but even besides this, there are other constraints that between entities of different types that are much too complicated without some constraint solver.

how does it compare to https://github.com/alexanderkiel/phrase ?

or https://github.com/bhb/expound

I'm actually using phrase to generate end-user friendly errors. The problem is passing additional error-related metadata from custom spec predicates to spec errors (and therefore to phrase).

I'm not convinced you can get helpful error messages from the general form of (s/def ::the-name #(apply distinct? %)) - if you consider that the spec is a one-arg predicate function, it would be hard to see how to determine which entry caused the failure. For the specific case of duplication, you'd probably need to replay the data or reconstruct it - as spec would only recall the input unless you walk it element by element. Even the inbuilt :distinct field in (s/every ...) doesn't seem to know which specific member breaks uniqueness

for reference: https://clojure.atlassian.net/browse/CLJ-1925