@hkjels just (s/def ::hiccup (s/tuple #{:div :span} string?))?

So Stuart Halloway gave a talk on Clojure spec at Strange Loop 2016 that I am transcribing now (mostly done), where he said this: 'So one of the things that is fun about developing with spec is: as soon as you have made a spec, and it can even be a very rudimentary one, you can then say "give me example data" or "give me example functions that do this".'

If you want to see it in context of the full text, you can search for that quote here: https://github.com/jafingerhut/talk-transcripts/blob/add-halloway-agility-robustness-clojure-spec-transcript/Halloway_Stuart/AgilityRobustnessClojureSpec.md

The part that I am wondering how to do is the part where he says "give me example functions that do this". Does anyone know if that is possible, and if so, has examples of doing that?

fspecs can be generated I think

(def my-fn (-> (s/fspec :args (s/cat :x int?) :ret string?)
               (s/gen)
               (gen/sample 1)
               (first)))
(my-fn 1)
=> "8VRbFJ59e2K2Ic79F8CX8HB1"
(my-fn 1)
=> "WSKN70JT5kZG"

is it just making a function that ignores its inputs and using the :ret spec to generate return values?

> fspecs can generate functions that validate the arguments and fabricate a return value compliant with the :ret spec, ignoring the :fn spec if present.

Well you could try doing (my-fn "string") and see if it complains

Because you are giving it an int right?

it does validate the inputs, I asked before I read the docstring 🙂

ah

:thumbsup:

yes the return is unrelated to the input I think

I made a ticket many decades ago to discuss whether it should at least be a pure function

it's also currently independent of the test.check seed I think

You can use orchestra to make it related with the :fn i think?

I think that only applies to instrumentation

I think this is a really dumb question, but how can I detect which branches were taken/captured in a s/cat?

doesn't the conformed value tell you that?

yeah I can see it in the data, I was just wondering if there was a function you could call to get back which parts matched

the context is that I'm trying to parse defn forms and reassemble them with tracing wrapped around parts of the function

and the function specs have quite nested data that is a little bit annoying to pull out

So I end up with this disgusting code:

(defmacro fn-traced
  [& definition]
  (let [conformed (s/conform ::ms/fn-args definition)
        name      (:name conformed)
        bs        (:bs conformed)
        arity-1?  (= (nth bs 0) :arity-1)
        args+body (nth bs 1)]
    (if arity-1?
      (if (= :body (nth (:body args+body) 0))
        (if name
          `(fn ~name ~(:args (:args args+body))
             ~@(map (fn [body] `(dbgn ~body)) (nth (:body args+body) 1)))
          `(fn ~(:args (:args args+body))
             ~@(map (fn [body] `(dbgn ~body)) (nth (:body args+body) 1))))
        ;; else :prepost+body
        (if name
          `(fn ~name ~(:args (:args args+body)) (:prepost (nth (:body ~args+body) 1))
             ~@(map (fn [body] `(dbgn ~body)) (:body (nth (:body args+body) 1))))
          `(fn ~(:args (:args args+body)) (:prepost (nth (:body ~args+body) 1))
             ~@(map (fn [body] `(dbgn ~body)) (:body (nth (:body args+body) 1)))))

        )
)

was wondering if there's a pattern for doing this in a cleaner way

small critique, seems like the if name bits could be done inside the (fn ... part to avoid repeating the whole fn expression

both times

or I might be missing something

but if there is no name then I'll end up with (fn nil [] ...)

oh right, I didn't pay attention

Am I possibly approaching this whole thing in the wrong direction?

Feels pretty dirty

@alexmiller anything missing for https://dev.clojure.org/jira/browse/CLJ-2311 ?

I'll be able to clean this up a lot, but here's how it turned out:

(defmacro fn-traced
  [& definition]
  (let [conformed (s/conform ::ms/fn-args definition)
        name      (:name conformed)
        bs        (:bs conformed)
        arity-1?  (= (nth bs 0) :arity-1)
        args+body (nth bs 1)]
    (if arity-1?
      (if (= :body (nth (:body args+body) 0))
        (if name
          `(fn ~name ~(:args (:args args+body))
             ~@(map (fn [body] `(dbgn ~body)) (nth (:body args+body) 1)))
          `(fn ~(:args (:args args+body))
             ~@(map (fn [body] `(dbgn ~body)) (nth (:body args+body) 1))))
        ;; else :prepost+body
        (if name
          `(fn ~name ~(:args (:args args+body)) ~(:prepost (nth (:body args+body) 1))
             ~@(map (fn [body] `(dbgn ~body)) (:body (nth (:body args+body) 1))))
          `(fn ~(:args (:args args+body)) ~(:prepost (nth (:body args+body) 1))
             ~@(map (fn [body] `(dbgn ~body)) (:body (nth (:body args+body) 1))))))
      ;; arity-n
      (let [bodies (:bodies args+body)]
        (if name
          `(fn ~name
             ~@(map (fn [a+b]
                      (println "A+B" (:body a+b))
                      (if (= :body (nth (:body a+b) 0))
                        `(~(:args (:args a+b))
                           ~@(map (fn [body] `(dbgn ~body)) (nth (:body a+b) 1)))
                        ;; prepost+body
                        `(~(:args (:args a+b))
                           ~(:prepost (nth (:body a+b) 1))
                           ~@(map (fn [body] `(dbgn ~body)) (:body (nth (:body a+b) 1))))
                        ))
                    bodies))
          `(fn ~@(map (fn [a+b]
                        (println "A+B" (:body a+b))
                        (if (= :body (nth (:body a+b) 0))
                          `(~(:args (:args a+b))
                             ~@(map (fn [body] `(dbgn ~body)) (nth (:body a+b) 1)))
                          ;; prepost+body
                          `(~(:args (:args a+b))
                             ~(:prepost (nth (:body a+b) 1))
                             ~@(map (fn [body] `(dbgn ~body)) (:body (nth (:body a+b) 1))))
                          ))
                      bodies)))))))

@mpenet here's how to not repeat the name section twice:

`(fn ~@(when name [name])
           ~@(map (fn [a+b]
                    (if (= :body (nth (:body a+b) 0))
                      `(~(:args (:args a+b))
                         ~@(map (fn [body] `(dbgn ~body)) (nth (:body a+b) 1)))
                      ;; prepost+body
                      `(~(:args (:args a+b))
                         ~(:prepost (nth (:body a+b) 1))
                         ~@(map (fn [body] `(dbgn ~body)) (:body (nth (:body a+b) 1))))
                      ))
                  bodies))

Wrap a single element in a collection and then unsplice it

right

😈

what would be the most idiomatic way of expressing xor for two keys in a map?

it is possible to actually define xor and use it in :req, but I do not guarantee that that will work forever

separately you can s/and around the map to enforce a predicate

That's a bit better:

(defn fn-body [args+body]
  (if (= :body (nth (:body args+body) 0))
    `(~(or (:args (:args args+body)) [])
       ~@(map (fn [body] `(dbgn ~body)) (nth (:body args+body) 1)))
    ;; prepost+body
    `(~(or (:args (:args args+body)) [])
       ~(:prepost (nth (:body args+body) 1))
       ~@(map (fn [body] `(dbgn ~body)) (:body (nth (:body args+body) 1))))))

(defmacro fn-traced
  [& definition]
  (let [conformed (s/conform ::ms/fn-args definition)
        name      (:name conformed)
        bs        (:bs conformed)
        arity-1?  (= (nth bs 0) :arity-1)
        args+body (nth bs 1)]
    (if arity-1?
      `(fn ~@(when name [name])
         ~@(fn-body args+body))
      ;; arity-n
      (let [bodies (:bodies args+body)]
        `(fn ~@(when name [name])
           ~@(map fn-body bodies))))))

By mistake, but it surprised me:

(s/def :dropdowns/options (s/coll-of :dropdowns/options))
(s/valid? :dropdowns/options []) ;; true, ok, I can get that
(s/valid? :dropdowns/options [[]]) ;; true, uuh...

:thinking_face:

coll-of doesn’t limit cardinality by default

0 size is valid

yes, I get that

Use :count, :min-count etc if needed

what is your spec for :dropdown/option ? suprised it allowed [[]]

no, you see, it’s recursive

oh right

Sorry missed that

I missed that too, but then I was surprised about this behavior, because spec will allow arbitrary nesting of empty colls this way

I don’t know if set theory is happy with this

the way to justify: an empty coll is a valid :foo, a collection of empy collections is a collection of valid :foo, hence an arbitrarily nested empty coll is a valid :foo

so actually this is a spec for arbitrarily nested empty colls

if you re thinking about monoid instances, it's perfectly valid imho

well if you think about types, a [a] isn’t the same as [[a]]

yeah but the mempty of [a] is []

but yes, no type annotation to validate that [] is indeed potentially a coll of foo

but other than that it's ok

I guess

it’s an unexpected way to describe all possible sets of empty sets

(s/valid? ::empty-nested [[] []]) is also true of course

spec cannot go that far. same problem with (s/def ::first-name string?) (s/def ::last-name string?)

using ::first-name instead of ::last-name in an fdef args signature will be silent, in haskell it would scream at you

same shape, not necessary same meaning

yes, I guess that makes sense. it’s enabled things too

no such thing as newtype or some kind of wrapper for validation

yes, it's all trade-offs I guess

How would you write this:

(s/def :dropdown/option (s/keys :req-un [:dropdown-option/id
                                         :dropdown-option/label]))

>dropdown-option/id Says to me, thats the id of the dropdown option. >dropdown/option-id Says to me, thats the option-id of the dropdown

I use a little helper and create a new namespace for it

https://github.com/mpenet/spex/blob/master/src/clj/qbits/spex.clj#L7-L10

(rel-ns 'dropdown.option)

then ::dropdown.option/id

That's what I found to be the least horrible so far.

I could just use the dot anyway right? without creating a namespace?

Yeah

you can use a keyword with a dot yes

ok, I’ll do that then

Is it possible that both s/conform and s/valid are failing, but s/explain returns Success!?

Not doing anything fancy. Clojure 1.9.0

ok, nevermind, forgot to reload ns

any case of that is a bug