Oh whoops. Instrument just for args, duh. Lazy speed reading of slack posts is never a good idea :-(

cheers... I'll investigate it some more.

Any patterns to avoid things like this

(s/def ::dimensions/seq (s/cat ::dimensions/x ::dimensions/x ::dimensions/y ::dimensions/y ::dimensions/z ::dimensions/z))

@alexisvincent You could use s/tuple instead - or are you interested in the conforming behavior of s/cat?

Then I think your only option to avoid the redundancy is to write a macro around s/cat

->

(defn make-dimensions [& d]
  (s/conform ::dimensions/seq d))

hmm. was wondering if there was something like the destructureing {:keys []}

So you want to conform your sequential input into a map, right?

yep 🙂

Ah, how about s/keys*

I think that's what you're looking for

Well no, it's not, sorry 😄

That would require the keys themselves to be present in the input sequence, too

So yeah, you'll have to roll your own wrapper macro

@dergutemoritz Thanks 🙂 I wonder though if tuple is not what I want actually

@alexisvincent YW! Yeah, s/tuple would get rid of the redundancy but it wouldn't conform into a map

But perhaps you can live with that

Oh right.

I wonder if s/keys maintains order?

Because then I could write a function that first accepts req keys and then optional keys

in order

FWIW, here's a wrapper macro of the kind I'm talking about:

(defmacro keys-cat [& keys] `(s/cat ~@(interleave keys keys)))

(s/conform (keys-cat ::foo ::bar) [1 2]) => #:user{:foo 1, :bar 2}

Or maybe keys-tuple would be a more fitting name

@dergutemoritz Thanks 😄

maybe cat-keys

https://s-media-cache-ak0.pinimg.com/originals/c1/19/8f/c1198f0990a37c100437b8c31309c4e8.jpg

xD

is the general consensus to prefer namespaced keys in maps?

it seems so, for best synergy with spec

Are people generally using :: as a helper

Its a pain when wanting to use the spec in another ns… You have to specify the full mylonglongname.namespace.thing/name

becomes so long winded…

Or are people just registering thing/name

OH 🙂 :: can also be used for aliasing

also (require [some.ns :as n]) (is (= ::n/kw :some.ns/kw))

I guess that's what you meant

What is the best way of namespacing an existing map? Using a function, not the reader

@dm3 yep 🙂

@alqvist what do you mean? adding a namespace to the keys of a map?

there is no function to do that right now

@alexmiller exactly that - I made a small function for it. Posted it in #clojure

cool

Is there some preferred way of writing simulation-testable specs for functions with constraints between parameters? I have a function that takes a map and a key. The key must exist in the map for both the input and output. I can make it work by writing a custom generator for :args using bind, was wondering if there was a preferred method.

that is the preferred method

https://www.youtube.com/watch?v=WoFkhE92fqc

^^ is about that

Thanks, that's basically how I handled it.

I notice in the video that the generator override was specified directly in the test, rather than in the spec. Don't know that it makes much difference, though giving it in the spec would allow you to reuse the override if that spec was composed with others.

is there a spec or predicate for objects that have strict value equality? looking for something like a clojure.core/edn? or something like that

edn? isn’t quite right, since that’s about serializability, but would be close enough for my needs

that would be nice

any? is so close, but fails with NaNs

no, any? isn’t close - it includes functions

i have a procedure that will go in to an infinite loop if the function isn’t pure & i’ve been bitten a few times by including a function in it

so i’m doing like add-watch! does, which is force key values

I am pretty sure the generator for any? doesn't generate functions

generation aside, the spec is wrong if i allow functions 🙂

the generator for any? was way simpler than preferred last time I checked, there was a bug on test.check about it

i need a predicate like value-equality?

which i guess i could make, but it seemed like it might have been something that existed or should exist

i didn’t feel like exhaustively listing what’s in edn in a spec

I think there are some things in test-check with "printable" in their name?

I know we spent a lot of time building up stuff like that in the old data.generative

Certainly open to ideas

hmm “printable” is a good hint, i’ll look - thanks

the problem with the printable stuff is it generates NaNs

and those are generators, not predicates

alexmiller: this looks more or less like what i need. would be cool to have a predicate for it

Jira it up

Seems like we could also fix test.check re NaN (which is not currently printable)

http://dev.clojure.org/jira/browse/CLJ-2083

i think clojure.core/edn? would be the least objectionable formulation of this request

well, actually - may not

b/c that would be a “deep” predicate

i don’t think any such deep predicates exist - it would have O(N) runtime 😕

I think it's probably unlikely we would make that predicate

yeah - after realizing it was O(N), i realized that - but a spec makes more sense, right?

Well, definitely a generator, maybe a spec

besides the stuff in clojure.core.specs, are there any “standard” specs anywhere? i don’t think so, right? just predicates...

In this example from the spec guide, is the ability to key into the arguments with :start and :end created by the s/cat above the anon function? Does the destructuring happen such that the first expression given to s/and has an effect on what’s passed to the other?

(s/fdef ranged-rand
  :args (s/and (s/cat :start int? :end int?)
               #(< (:start %) (:end %)))
…

@jeremyraines yes, the s/cat conforms the data. s/and threads the conformed data

ok, thanks

Super useful for conformers that coerce between types.