Clojure lines increase in length as they increase in nesting, but without increasing nesting, they don't typically get particularly long[1], unless you have very long argument lists or very long names. So, the key is to reduce nesting (which helps comprehension anyway) and Clojure has plenty of tools to help with that: you can use ->, ->>, as->, some->, or you can bind sub-expressions to names using let/when-let/etc. There's no need to split code into smaller functions unless it makes sense to do so (eg for code reuse or semantically).
[1] 2-space indents help keep indents from being crazy wide without crazy nesting. The only place where I often find lines getting too long is let-blocks with aligned expressions and long variable names:
(let [this-name-is-too-long (some-code-here
(uh-oh this is getting long)
... ]
))
Had to close those parens to stop the mental itch!> You have little recourse but to break it up into smaller functions (perhaps some of them nested in the parent).
Generally this type of factoring is a good thing for the codebase, and a very natural part of the development process in Clojure.
Not really; prose doesn't indent with increasing nesting, so line length in prose actually means that many non-whitespace characters to scan.
> Now compare this to a newlined block of code, which resembles a richer data structure that spatially colocates relevant elements.
Nobody writes huge lines in Lisps; but the indentation can get out of hand in large functions. So you have this neat block that spatially colocates relevant elements, but has 150 columns of whitespace on the left, which creates a navigation challenge that is different from the problem of scanning a long line.
If you combat this by simpy constraining the column length, then what happens is this problem
You have little recourse but to break it up into smaller functions (perhaps some of them nested in the parent).