= Proposal: make the $ operator left-associative =
== Arguments in favour ==
0) $ was introduced as a combinator for function application.
Therefore we might expect that whenever we have a function application
we can stick a $ in there. But this is not the case. Consider the
following expression:
{{{
f x y
}}}
There are two applications here and if $ behaved like function
application we would be able to write:
{{{
f $ x $ y
}}}
But as it is now this expression means something completely different.
(these following points taken from [http://www.haskell.org/pipermail/haskell-prime/2008-April/002459.html Dan Doel's post on the haskell-prime mailing list])
1) Anything of the form:
{{{
f $ g $ h $ x
}}}
with right associative ($) can instead be written:
{{{
f . g . h $ x
}}}
where the associativity of ($) doesn't matter. It's not uncommon to want to
peel off the end of such a pipeline to eliminate a point. For the second
form, such a translation is:
{{{
\x -> f . g . h $ x ==> f . g . h
}}}
However:
{{{
\x -> f $ g $ h $ x ==> f $ g $ h
}}}
Is invalid, so one might argue that writing such pipelines with composition is
a better habit to get into, as it allows easier cleanup of code in this way
(if you like somewhat point-free code, that is).
2) Left associative ($) allows you to eliminate more parentheses. Per #1, any
parentheses eliminated by right associative ($) can be eliminated by (.) and
a single ($). However, left associative ($) allows, for instance:
{{{
f (g x) (h y) ==> f $ g x $ h y
}}}
3) Left associative ($) is consistent with left associative ($!). The right
associative version of the latter is inconvenient, because it only allows
things to be (easily) strictly applied to the last argument of a function.
Needing to strictly apply to other arguments gives rise to things like:
{{{
(f $! x) y z
((f $! x) $! y) $! z
}}}
Left associative, these are:
{{{
f $! x $ y $ z
f $! x $! y $! z
}}}
There may be more arguments, but those are the ones I've heard that I can
think of at the moment. #3 strikes me as the most likely to bite people (the
other two are more stylistic issues), but I suppose I don't know the relative
frequency of strict pipelines (f $! g $! x) versus strict applications at
non-final arguments.
== Arguments against ==
* This would break a ''lot'' of code.