Haskell function composition (.) and function application ($) idioms: correct use

Question

I have been reading Real World Haskell, and I am nearing the end, but a matter of style has been niggling at me to do with the (.) and ($) operators.

When you write a function that is a composition of other functions you write it like:

f = g . h

But when you apply something to the end of those functions I write it like this:

k = a $ b $ c $ value

But the book would write it like this:

k = a . b . c $ value

Now, to me they look functionally equivalent, they do the exact same thing in my eyes. However, the more I look, the more I see people writing their functions in the manner that the book does: compose with (.) first and then only at the end use ($) to append a value to evaluate the lot (nobody does it with many dollar compositions).

Is there a reason for using the books way that is much better than using all ($) symbols? Or is there some best practice here that I am not getting? Or is it superfluous and I shouldn't be worrying about it at all?

Serranid

Note that the second example can be done as k = a $ b $ c value – Flattery

Yes it can, as Zifre mentioned below, but I decided to leave it there as it does not harm anything and makes his (and now your) comments make sense. Thankyou though. +1 :) – Serranid

Another common approach is a . b $ c value, which I don't like quite as much as the third example but saves a few characters. – Mangle

Regarding performance: #47133054 – Bindman

Answer 1

I guess I can answer this from authority.

Is there a reason for using the books way that is much better than using all ($) symbols?

There's no special reason. Bryan and I both prefer to reduce line noise. . is quieter than $. As a result, the book uses the f . g . h $ x syntax.

Lightner

Well, I cannot hope for a better answer than this one; from one of the authors himself. :) And that makes sense, it does look much quieter on the page as I read. Marking this as the answer because It directly answers the question. Thankyou for the response; and, infact, the book. – Serranid

Not to disagree with the author, but I think there is another more prominent reason in the mental model of creating something rather than using it. Haskell users tend to want to think of f.g.h as a new clever creation rather f(g(h())). Now they're calling a new, albeit anonymous, function which they created rather than just chaining a big dictionary of prefabbed function calls like a PHP user. – Hutto

That's an interesting statement: 'reduce line noise' and 'quieter than'. I never thought about programming languages in this terminology, but it makes perfect sense. – Atypical

Answer 2

They are indeed equivalent: Keep in mind that the $ operator does, essentially, nothing. f $ x evaluates to f x. The purpose of $ is its fixity behavior: right-associative and minimal precedence. Removing $ and using parentheses for grouping instead of infix precedence, the code snippets look like this:

k = a (b (c (value)))

and

k = (a . b . c) value

The reason for preferring the . version over the $ version is the same reason for preferring both over the very parenthesized version above: aesthetic appeal.

Although, some might wonder if using infix operators instead of parentheses is based on some subconscious urge to avoid any possible resemblance to Lisp (just kidding... I think?).

Vaporing

Answer 3

I'd add that in f . g $ x, f . g is a meaningful syntactic unit.

Meanwhile, in f $ g $ x, f $ g is not a meaningful unit. A chain of $ is arguably more imperative -- first get the result of g of x, then do f to it, then do foo to it, then etc.

Meanwhile a chain of . is arguably more declarative, and in some sense closer to a dataflow centric view -- compose a series of functions, and ultimately apply them to something.

Untruth

I'm learning Haskell (haven't coded anything meaningful) but I like to think of $ as a sort of "pipe" operator. Its a lot like the terminal | pipe (except the data flows right-to-left), but like terminal processes each unit is explicitly independent. – Chemosynthesis

The $ operator seems to behave similarly to the <| operator in F#. I believe both are defined the same, in fact - in F#, (<|) a b = a b and in Haskell, a $ b = a b, which are essentially equivalent. – Rector

@Quackmatic Fairly certain it's (<|) b a = a b in F#, since it's used like [1; 2; 3; 4; 5] <| List.map ((+) 1), if memory serves. – Indefinable

@BalinKingOfMoria The <| operator passes the value to the function, rather than passing the function to the value - your code example would work with the |> operator, instead. – Rector

@Quackmatic Oh. Wasn't aware there were multiple versions (I haven't used F# very much). – Indefinable

Excellent distinction, you expressed what I had as a gut feeling. – Sidsida

Answer 4

For me, I think the answer is (a) the neatness, as Don said; and (b) I find that when I'm editing code, my function may end up in point-free style, and then all I have to do is delete the last $ instead of going back and changing everything. A minor point, certainly, but a nicety.

Partee

Yeah that is a good reason to write it like that, if you want to end in a function composition then it is faster. :) Yay for saving keystrokes, but more importantly time. +1 – Serranid

Answer 5

There's an interesting discussion of this question on this haskell-cafe thread. Apparently there's a minority viewpoint that holds that the right associativity of $ is "just plain wrong", and choosing f . g . h $ x over f $ g $ h $ x is one way of side-stepping the issue.

Chor

Hey, you found a whole discussion on the matter. That is awesome, I'm having a read now. +1 – Serranid

Similar arguments here: ghc.haskell.org/trac/haskell-prime/wiki/… – Decapitate

Note that $! has also the "plain wrong" right associativity -- Why is the $! operator right-associative?. – Improvisatory

Answer 6

It's just a matter of style. However, the way the book does it makes more sense to me. It composes all the functions, and then applies it to the value.

Your method just looks strange, and the last $ is unnecessary.

However, it really doesn't matter. In Haskell, there are usually many, many, correct ways to do the same thing.

Tonsillectomy

I didn't notice that the last $ was unnecessary but I should have. Thanks and I'll leave it there so that people know what this comment means. – Serranid

Answer 7

I realize this is a very old question, but I think there is another reason for this that hasn't been mentioned.

If you are declaring a new point-free function f . g . h, the value you pass in will be automatically be applied. However, if you write f $ g $ h, it will not work.

I think the reason the author prefers the composition method is because it leads to a good practice of building up functions.

Lottielotto