Nesting vs Threading vs let - clojure

Question

Clojure newcomer here, which of the following forms do you consider most "clojuresque":
Heavily nested
(my-fn3 (my-fn2 (my-fn1 foo bar) baz) qux)
Using let
(let [result foo
result (my-fn1 result bar)
result (my-fn2 result baz)
result (my-fn3 result qux)])
Using thread-first
(-> foo
(my-fn1 bar)
(my-fn2 baz)
(my-fn3 qux))

Answer 1

I use all 3 techniques, depending on the situation. The goal is to pick the technique that makes the code the most clear (not the fewest characters!).
Technique #2 is especially handy when debugging, as you can easily print out intermediate values. However, I normally give each stage a distinct name to clarify the situation:
(let [x-1 foo
x-2 (my-fn1 x-1 bar)
x-3 (my-fn2 x-2 baz)
x-4 (my-fn3 x-3 qux)]
(println :x-1 x-1)
(println :x-2 x-2)
(println :x-3 x-3)
(println :x-4 x-4)
x-4) ; don't forget to return the final result!
Update
On the subject of debugging, this is how I would do it. First, the 3 versions raw:
(ns tst.demo.core
(:use demo.core tupelo.core tupelo.test))
(defn fa [x y] (+ x y))
(defn fb [x y] (* x y))
(defn fc [x y] {:x x :y y})
(def tgt 2)
(defn stack-nest
[foo]
(fc
(fb
(fa foo 3)
3)
99))
(defn stack-thread
[foo]
(-> foo
(fa 3)
(fb 3)
(fc 99)))
(defn stack-let
[foo]
(let [a foo
b (fa a 3)
c (fb b 3)
d (fc c 99)]
d)) ; don't forget to return the final result!
You don't need to invent your own dbg function, as there are already some good options in the Tupelo library. Here, we print the results using the spyx (spy explicit) macro:
(dotest
(spyx (stack-nest tgt))
(spyx (stack-thread tgt))
(spyx (stack-let tgt)))
(stack-nest tgt) => {:x 15, :y 99}
(stack-thread tgt) => {:x 15, :y 99}
(stack-let tgt) => {:x 15, :y 99}
We then add debugging info using spy and a label:
(defn stack-nest
[foo]
(spy :fc (fc
(spy :fb (fb
(spy :fa (fa foo 3))
3))
99)))
:fa => 5
:fb => 15
:fc => {:x 15, :y 99}
(stack-nest tgt) => {:x 15, :y 99}
It works, but it's pretty ugly. How about the threading form? Here we can insert spy and it's a bit better:
(defn stack-thread
[foo]
(-> foo
(spy :foo)
(fa 3)
(spy :fa)
(fb 3)
(spy :fb)
(fc 99)
(spy :fc)
))
:foo => 2
:fa => 5
:fb => 15
:fc => {:x 15, :y 99}
(stack-thread tgt) => {:x 15, :y 99}
We get what we want, but it's got some duplication. Also, we need to put each (spy ...) expression on a separate line so the threading macro -> sends the value to both the computation like (fa 3) and the printing step like (spy :fa).
We can simplify it a bit with the it-> macro like so:
(defn stack-thread-it
[foo]
(it-> foo
(fa it 3)
(fb it 3)
(fc 99 it)))
We use the symbol it as a placeholder. Note that we can place the threaded value in any argument position, as shown by the reversed args to fc. For our debugging, use spyx so the expressions are self-labeled, and we get:
(defn stack-thread-it
[foo]
(it-> (spyx foo)
(spyx (fa it 3))
(spyx (fb it 3))
(spyx (fc 99 it))))
foo => 2
(fa it 3) => 5
(fb it 3) => 15
(fc 99 it) => {:x 99, :y 15}
(stack-thread-it tgt) => {:x 99, :y 15}
When intermediate variables are in a let expression, I debug like so:
(defn stack-let
[foo]
(let [a foo
>> (spyx a)
b (fa a 3)
>> (spyx b)
c (fb b 3)
>> (spyx c) ]
(spyx (fc c 99))))
a => 2
b => 5
c => 15
(fc c 99) => {:x 15, :y 99}
(stack-let tgt) => {:x 15, :y 99}
Note that the last function fc is invoked directly as the return value (outside of the let), but we can still print its value using spyx.
Note that I like to use the symbol >> (unused anywhere in Clojure) instead of the underscore _ as the dummy recipient of the expression value, as the underscore is sometimes difficult to see. The >> symbol not only stands out in the code, but also looks a bit like a command-line prompt, reminding one of the imperative, side-effecting nature of the print action.

Answer 2

I would say that often a combination of approach 2 and 3 is what most people strive towards when writing Clojure, simply because it provides the most readability.
Typically you'll want to use lets where the values you're binding will be used in multiple places, e.g. you'll need a particular value that will be used to create another binding and that value will also be used inside the body of the let.
Now, approach 3 isn't always achievable, in some cases you'll run into a situation where two function calls don't share the same ordinal position for the value you're threading, which will either require a re-think/structuring the code slightly differently, or you can reach for the as-> operator, which I personally find rather hideous.
I often find with Clojure that the readability of the code reflects its idiomaticy, if something does look right, there's almost always a better way to write it.