Clojurians Log v2

I go for (fn [v] {:foo v}) all the time in such cases.

Sure, I'd put that in the same boat as let and identity.

Cognitive load is different, IMO. No tricks, no extra syntax, the most direct expression one could come up with.

I personally feel like if I can get used to (seq x) meaning "not-empty", I can get used to #(-> {:foo %}), but we can disagree

Oh, I definitely agree. It's just that (seq x) is a documented idiom and the -> trick is not. :) And even the fact that it's an idiom seems to be shaky nowadays, with empty? getting special treatment.

I had to try that in a REPL to convince myself it even worked...

I expect a linter would flag it tho'?

(-> x) is basically a shorter version of identity, which makes perfect sense if you think about it

clj-kondo doesn't flag it, by default at least

I remember somewhere someone used #(do {:foo %})

to me i didn’t “get used to” seq x but i understood it. This to me is a workaround around the shorthand that makes it longer than what the shorthand replaces. So to me its more confusing and more verbose than what you can just natively do

I think we have pretty much exactly this discussion once a year or so. :)

yeah. i think you are correct.

I prefer #(hash-map :foo 1) over code golfing ways to avoid it, but cool

I have used #(-> {:foo %1}) in the REPL, but not much in application code. I like how concise it is, and it doesn't feel very "tricky" to me, but it does take a little more thinking than (fn [v] {:foo v}), which is also quite short.

using -> is weird when you could use do

if you really want to get weird with it, use max

assoc should be a contender here as well - in terms of readability / intent #(assoc {} :foo %) uses everything in idiomatic ways. also (def id identity) is straightforward

There's also a weird edge-case with map/set data literals to be aware of:

user=> (#(hash-map :foo 1, % 2) :foo)
{:foo 2}
user=> (#(-> {:foo 1, % 2}) :foo)
java.lang.IllegalArgumentException: Duplicate key: :foo [at <repl>:1:2]

oh also if we're really looking to get spicy i'd like to nominate #((completing slurp) {:foo %})

Doesn’t {:a 1} emit a constant, vs. (assoc {} :a 1) and the equivalent hash-map? Probably makes no difference in the vast majority of cases, but if you’re in a very hot loop: maybe?

I think the literals have a slight edge even when the value is dynamic IIRC.

When keys are guaranteed to be unique, literals should be the fastest. If they are unique in the data but it cannot be guaranteed at read time, both literals and constructor functions should have the same performance. assoc is the slowest, but (assoc nil k v) specifically is as fast as it gets when it comes to values that aren't known at read time. None of this means anything for tiny structures and lack of profiling - I just took a glance at the impl and the result of clj-java-decompiler.

So I made this strange https://github.com/johnmn3/perc#mapping-and-reducing thing a while back that has that as what I call "return literals," where you can do #%{:a {:b like:

(->> [{:a {:z {:x 5}}
       :b {:c {:p {:q 6}}}}
      {:a {:z {:x 7}}
        :b {:c {:p {:q 8}}}}
      {:a {:z {:x 9}}
        :b {:c {:p {:q 10}}}}]

     (mapv #%{:a {:z {:x (inc %:a:z:x)}}
              :b {:c {:p {:q (dec %:b:c:p:q)}}}})

     (reduce #%{:a {:z {:x (+ %1:a:z:x %2:a:z:x)}}
                :b {:c {:p {:q (+ %1:b:c:p:q %2:b:c:p:q)}}}}))

Oh, but what if it let you condense the map construction as well? Like:

(mapv #%{:a:z:x (inc %:a:z:x)
         :b:c:p:q (dec %:b:c:p:q)})

Also can be written as:

(mapv #%{:a:z:x %:a:z:x%inc
         :b:c:p:q %:b:c:p:q%dec})