There is no consensus as far as I know. What matters is your API design. If someone else is using your tool, what interface should they be presented with? Think "developer experience", and communicating with other people through code. You could: • decide that everything is public and rely on documentation to communicate about the API. • make it implicit with public / private definitions. • have two namespaces like • mylib.core : public interface, default ns • mylib.impl : technical stuff • etc… Note: private vars is a Clojure thing. In ClojureScript everything is public.

(A better place for questions like this in the future is #tools-deps )

The pom reading local jar deps is not something you can turn off right now, but if you're not finding or including it's deps, seems unlikely to succeed

Another option would be to install the jar in your local maven repo and just use it as a Maven dep

clj -X:deps mvn-install :jar '"/path/to.jar"'

It will pull the group/artifact/version from the pom inside the jar, and that's what you would use as coords

Great, thanks very much - I’d considered installing in local maven repo, but wasn’t sure exactly how. Will give it a go. Thanks again 🙂

Unfortunately, when I try and run the mvn-install bit, above. It encounters the same issue with the (undoctored) jar - version env variables not being sub’ed in 😞

You can also supply the :lib and :version to use instead

As options on the command line

I saw that mentioned in the deps docs, but couldn’t find any more info on it. I’ve tried: clojure -X:deps mvn-install :jar '"resources/SparkJDBC42.jar"' :lib com.simba.spark.jdbc.Driver :version '"2.6.19.1030"' But that gives me a npe:

Installing resources/SparkJDBC42.jar 
Execution error (NullPointerException) at java.util.regex.Matcher/getTextLength (Matcher.java:1770).
null

am pretty sure the :lib needs to be the classpath as it wanted a class rather than a string; it’s picking up the JAR, so am I providing the :version incorrectly?

:lib should be a qualified symbol in form group/artifact

so :lib spark/jdbc or something like that (not sure what it should be)

gotcha, will look at the (sparse) driver docs

I mean it doesn't really matter but you'll need to use that as your lib name when you refer to it later in your :deps

whatever they have in the pom inside the jar for groupId and artifactId would be one place to look

yep, that’s what I just did…

clojure -X:deps mvn-install :jar '"resources/SparkJDBC42.jar"' :lib Spark/SparkJDBC42 :version '"2.6.19.1030"'
Installing resources/SparkJDBC42.jar 
Installed to /home/vscode/.m2/repository/Spark/SparkJDBC42/2.6.19.1030

I think you're looking for https://clojuredocs.org/clojure.set/join

Hmm, not quite able to get the result I want out of this. It omits ids 2 and 3 since they don't exist in both sets.

clojure.set/join will give you the common items, the way you want them then you can concat with the items that are unique in each collection

You can use group-by and merge/`merge-with`

(let [x [{:id 1 :foo 11}
         {:id 2 :foo 22}]
      y [{:id 1 :bar 33}
         {:id 3 :bar 44}]]
  (->> (merge-with concat (group-by :id x) (group-by :id y))
       (mapv #(apply merge (val %)))))

with join:

(let [x [{:id 1 :foo 11}
         {:id 2 :foo 22}]
      y [{:id 1 :bar 33}
         {:id 3 :bar 44}]]
  (let [common     (set/join x y {:id :id})
        common-ids (set (map :id common))]
    (concat common
            (remove #(common-ids (:id %)) (concat x y)))))

(let [x [{:id 1 :foo 11}
         {:id 2 :foo 22}]
      y [{:id 1 :bar 33}
         {:id 3 :bar 44}]]
  (->> (merge-with concat
                   (group-by :id x)
                   (group-by :id y))
       vals
       (map #(apply merge %))))

@U024X3V2YN4 @UEQPKG7HQ Thank you both. These are fun 🙂 I like the solution from @U024X3V2YN4 for its brevity. Came up with this one too but it seems a touch slower:

(let [x #{{:id 1 :foo 11}
          {:id 2 :foo 22}}
      y #{{:id 1 :bar 33}
          {:id 3 :bar 44}}
      joined (clojure.set/join x y)
      union (clojure.set/union x y joined)
      indexed (vals (clojure.set/index union [:id]))]
  (map #(apply max-key count %) indexed))

From https://stuartsierra.com/2019/09/11/clojure-donts-short-fn-syntax

syntax quote can be helpful to see what the reader syntax expands to

user=> `#([:li %])
(fn* [p1__3__4__auto__] ([:li p1__3__4__auto__]))

I think I was trying to say that -- at some step i've been mentally inserting, or failing to insert, the parens that make that list of +, 1, and 2 a function call

to me its a hack to work around how the function reader macro works. and as such i don’t like it. And for me, do means side effects

it's a convenience, and a very readable one, for a common need, imo. I guess you could call it a hack but in plenty of cases idioms start out that way

yeah. it does work. and its not a huge deal

it really speaks to the need for what is essentially a template, as in "stick the value in this template"

it's definitely not

not a big deal at all

actually cant think of A good use case for (map #(do [%]) values) If I'm pulling out individual value from a [] I'm usually wanting to mangle the values somehow ...

the original need was a usecase for it if you don’t mind the #(do [:li %]) form

I just really like how that looks like a template without much ceremony cluttering up the meaning, or at least that's what it feels like to me. it's all feeling, I guess

(#(conj [:li] %) "test") first part of a () always has to be a function unless preceded by a '

but I'm pragmatic and most people who care about it care about it not being that and so it's a smoother ride on shared code bases if I don't use it

👍

99.9% of the times I have needed a do in a function I've also needed a let . So it becomes let instead.

(apply map + input) (where input is your seq of seqs.

That works! Thanks, could you help me understand why?

I still can't distinguish between apply +, map +, and reduce +

apply says put map followed by each seq in your seq of seqs, and the extra arg + is inserted after map so you get (map + (5 2 4) (2 3 6) (8 3 9))

user=> (apply map + '((5 2 4) (2 3 6) (8 3 9)))
(15 8 19)
user=> (map + '(5 2 4) '(2 3 6) '(8 3 9))
(15 8 19) 

Calling apply in that case ends up being similar to directly invoking (map + '(5 2 4) '(2 3 6) '(8 3 9)) As the docstring for apply says, it... > Applies fn f to the argument list formed by prepending intervening arguments to args. In the case of the above input collection, it has the effect of "exploding" the collection to its constituent elements.

Thanks!!

(apply + [5 2 4 6]) is equivalent to (+ 5 2 4 6). it 'spreads' a passed collection into multiple arguments to the function (map + [5 2 4] [2 3 6]) is equivalent to [(+ 5 2) (+ 2 3) (+ 4 6)]. when you pass multiple collections to map, it applies the function to the first elements, then the second elements, then the third elements and so on. (reduce + [5 2 4 6] is like (+ (+ (+ 5 2) 4) 6). it reduces a collection down by applying the function successively to the result so far and the next item