I'm calling explain on a spec and it's returning nil, why would that be?

answer: i need to use explain-str, explain just prints to out

Interesting clojure.spec + datomic question: http://stackoverflow.com/questions/39971727/using-clojure-spec-with-datomic-entities

how would you create a spec for the following: 1) ns store - defines ::state as (s/keys :req [::data ::metadata]) where ::data is a map? 2) ns x produces a ::state with concrete ::data How would the ::x-state spec be defined? (s/and ::store/state #(s/assert ::x-data (::store/data %))) doesn't look right...

On it's own, [1 1] conforms to the ::pattern spec

(ns example.paths
  (:require
   [cljs.spec :as s]
   [cljs.spec.impl.gen :as gen]
   [cljs.spec.test :as test]))

(s/def ::keyword-or-string
  (s/with-gen
    (s/or :keyword keyword?
          :string string?)
    #(s/gen #{"a" "b" :c :d :e/z})))

(def path (s/coll-of ::keyword-or-string
                     :min-count 1
                     :kind vector?))

(s/def ::path
  (s/with-gen
    path
    (fn []
      (s/gen
       (gen/such-that
        #(-> % count (< 5))
        (s/gen path))))))

#object[Error Error: Unable to construct gen at: [] for: [object Object]]
Error: Unable to construct gen at: [] for: [object Object]

So I am trying to reduce the size of generated ::paths to at most be of length 5. It isn’t part of the actual spec for a ::path, but it is something I would like when generating, any idea what I am doing wrong?

@samedhi there is a 20% chance that what i’m about to say is relevant, but i’ll say it just in case

i’ve run into trouble with s/coll-of specs that define a :kind but not an :into

try adding :into [] and see if it does anything

it’s probably irrelevant, but who knows

this is definitely a thing if your :kind is set?, you need to define :into #{} for generators to work afaict

(ns example.paths (:require [cljs.spec :as s] [cljs.spec.impl.gen :as gen] [cljs.spec.test :as test]))

(s/def ::keyword-or-string
  (s/with-gen
    (s/or :keyword keyword?
          :string string?)
    #(s/gen #{"a" "b" :c :d :e/z})))

(gen/generate (s/gen ::keyword-or-string)) => :d

(def path (s/coll-of ::keyword-or-string
                     :min-count 1
                     :kind vector?
                     :into []))

(gen/generate (s/gen path)) => [“a” :c “b” “b” “b” “b” “a”]

(s/gen
 (gen/such-that
  #(-> % count (< 5))
  (s/gen path)))
=> (errors with)
#object[Error Error: Unable to construct gen at: [] for: [object Object]]
Error: Unable to construct gen at: [] for: [object Object]
...

@jrheard is this what you mean? In this case I am trying to return a vector of keywords or strings, so I set :kind to vector? and :into to []

yeah, that’s what i mean; looks like it wasn’t relevant, sorry 🙂

Hey, no problem, I appreciate it.

@samedhi should that be gen/generate instead of s/gen around the gen/such-that?

@thegeez, actually, that does work… Let me play a bit with it.

On my first post, 2 paste up, I had.

(s/def ::path
  (s/with-gen
    path
    (fn []
      (s/gen
       (gen/such-that
        #(-> % count (< 5))
        (s/gen path))))))

I think s/with-gen requires a generator as the second argument...

I think I am basing it off of this from http://clojure.org/guides/spec#_explain

(s/def ::kws (s/with-gen (s/and keyword? #(= (namespace %) "my.domain"))
               #(s/gen #{:my.domain/name :my.domain/occupation :my.domain/id})))

> Note that with-gen (and other places that take a custom generator) take a no-arg function that returns the generator, allowing it to be lazily realized.

So it sounds like I want a zero-args function that returns a generator.

Kind of seems like that is what I have above… right?

Maybe gen/such-that is already a generator or maybe it is a spec?

remove the s/gen around the gen/such-that

gen/such-that is already a generator indeed

@thegeez You got it!

(s/def ::path
  (s/with-gen
    path
    (fn [] (gen/such-that #(-> % count (< 5)) (s/gen path)))))

Thanks, that helped me out a lot, data seemed to just take forever on generating without this. (though that may actually be my formater and not the actual generation). Fixed issues.

(s/def ::path
  (s/with-gen
    path
    (fn [] (gen/fmap #(vec (take 5 %)) (s/gen path)))))

Is actually slightly better, as it never fails to generate under the 100 try limit.

@alexmiller Suggestion: a special s/cat, primarily intended for specifying args in fdef, that automatically calls s/spec on each of its arguments

@alexmiller I feel like a lot of people have bumped their toe on the nested regex gotcha

I think that’s unlikely something we would add

and in general, I don’t find that that is (usually) what you want

it seems more common from specs I’ve written to have s/cat of s/coll-of for functions. For macros, you sometimes have this but I find it’s really important in that case to develop the awareness of when you are really needing to drop nested levels - that’s critical to build reusable parts, and often for making workable recursive specs

I think just making this clearer in the guides, in the specing functions section, would help

I found where it's mentioned now, but not when I was trying to work out what was wrong

You could argue I should have read the guide more thoroughly

for me, it was just forgetting that cat is a regex operator. I didn’t feel like the guide could have been much clearer about it.