> People spend time on this because Haskell syntax is deeply unpleasant to a lot of people, including myself.
I can understand that the syntax may be unpleasant, but I don't think having to memorise even more precedence rules makes a language more pleasant.
When I read and write Haskell, my default "mode" is to see whitespace as function application, i.e. if I see "A B" then I assume "A" is being applied to "B". Hacks like "A $ B" interfere with this, since I have to mentally back-track and re-parse them as "$ (A) (B)".
> I've forgotten the $ in some usage of do or a final argument lambda twice in the last week even.
This is exactly the kind of thing I was lamenting. Rather than (ab)using "$", why not do the more natural thing, which every other language does, and use parentheses for grouping?
Instead of "forgetting the $" in
atomically do
v <- readTVar tv
writeTVar tv $! v + 1
Why not use parentheses for the job they're designed for, and write:
atomically (do
v <- readTVar tv
writeTVar tv $! v + 1)
Likewise, for
withForeignPtr fptr \ptr -> c_memcpy buf ptr size
You can use parentheses and never "forget the $"
withForeignPtr fptr (\ptr -> c_memcpy buf ptr size)
Parentheses are a universally understood syntax for grouping, they're supported in editors (e.g. finding matching pairs, checking if they're balanced, etc.), they always work in the same way, have no interference with other constructs or edge-cases, etc.
Don't get me wrong, the "$" function is really useful, for example in "map ($ arg) [func1, func2, func3]", but I don't see the point of abusing it to avoid parentheses. I do sometimes use it myself, but whenever there are multiple infix functions around, I'll tend to use "redundant" parentheses for grouping.