Is it possible to exclude part of my project from being included in the uberjar depending how I call leiningen? nevermind

in Clojure, is it possible to construct looping (but non lazy) values x, y such that (= x y) infinite loops?

Both infinite and non-lazy?

(defn loop-forever [number] (do (println number) (recur (+ 1 number)))) use at your own risk 😛

following on from that, and just for jest, would it be possible, just thinking, of using clojure reducers, to pretty much cause heat death by having each processor core sum an infinite sequence of numbers...

would it make sense for clojure itself to enable some sponsporing options? via Github you can now enable several sponsporing links, e.g. patreon, opencollective. if most of the Clojure users would chip in for a couple of dollars a month, would that make a difference to the development of Clojure?

hey everyone, got a super weird bug i’m kind of stuck on. i have a collection of 6000 32-byte arrays that i’m sorting with a function compare-bytes. (sort compare-bytes coll). when the comparison function hits a particular element, it throws an exception Comparison method violates its general contract!

if i generate a separate collection of 6000 randomized 32-byte arrays, it works fine. even beyond 50,000 elements, no exception is thrown

it’s only with this specific collection. i can see nothing odd about the element on which the comparison function breaks down

also, (= 6000 (count (distinct (map bytes->hex coll))))

can you post your compare-bytes fn?

oh yeah, should have mentioned: it’s not mine, it’s the one in ztellman/byte-streams

i’ll get a link

https://github.com/ztellman/byte-streams/blob/3e0822b58172b8d351b366213eda6090892e32b3/src/byte_streams.clj#L912

wrap it in your own comparator function that catches and prints the inputs

i tried this earlier, but the exception comes from the sort and not the comparison, so i’m not sure how to grab the breaking elements

i guess i could just print all of them. one sec

I believe you get this exception in Java when the transitive property doesn't hold (that is, e1 > e2 and e2 > e3 but NOT e1 > e3), which is presumably something the sort relies on

yeah, that’s what google seems to say

must the function only return something ε [-1, 0, 1]? i noticed it can return other values

Ooh! Debugging why a comparator is not a total order. Looking at it ...

can be other values

The JVM can handle negative, 0, positive fine.

i mean they seem correct (negative when l<r etc)

given that this is a property, it's a perfect candidate for a generative test with test.check

ha, seems it’s been done https://github.com/ztellman/byte-streams/blob/b5f50a20c6237ae4e45046f72367ad658090c591/test/byte_streams_simple_check.clj

that's not a transitivity test

oh, guess it’s not really checking transitivity

yeah

but could easily be extended to do so! :)

just gen a / b / c, and verify that if a>b and b >c, that a>c

test.check will spit you back a failing example

sweet! on it

Something that seems odd to me in cmp-bufs, which the function you linked calls in most/all cases - it calls a ByteBuffer .getInt method in some cases, or .get. From my reading of Java API, those mutate a "position" member of a ByteBuffer object. I don't yet see anything that initializes this position back to the beginning of the ByteBuffer, which would be a problem if the same ByteBuffer was compared more than once.

case anyone is interested in the issue @gtzogana was asking about, but doesn't want all the gory details in the thread, I do not know if I have fixed the bug he found, but I have a proposed fix that definitely improves the result of compare-bytes for a bad case I found where it can return (x < y) and also (y < x) for many pairs of byte streams x and y. https://github.com/ztellman/byte-streams/pull/39 is the PR if you want to track it.

I thought datafy could transform a Java object into Clojure data, am I wrong?

Like say I want to extract all values from a Java object into a Clojure datastructure instead like say EDN

And I want that to be deep

yes

in the sense that datafy by default doesn't do anything

So, when I call datafy, it just prints the object memory address

right

(defprotocol Datafiable
  :extend-via-metadata true

  (datafy [o] "return a representation of o as data (default identity)"))

if you have something you want turned in to data in a particular way, you have to extend the protocol to do it

Oh. Okay I guess I assumed that Java objects had a smarter default then identity

I am also not sure how deep the 'datafy' should go

from my understanding a intended use case is kind of a cycle from datafy to nav and back again

you datafy something, then nav to something it references, then datafy that, etc

Oh right, so each datafy is one level. And to go deeper you have to recursively datafy. Makes sense. So it handles circular graphs

or things that are method calls returning data under that object, which may be newly generated or may just be a getter for existing contents

Think of datafy/`nav` as an extended, explicit form of laziness.

I still wished there was a default datafy for objects.

Don't really want to implement my own reflection field parsing

for things that use normal getter methods, there's bean

and there's definitely other reflection libs for making data out of objects that satisfy a few assumptions, IIRC TimMC made one...

Ya, bean is there, but not deep. It's okay, I'll just use GSON

And then Cheshire to pull that into Clojure

Hum... there seems to be clojure.java.data

yes, java.data works too and makes different choices

does cognitect's aws-api library support signing CloudFront URLs? i inspected the ops of com.cognitect.aws/cloudfront but don't see anything related. same with com.cognitect.aws/signer.

it does not @joshkh

it may be worth having an add-on library that does presigned URLs for cloudfront + s3

out of curiosity, what would you name this function?

(defn- foo
  "Take `n` random elements from `coll`, choosing those that satisfy `pred` first."
  [n pred coll]
  (let [[preferred rem] ((juxt filter remove) pred coll)]
    (take n (concat (shuffle preferred) (shuffle rem)))))

extract or pluck would be my suggestions

I was thinking something like take-rand-preferring or take-rand-biased but bias might suggest probability

I like the word draw (as in drawing a hand of cards), but that would probably be more confusing due to double meaning

naming things is hard. 😅

random-sample

random-sample is in clojure.core

it’s hard but I find it weirdly enjoyable

sample-randomly 😆

I accidentally wrote random-sample on IRC, and someone on the channel was like "I know you are joking but that's actually useful" and it ended up in core

it's too simple to take much credit for, but I found the whole process amusing