In JVM Clojure, if provided, it’s used in the generated class name, so it is helpful to disambiguate between anonymous functions when reading stacktraces:

dev> (fn [])
#function[dev/eval325607/fn--325608]
dev> (fn my-cool-fn [])
#function[dev/eval325611/my-cool-fn--325612]

Thanks! Wish it was on the Clojure functions page.

Also provides for self-reference without recur if your recursion is already stack-safe.

(let [foo (fn bar [x]
            (if (> x 1) x (bar (inc x))))]
  (foo 0))
; => 2

that's rarely a good usage - here you could safely recur instead. and let-fn is sufficient for mutually recursive local functions. really the primary reason to name your fn is to share intent and to aid debuggability

Yes. The example is terrible use case, which is definitely not stack safe. It was just a quick & dirty demonstration of the capacity to call the name recursively. I have pretty mixed feelings about let-fn. In addition to it's lack of symmetry with the syntax of let, it can get verbose quickly if you also want non-function let bindings. If I don't specifically need mutual recursion, I am personally inclined to avoid it.

regarding the docs themselves, as you mentioned the optional name is not covered in the "learn Clojure" page (which I assume is because it's not typicaly heavily used to get started), but it is covered in the reference: <https://clojure.org/reference/special_forms#fn>

I actually think it's kind of accidental that it does work, which may be why it was not part of the original docs