Function application: Why is $ used here?

Question

A while ago, I asked a question about $, and got useful answers -- in fact, I thought I understood how to use it.

It seems I was wrong :(

This example shows up in a tutorial:

instance Monad [] where
   xs >>= f = concat . map f $ xs

I can't for the life of me see why $ was used there; ghci isn't helping me either, as even tests I do there seem to show equivalence with the version that would simply omit the $. Can someone clarify this for me?

Thanks!

Answer 1

The $ is used here because it has lower precedence than normal function application. Another way to write this code is like so:

instance Monad [] where
   xs >>= f = (concat . map f) xs

The idea here is to first construct a function (concat . map f) and then apply it to its argument (xs). As shown, this can also be done by simply putting parenthesis around the first part.

Note that omitting the $ in the original definition is not possible, it will result in a type error. This is because the function composition operator (the .) has a lower precedence than normal function application effectively turning the expression into:

instance Monad [] where
  xs >>= f = concat . (map f xs)

Which doesn't make sense, because the second argument to the function composition operator isn't a function at all. Although the following definition does make sense:

instance Monad [] where
  xs >>= f = concat (map f xs)

Incidentally, this is also the definition I would prefer, because it seems to me to be a lot clearer.

Answer 2

I'd like to explain why IMHO this is not the used style there:

instance Monad [] where
  xs >>= f = concat (map f xs)

concat . map f is an example of so-called pointfree-style writing; where pointfree means "without the point of application". Remember that in maths, in the expression y=f(x), we say that f is applied on the point x. In most cases, you can actually do a final step, replacing:

f x = something $ x

with

f = something

like f = concat . map f, and this is actually pointfree style. Which is clearer is arguable, but the pointfree style gives a different point of view which is also useful, so sometimes is used even when not exactly needed.

EDIT: I have replaced pointless with pointfree and fixed some examples, after the comment by Alasdair, whom I should thank.

Answer 3

The reason $ is used here is doe to the type signature of (.):

(.) :: (b -> c) -> (a -> c) -> a -> c

Here we have

map f :: [a] -> [[b]]

and

concat :: [[b]] -> [b]

So we end up with

concat . map f :: [a] -> [b]

and the type of (.) could be written as

(.) :: ([[b]] -> [b]) -> ([a] -> [[b]]) -> [a] -> [b]

If we were to use concat . map f xs, we'd see that

map f xs :: [[b]]

And so cannot be used with (.). (the type would have to be (.) :: (a -> b) -> a -> b