(def x #(assoc % :version 3))

(->> {} x) works too without the parens.

The doc of ->> says ”

Inserts x as the
last item in the first form, making a list of it if it is not a
list already.

so shall it be with #(assoc )

The reason is that #(assoc % :x 3) is read as a function, not a list

It is equivalent to writing (fn [m] (assoc x :x m))

And you can see how threading to that won't work

> The reason is that `#(assoc % :x 3)` is read as a function, not a list I see. It is read as a list. so the value inserted is INSIDE the function list form.

But when you have the extra parentheses around, you get a list with a function in the first position, and argument last.

(macroexpand '(->> {} #(assoc % :x 2)))
=> (fn* [p1__18483#] (assoc p1__18483# :x 2) {})

just as an add-on, in this situation, the thread-first macro might be clearer/preferred:

(macroexpand '(-> {} (assoc :x 3)))
=> (assoc {} :x 3)

Unless you have a pipeline of just sequence functions (map, filter, etc), it is pretty much always better to start off with -> since you can use all the other arrow functions inside -> (including ->> and as->).

> since you can use all the other arrow functions inside `->` (including `->>` and `as->`). Can you be more specific?

(-> x
  (->> (map inc))
  (as-> y (if (seq y) y 0)))

Ah good point, let's assume ordered collections are used as values in the map. I guess what I'm concerned about is either these collections are sorted differently, or the entires in the map are in different “order”

it should stand out as kind of tautological but order is important for ordered collections

On the other hand, a sorted collections can compare equal to its equivalent unsorted type

Sure. I was more curious how the memoize fns behaved with these kind of things - ill try some examples tomorrow. Thanks!

I think ultimately that will depend on what cache you're using and how it does the lookup

@U0HJAJ64E The argument list is used as a key into the hash map of cached argument lists to get the computed value. So the equality behavior is identical to Clojure's built-in hash map key lookup/insertion (and therefore key collision/comparison machinery).

Depending on how deep down the rabbit hole you want to go: https://clojure.org/guides/equality

Many thanks @U04V70XH6