clojure.test.check.generators/let is also missing in clojure.spec.gen.alphanamespace

Related to the 2.) When I actually try to use (gens/double) it throws an exception so the usage pattern is a bit inconsistent

what kind of exception?

1. Unhandled java.lang.ClassCastException
   clojure.test.check.generators.Generator cannot be cast to clojure.lang.IFn

I don't have anything against either approach, I just thought that they behave in the same way O:-)

oh, you mean between the two namespaces it's inconsistent yes absolutely, and that's unfortunate

just a small thing. imho, gen/large-integer doesn't accept min/max options. I had to use gen/large-integer* (slide 43). Funny thing is that if you use clojure.spec.gen.alpha/large-integer it doens't throw an exception but generates wrong data

that's disappointingly error-prone

the other thing is definitely a slide typo 😞

my org-mode⇒beamer workflow is not yet sophisticated enough to automatically verify that the code works

I think it's more like all the "regex" spec types (`cat`, alt, *, +, ?) are specifically meant to specify elements of a sequence. I wouldn't say there's an implicit cat around alt or any of the regex specs, they all work on sequences whether you use them alone or in combination

I'm probably missing some context for your use case though? Writing specs for multi-arity functions?

The fdef docstring has a nice example:

(s/fdef clojure.core/symbol
  :args (s/alt :separate (s/cat :ns string? :n string?)
               :str string?
               :sym symbol?)
  :ret symbol?)

Using an alt case for each arity

ok, but apart from conciseness, what’s the benefit over s/or in this case?

(Yes, I’m writing specs for multi-arity functions)

(s/fdef clojure.core/symbol
        :args (s/or :separate (s/cat :ns string? :n string?)
                    :str (s/cat :str string?)
                    :sym (s/cat :sym symbol?))
        :ret symbol?)

yeah, it’s longer, but are there any other disadvantages?

Not sure what other disadvantages there might be. The :args spec isn't just longer with or, it's more complex. They also produce slightly different output e.g. when incorrectly calling a instrumented function

The or version has additional, unnecessary tags in its explanation

from the :clojure.spec.alpha/problems: :path [:args :sym] vs :path [:args :sym :sym]

Regex specs compose together to describe a single sequential context and are generally preferred for describing args

Generally it's best to use a top level cat as you will then get a map conformed to component names that you can use in the :fn spec

@U064X3EF3 but are different arities a “single sequential context”?

For any given case, yes

I would actually write that example now as

Sorry, I can't type it all, on the phone

no problem, would be grateful to have your example when you get some time

Use alt for alternatives, ? for optional args, * for varargs etc. you can describe any set of arities I've encountered with a regex spec

alright, thanks

on a bit of tangent: what about keyword args?

Use keys* - that's what it's for

ok, many thanks!