"Parens are overloaded in traditional Lisps for both invocation and grouping."

And boy do I wish they were overloaded the same way in Clojure. I hate the fact that I have to say

     (cond
       (some-long-predicate involving multipler-parameters)
       (what-to-do has to go-on-the-next-line because-of wrapping)
       (here-is-the-next predicate)
       [(func1 arg1) ...])

It's very easy to end up in this situation (and it's not always just a sign that you need to refactor). It messes things up visually, and it also means that #_ doesn't work to comment out an entire test-and-expression (likewise #_ doesn't comment an entire binding-plus-binding-expression in a let), because it's not just one s-expression.

I don't really understand the rationale, tbh (in fact I don't even know what it's supposed to be to try to understand it); somewhere I saw the observation that there's no need for you as a macro writer to make the client of the macro use parens for grouping when you can just call (partition 2 ...) on the arguments, which is true enough (at least, as long as the unpaired args in a larger group (e.g. binding vector) or are the tail of the arguments to the macro, captured as a rest param), but ... I kind of doubt that CL and Scheme went with the form of let, cond, etc. that they did out of convenience for implementation of the relevant macros. And even if that were the original motivation, those forms have other benefits.