Do you use clojure-lsp?

It has clj-kondo built-in, which is the main linter.

Currently i'm not using any but it seems that clj-kondo is available for vs-code. Thank you very much for pointing me in the right direction

For VS Code, you will want to install Calva. It comes with clojure-lsp and clj-kondo.

Hmm I was just looking at that, Calva is installed yet I see precious few warnings in my code. I don't think i'm that good as a beginner, so might need to play around to see if it's working right

clj-kondo has a lot of optional linters. Borkdude likes making new linters, but is pretty frugal about pushing them on people by default. If you see some warnings, but want to see more, Checkout the docs to add more linters to your setup. https://github.com/clj-kondo/clj-kondo/blob/master/doc/config.md#options https://github.com/clj-kondo/clj-kondo/blob/master/doc/linters.md

Thank you kindly I'll be sure to take a look

In terms of style guides, this one is the most widely followed: https://guide.clojure.style/ -- I'm not sure how much of it clj-kondo can enforce but Calva + LSP + Kondo is a great combination with VS Code!

(apply str [\a \b \c])

ffs

Okay thank you @U11BV7MTK

The fact that they are characters is irrelevant. It’s just dealing with the collection

Right - I just wasn't thinking of apply being the idiom for putting it together

is there an arity limit on apply str? would a phenomenally long list of characters via apply break a call to str ?

You tell me :). Try it out in your repl

:saluting_face:

https://clojuredocs.org/clojure.string/join can be used for this as well

@U01188CHUFL when you give many arguments to str, it is just a loop over the sequence adding one by one to a StringBuilder, so should be ok https://github.com/clojure/clojure/blob/master/src/clj/clojure/core.clj#L556-L561

clojure.string/join does the same, so they should be equivalent on the perf side

I did not validate it. But I would give reduce a try.

(reduce #(str %1 %2) "" ["o" "l" "a"])

That is the worst way to go about this

Strings are horrible accumulators for more strings. Look at the source of str to see how it accumulates parts of the final string in its reduce

it is going to constantly be creating StringBuilders and discarding them after adding one more String

also looks uglier than (apply str [...]) imo

the only thing faster is if your original list of chars is a char[], then you can just build the string with the char[] constructor, like (String. (char-array [\a \b \c]))

regardless of aesthetics, it can be catastrophic on large collections

(let [coll (repeat 1000000 "a")]
  (time (count (apply str coll)))
  (time (count (reduce str "" coll))))
"Elapsed time: 54.076833 msecs"
"Elapsed time: 49594.28475 msecs"
1000000

Nice! Thanks for the insight! Another doubt i was thinking of now: from a bigO notation perspective it would run the same amount, correct?

yes, they are both k*O(n) with very different ks

I’m not sure that’s true due to the constructor of the string builder

yeah, I guess it depends if the constructor is O(1)

looking at the source, it isn't, it copies the CharSequence, so I was wrong, it isn't O(n)