Saw this once again: https://stackoverflow.com/a/21443241/855160

'^{:type :ratom} credential works!

So something like < and <= that also work on non-numbers? Why do you need these predicates? Where would you use them?

I use them on characters currently, but I’ve had other uses for them. They’re analogous to least and greatest from medley.

I'm not aware of any library that offers these but I feel that maybe it's an XY problem. > I use them on characters currently Yes but to what end? I mean maybe there's a better way to solve your actual problem without resorting to manual comparisons. E.g. to sort arbitrary data it would be better to https://clojure.org/guides/comparators

I’m writing a interval set for character ranges, for instace i have. a function:

(defn in [x [a b]]
  (and (less-equal? a x) (less-equal? x b)))

So you have a set of discrete values and a character and you want to do a membership check. I would: 1. build the set of characters based on the interval bounds 2. run (charset x) That way if charset is #{\b \d \c \e} and x is \e the result will be truthy, if charset is #{\b \d \c}, the result will be falsey.

Thank you. I want to avoid representing each character as this is for a regex engine and a interval set could potentially represent all characters.

Oh alright, I assumed ASCII 🙂 I think your solution is fine for bigger character sets. (Still, I'm not sure how meaningful Unicode ordering is, like should a smile emoji be greater than the plus sign emoji?)

I haven't tried but I would assume regex character classes us codepoint ordering.

Not sure whether it'll work but try

(definterface GoTest
  (Add ^long [this ^long x ^long y]))

Same result, sadly

Oh, wait, you have extends in the Java code.

Is that unsupported in Clojure?

Indeed, definterface by itself doesn't have that ability. But you can use gen-interface.

Oh, and also - my bad for not realizing this - methods you specify in definterface don't accept this. So also remove this from there.

Let me try out gen-interface

Awesome! This works:

(gen-interface :name "clojure_go.core.GoTest"
                 :extends [com.sun.jna.Library]
                 :methods [[Add [Long Long] Long]])

Thanks for the tip 😄

Great! :)

@UG9U7TPDZ you could also consider implementing a golang pod so you can call it through the babashka.pods library which also works in the JVM. No native stuff :)

Interesting idea :thinking_face: But you would have a communication bottleneck I think. But maybe that would be really minimal

The reason I want to call Go is for performance

it depends on if you have: 1. many function calls 2. big sized arguments (as they are serialized) So if the overhead of the function call serialization is small compared to the actual work happening in Golang per function call then it would be a good fit. E.g. the sqlite3 pod and file watcher pod fall into this category

but if you add two numbers, and want the result then that's probably not a good fit

Right, for my usecase this might actually be a good fit. Not sure how I'd implement this though. Also I haven't gotten my own example working in GraalVM yet lol

But I'll think about this, thanks

there has to be no graalvm involved. you can look at the existing babashka pods in golang here: https://github.com/babashka/pod-registry

@UG9U7TPDZ Another option might be to use #coffi and project Panama on JVM 17

or dtype.next

Coffi also looks interesting, trying that out now

If you're targeting graalvm, then I think dtype.next is the best option. I don't think coffi works with graalvm. If it does, that would be good to know!

But does @UG9U7TPDZ target graalvm native? I haven't read that he did... Please don't leave us in suspense!

Yeah I'm targetting graalvm (eventually)

> The reason I want to call Go is for performance I'm not sure if I understand that one. Go in general shouldn't be more performant than Java, or is it?

dtype next isn't too bad once you set it up. Here's some examples • https://github.com/phronmophobic/grease/blob/7a9a17e78e91d55cca2a3895acb61c4c56710504/src/com/phronemophobic/grease/objc.clj#L25 • https://github.com/phronmophobic/grease/blob/7a9a17e78e91d55cca2a3895acb61c4c56710504/src/com/phronemophobic/grease.clj#L63

I'm happy to answer any questions. clojure <-> c interop unlocks a lot of potential!

although I agree with @U04V15CAJ that if the goal is performance, I'm not sure calling go from clojure will give you any better results than either calling java or optimizing your clojure code.

I was under the impression that Go did have a bit of an edge in terms of performance from the benchmarks I've seen, but maybe that's a bit misleading

Measure for your specific problem and in the typical scenario you're using it. Performance is hard to speak about in general is usually very contextual.

E.g. the JVM JIT may outperform Go when you run the program long enough

So you want to stop iterate nor from the consumer but from the f itself?

Ya, kind of what (take 5) does where it stops after 5

I wonder how take does that

I found a workaround:

(->> (iterate (fn [x] ...))
     (take-while (complement reduced?)))

That lets me return a reduced from the iterate fn and it'll stop. But I'm still curious, like how does take-while short-circuits the infinite seq to make it finite?

The implementation is rather trivial.

Hum... right so with lazy-seq, nil short-circuits, but I guess nothing can make iterate short-circtuits so you need to wrap it and not poll it anymore

That's right.

That answers my question haha, seems you can't short-circuit iterate, but wrapping it is pretty trivial and solves my issue cleanly enough

There is the new function, maybe iteration? That includes a stop condition