just def, in Clojure, everything is constant by default. :const has other implications regarding compilation

as far as I understood adding :const will improve the runtime. thus best practice?

Does your code have stringent performance constraints?

No, it has not. I just wanted to learn and apply the best possible option 🙂 .

Is there a reason why I should not make use of :const ?

Yes, because some things can't be made into a const and then the code which uses them will fail and you'll scratch your head. The best possible option is to start with def Then if you build an application use direct linking Then check if you have performance issues Then profile Then realize you're probably blocking on an IO thread or non optimal algorithm, fix it and go have beer It's not that const has no use, but it's rarely required. The defaults are good :)

Thx for the info! 🙂

What kinds of things cannot be made into a const?

ref types, I think, java types. they can be made into a const, but every piece of code using this const will break

You speak as if from personal experience Ben 🙂

(count (second (re-find #"^(#*)" s))) (count (take-while #(= \# %) s)) something like that ?

yea maybe I am overthinking it :thumbsup:

I assume that args can be multiple things, thus due to ambiguity it does not work. just guessing :)

Destructuring works, I'm curious why it works, even though the args are not a clojure.lang.PersistentArrayMap

Sorry, misread 🙃

You can apply map destructuring to sequential collections (like rest args) as if those were the kvs

This is sometimes called kwarg destructuring which allows you to pass alternating keyword / value options at the end of your function call, then destructure them like a map on the rest args

what argument did you invoke the function with?

This map

(def cart [{:name "Silicone Pancake Mold" :price 10.49}
           {:name "Small Pour-Over Coffe Maker" :price 18.96}
           {:name "Digital Kitchen Scale" :price 24.95}])

that's not a map

It's seems that you are right,

(def tax-rate 3)
(add-sales-tax {:price 4}) // => 12

but your original idea is correct. a let returns its last form in the let body

was actually (map add-sales-tax cart) 🙂 And thx for the clarification!

(let [x 1] inc dec (+ x 1)) just returns the (+ x 1) form

So I have to be more careful with my parentheses 🙂 .

Java can't handle dashes thus underscores are used when defining the structure of the project.

it is, of course, subjective, but I sort of get the impression that it's generally frowned upon.<https://stuartsierra.com/2018/07/06/threading-with-style> explicitly calls this out as a "don't". And in this case in particular, the partition call is the only thing being "thread-lasted", so a couple viable options include just calling partition directly on the thread-firsted form (e.g. move partition 15 to replace ->> ) and using a let

interesting read, thank you

Not sure if this will apply to your data structure but a few times I've been able to use this really elegant way of turning rows into columns: (map apply vector my-data) I found in the clojuredocs for map: https://clojuredocs.org/clojure.core/map#example-542692cac026201cdc326b01 (it's the last example in this small block of examples)

you might be able to replace vals and then flatten with (mapcat vals) but that's a quick untested thought (edit: this wouldn't work in the thread first expression of course)

Yes, you should probably not use flatten: https://stuartsierra.com/2019/09/25/sequences-in-flatland

that map apply vector solution is beautiful