There is probably a pending thread. You can add (shutdown-agents) after the println.

thanks! let me try that!

If you want to force the termination of the program despite pending threads you can use (System/exit 0)

(shutdown-agents) worked just fine many thanks

(though I'd use the return code of ls as return code of your program in this case)

Most of the time there's no appreciable difference.

For one, a get-in into a nested map is easier to read, imo. Afaik, both are linear time O(n), but in different ways: • -> O(n) n number of forms (expansion time) • get-in Both select-keys and get-in have linear behavior in the number of selection keys. If you need to select a huge number of keys from an even larger map, you might consider the option of dissoc the unwanted keys instead of selecting the wanted ones. Ref. Clojure the Essential Reference

I see, thanks!

If some of your keys are not executable as functions (for example a string) then the get-in form will be easier to work with.

In a hot loop, and depending on what's in the vector, the get-in technique might be slower. If the vector isn't a constant literal, your program has to allocate it and populate it and garbage-collect it. And in any case, get-in has to traverse the vector and do what your threading form does. In short, get-in is a wondrous tool but if you don't need that tool's killer feature (which is the vector) then get-in is a luxury.

get-in is usually much slower, but has the benefit of being able to use a dynamic key set at runtime

The -> expansion happens once at compile time whereas get-in work happens on every execution

@U072P0JLYP2 Often you need to destruct n keys from each level, not only one and in this case can use this approach instead

(let [{:keys [payload meta] event}
      {:keys [key1 key2] payload}])

@U0P0TMEFJ I see... I wonder what would be the case for using functions map keys?

@U0HG4EHMH @U064X3EF3 So to summarize, I should use the -> most of the time except when there is a need to use get-in's superpower, I presume

> I wonder what would be the case for using functions map keys? I didn't mean using literal functions as keys. Keywords like :hello and :world are executable as functions, that's how the thread-first macro -> works. It passes the result down the chain as the first argument to each function, it's not just for accessing data from a map. So (-> simple-map :hello :world) will macro expand to (:world (:hello simple-map)), before it is complied. That's one reason it's faster. But it also means that if the keys are strings or numbers (which are not functions) then that trick won't work.

(-> {"hello" "world"} "hello")

class java.lang.String cannot be cast to class clojure.lang.IFn

Aha, got it! Thanks a million 💵