Add solutions for chapter 5.

@fabioyamate, @laurocaetano I'm so sleepy that I don't remember where I had to change on the last exercise, haha.
Yes, but `$` does not favor pointfree notation because of its precedence.

It's `infixr 0` so it will bind the least tightly possible and you will
eventually hit a type error because what's on the left of `$` will bind
strongly.

For example:

```haskell
Prelude> let f x = [x]
Prelude> 1 : f x
[1, 2]
Prelude> 1 : f $ x

<interactive>:10:5:
    Couldn't match expected type `[a0]' with actual type `t1 -> [t1]'
    In the second argument of `(:)', namely `f'
    In the expression: 1 : f
    In the expression: 1 : f $ 2
```

So, what happened?

`1 : f x` can be seen as `1 : (f x)`. Actually is seen as `1 : f x`. Normal
function application, `f x` is assumed to have a precedence of level 10. The
`(:)` has `infixr 5` which explains why `f x` is bound first and that's why it
works.

In the second case, `1 : f $ x` is seen as `((1 : f) x)` because `(:)` binds
tightly than `$`.

So, if you try to define a function with pointfree notation using `$` you will
probably hit type errors because the functions will bind differently of what
you would expect.

To illustrate this consider the following function: `let g = 1 : f $`

This function will be translated to `(\a -> (1 : f) a)` which is wrong and has a
type error.