medley has http://weavejester.github.io/medley/medley.core.html#var-distinct-by to do this

Thanks! I did a (->> coll (reverse) (distinct-by :id) (reverse)) and that did the trick

Note that there's also rseq which should be better for longer collections since it's created in constant time. The downside is that not all collection types support it (vectors do though).

If you didn’t care about order you could (->> v (map #(vector (:id %) %)) (into {}) vals)

snippet from my deps.edn:

:paths ["resources" "src/clj" "src/java"]

 :deps/prep-lib {:alias  :build
                 :fn     compile
                 :ensure "target/classes"}

(defn compile [_]
  (b/javac {:src-dirs ["src/java"]
            :class-dir class-dir
            :basis basis
            :javac-opts ["-source" "17" "-target" "17"]}))

(defn uberjar "build the uberjar" [_]
  (let [opts (uber-opts {})]
    (clean nil)
    (compile nil)
      (b/write-pom {:class-dir class-dir
                    :lib lib
                    :version version
                    :basis basis
                    :src-dirs ["src"]})
    (b/copy-dir {:src-dirs ["src" "resources"]
                 :target-dir class-dir})
    (b/compile-clj {:basis basis
                    :src-dirs ["src"]
                    :class-dir class-dir})
    (b/uber opts)))

Aha! I've figured it out. I just needed to get the compiled classes on the classpath.

deps.edn becomes simply

:paths ["resources" "src/clj" "src/java-classes"]

(defn compile-dev [_]
  (b/javac {:src-dirs ["src/java"]
            :class-dir "src/java-classes"
            :basis basis
            :javac-opts ["-source" "17" "-target" "17"]})) 

Looks good, simply keep in mind a .class file is not a source file. target/dev/classes would look a litte more standard

here is my explanations of agents https://clojure.wladyka.eu/posts/share-state/#agents

I don’t know what is your goal, so hard to answer if agent fit into your needs or not

but if you want to do parallel then use async instead of any above

this is more about managing state, not about performance

but async is for performance

at least how I see this

I have n operations to do I'd like to realize them with m active operations per time. Eventually, get the result. My goal is just realize n operations, with m active per time • not an async thing • not an performance thing

claypool

https://github.com/clj-commons/claypoole

pipeline or pipeline-blocking sounds like async for me. You want to control number of threads (`m` active per time) and process n items. With pipeline you set m and input data in 1 line.

(async/pipeline-blocking 3 csv-chan (map url->csv) (async/to-chan!! urls-to-sync))

I think that pipelines may work. let me try

There is no such a built-in function but you can implement it this way:

(defmacro with-pool [[bind threads] & body]
  `(let [~bind (Executors/newFixedThreadPool ~threads)]
     (try
       ~@body
       (finally
         (.shutdown ~bind)))))

;; then

(with-pool [pool 8]

  (let [futures
        (new ArrayList)]

    (doseq [chunk chunks]

      (let [fut
            (.submit pool
                     ^Callable
                     (fn []
                       (bla-bla)))]

        (.add futures fut)))

    (reduce + (map deref futures))))

You can't actually type hint function literals like that

hm, this code works, I took it from a real project. Without the ^Callable hint, there is a reflection warning.

It will work but still be reflective if you are tagging the function literal

But it will not be if tag a symbol that a function is bound to

My guess would be the project you took it from doesn't pass a function literal there

well, I copied a fragment were we pass an inline function. But the code might be easily refactored such that it accepts a function

I apparently am misremembering and have done it before https://clojurians.slack.com/archives/C03S1KBA2/p1667760502594819?thread_ts=1667757292.891349&cid=C03S1KBA2

Might have been a but that got fixed at some point

> I think that agents is kind of it. maybe it could be simpler if i use agents? Agents have send-via to specify a custom pool, probably it maps well to your q

yep, just an example:

(with-pool [pool 4]
  (let [a (agent [])]
    (doseq [x [1 2 3 4]]
      (send-via pool a conj x))
    (await a)
    @a))

[L...; is Java's way of saying "array of ..."

(and you are asking for the type of the array, not an element within it)

(.arrayType (.getClass (int-array 0)))
=> [[I
(.componentType (.getClass (int-array 0)))
=> int
(.componentType (.getClass (make-array java.util.Map$Entry 0)))
=> java.util.Map$Entry

Oh cool! Thanks @U2FRKM4TW!

works like a charm! thanks