clojure.lang.IHashEq tells you whether the object implements .hasheq(). Is there a single interface that tells you whether the object implements .equiv(other)?

Are there any good examples of writing test.check generators for data-dependent sequences? I’m trying to figure out how to use test.check to model a finite state machine, and the best thing I’ve got is recursive application of choice of functions of a state to a state with a longer execution history. Writing that out as a reduction is pretty simple and definitely works, but it’s kinda hard to model in a way which integrates with the rose tree AFAIK.

gen/recursive-gen isn’t really what I want, because there’s a recursive structure to my generator I want to capture.

I guess one way to do it would be to (gen/fmap (fn [[seed-state xformers]] (reduce #(%2 %1) seed-state xformers)) (gen/tuple (s/gen ::state) (gen/vector (gen/one-of transformers))))

@puzzler I looked around the source for a few minutes and could not find an interface that tells you whether an object implements .equiv(other)

Consider (defrecord T [^long x]) and then (:x (T. 1)). Am I correct that this expression will not return a primitive, and to get a primitive you need (.-x (T. 1)) ?

Similarly, if I do (assoc (T. 1) :x 2), that 2 is going to get boxed and then immediately unboxed for storage in the defrecord, correct?

For Clojure at least that is correct - invoking the Keyword can only return a boxed value and no attempt is made to inspect the right hand side and determine that the keyword access could be a field access with a primitive type although the keyword as a field getter has some efficient machinery. I believe that your second example/statement is correct.

But the only way to really know is to no.disassemble it

Hey guys, I made a tool in Cljs to translate boot-clj and Leiningen :dependencies to the newer deps.edn format: https://theronic.github.io/depsy/ (source on GitHub)

Hello, what’s your favourite Clojure query DSL for production?

^ Are you talking about SQL?

What are the benefits of using namespaced keywords for applications, practically, assuming you don't care about namespace clashes ?

if the use of a keyword assumes a ns has been required, you can use a namespaced keyword and refer to it with a namespace alias, that way you ensure it's been required

(think about spec, re-frame...)

also, semantics

What's the difference between s/every and s/coll-of ?

Unlike 'every', coll-of will exhaustively conform every value. got it

(t/are [x y]
      (= (let [{:keys [a b]} x] [a b]) y)
    {:a 1 :b 2} [1 2]
    {:a 1 :b 2} [2 2] ;; false
    {:a 3 :b 4} [3 4]
    ) ;; true

eh, the second binding is clobbering the previous a and b? Maybe renaming the second set of bindings?

wait...

no, it just returns the result of the last test

I misread the binding

(t/are [x y]
        (= x y)
      :not :equal         ;; fail
      :not-this :either ;; fail
      [2] [2]
) ;; true

Returns the result of the last test

(defmacro all-are
  [argv expr & args]
  (if (or
       (and (empty? argv) (empty? args))
       (and (pos? (count argv))
            (pos? (count args))
            (zero? (mod (count args) (count argv)))))
    (let [c (count argv)]
      `(clojure.core/and 
        ~@(map (fn [a] (clojure.template/apply-template argv `(clojure.test/is ~expr) a)) 
               (partition c args))))
    (throw (IllegalArgumentException. "The number of args doesn't match are's argv."))))

clojure.test/is and clojure.test/are are like assertions, you shouldn't care about the return value

naw, that didn't work confused typo

ah k

Is there a way not to parameterize HoneySQL values? E.g.

(honeysql.format/format
 (-> (h/insert-into :FOO)
     (h/values [{:a 1 :b 2 :c 3}])))
;; => ["INSERT INTO FOO (a, b, c) VALUES (?, ?, ?)" 1 2 3]

☝️ Seems like I can map honeysql.core/inline to all map values

@xiongtx There's also an #inline reader literal in HoneySQL: [{:a #h/inline 1 :b #h/inline 2 :c 3}] should result in only 3 becoming a parameter.

Hello! Is there a way to tell which procols an object implement? When dumping certain objects in the repl I get things like reify__1987, which isn’t very descriptive

no

you can ask if an object satisfies a specific protocol using satisfies?

So if I see an object described as reify__1987 (or similar), I have no way to figure out what that thing is?

the protocols implemented don't tell you what it is anyway

So...I converted some local project from lein to deps.edn for fun. One thing that surprised me was when my Project2 had a dependency of type ":local/root" to Project1. Project1 (also using deps.edn) had a dependency to "httpkit". I expected that Project2 would retrieve the transitive dependencies, but no. I had to add "httpkit" as a dependency to Project2 as well. Is this the way it is supposed to work?

...do I always need to add transitive deps to my "deps.edn"?

that would surprise me quite a bit

that sounds like there is a problem with the deps.edn @andnils

Im looking for a fun side project to work on using clojure

if anyone wants or needs a code monkey i am available