I am calling generate on a complex data structure. Sometimes I see this error. I would normally troubleshoot this by commenting out parts of the spec to zone in on the problem; but I'm wondering if there is a smarter way to debug generators

is there a direct way to dicover the specific sub-spec that has the problem?

okay another question; I want a generator that has two modes of operation • when there is data available in the dynamc variable *existing-ids* then I want it to behave like (element *existing-ids)` • when *existing-ids* is empty then I want it to behave like (spec/gen string?) this must be a fairly common use case how has it been solved before?

I'm thinking something like

(test.gen/bind
  (test.gen/return nil)
  (fn [_]
      (if (not-empty *existing-ids*)
        (test.gen/elements *existing-ids*)
        test.gen/string-alpha-numeric)))

that doesn't seem a very smart solution though

I think that's the best I can do, unless I hack directly into

(defn- bind-helper

(defn- make-gen

(def ^:dynamic *existing-ids* nil)
=> #'dev/*existing-ids*
(def gg (test.gen/bind
          (test.gen/return nil)
          (fn [_] (if (not-empty *existing-ids*)
                    (test.gen/elements *existing-ids*)
                    test.gen/string-alphanumeric))))
=> #'dev/gg
(spec.gen/generate gg)
=> "9Dlv2SuFqT4Jb"
(binding [*existing-ids* [:this :that :tother]]
  (spec.gen/generate gg))
=> :that

I suppose I could store the test.gen/elements in the *existing-ids* var

(spec/with-gen takes a gen-fn, and I'd hope that I could use this to choose between generators, but of course it doesn't get called very often

this might be better actually

(defn build-indirect-gen 
  [vargen] 
  (test.gen/bind
    (test.gen/return nil)
    (fn [_] (deref vargen))))

(def ^:dynamic *existingids-gen* test.gen/string-alphanumeric)
(def gg (build-indirect-gen #'*existingids-gen*))

(binding [*existingids-gen* (test.gen/elements [:this :that])]
  (test.gen/generate gg))
=> :that 

(test.gen/generate gg)
=> "Sjeu5IwBWbMUZl"

@ben.hammond afair, Gary touched on it debugging "Couldn't satisfy such-that predicate after 100 tries" here: https://www.youtube.com/watch?v=F4VZPxLZUdA

this is the timestamp

https://youtu.be/F4VZPxLZUdA?t=976

I've not seen that video. that's very interesting

i'd not seen the size/scale explained properly before

I'd assumed they represented mean/standard deviation

I'm sure this has been asked and answered, but I can't find the answer... Why can I not do the following?

(s/def ::a any?)
(s/def ::thing (let [ks [::a]] (s/keys :req ks)))

I'm guessing that macros are the only way to dynamically define specs?