I think clojure.java.jdbc has good spec coverage

https://github.com/clojure/java.jdbc/blob/master/src/main/clojure/clojure/java/jdbc/spec.clj

thank you

Hello!

Can someone tell me what :opt is for? How is validation affected by its presence?

I'm talking about :opt as an option to keys

As far as i’ve understood it, if you have say (s/keys :opt [::name]) If the key ::name is present it will check it against the spec.

So i’ve used it in the past to say, If this thing is present then it has to look like this spec. Otherwise carry on.

So if i just make up an example with some pseduo code

(s/def ::name string?)
(s/def ::type string?)

(s/def ::person (s/keys :opt [::name] :req [::type]))

(s/valid? ::person {::type "human})
=> probably true

(s/valid? ::person {::name 124 ::type "human"})
=> false because name is not a string

I’ve just written these by hand so don’t trust the code 1 for 1

For more reading i would recommend https://clojure.org/guides/spec#_entity_maps

This registers a ::person spec with the required keys ::first-name, ::last-name, and ::email, with optional key ::phone. The map spec never specifies the value spec for the attributes, only what attributes are required or optional.

When conformance is checked on a map, it does two things - checking that the required attributes are included, and checking that every registered key has a conforming value. We'll see later where optional attributes can be useful. Also note that ALL attributes are checked via keys, not just those listed in the :req and :opt keys. Thus a bare (s/keys) is valid and will check all attributes of a map without checking which keys are required or optional.

Hope that helps!

Hey @guy! Thanks!

However, if I do (s/keys), it still checks that ::name is valid.

(s/def ::name string?)
(s/def ::person (s/keys))

(s/valid? ::person {}) ;=> true
(s/valid? ::person {::name "Eric"}) ;=> true
(s/valid? ::person {::name 15}) ;=> false

Yeah but what does ::person check for

:man-shrugging:

part of why i use opt is documentation

your point is valid though and its been asked before

yes, documentation is good

let me find it

thanks

ah bummer the historys gone

Another person asked something similar but a different way

saying why use :opt at all when (s/keys) does the job

I think for me its documentation + being explicit about what you want to check for

okay, thanks

the spec guide on http://clojure.org hints that it'll explain later, but it never does

I thought it might be more than just docs

Also gen

oh!

good call

Kind of important ;)

I think when it comes to speccing out ur fn as well it might be awkward depending on how u use (s/keys)

I’m unsure if you would really generate a spec like (s/def ::person (s/keys))

for sure

you might just use (s/keys) as an anonymous spec inside a (s/fdef ..)

i’ve probably got the terminology wrong

but that would also lead to harder reading when it comes to spec messages when they have failed

but yeah

i would favour :opt over (s/keys)

just from a readability factor

but im just one guy 😄

is there also a difference when the spec is not defined?

i.e., putting things in :opt forces you to define the specs you listed (i.e., prevents you from accidentally forgetting them)?

@gfredericks a little repling shows that opts does not check if the spec exists