Exercises for the second chapter.

These are the exercises for the second chapter :smiley: 

Even this chapter being small, we could see some build in functions that Haskell provides to apply on lists. I spent a considerable time on the last two exercises, but then I started using [Hoogle] [1] which helped a lot :fireworks:.

@fabioyamate could you take a look?

  [1]: http://www.haskell.org/hoogle/
interesting, yeah ruby uses the `**` as power  operator.

I know that in maths the common symbol is the `^`. However, in most languages it used for AND bitwise operation.

for exemplo: `x^2 + 2x + 1`

So Haskell provides both operators, but what is the difference? Lets check the types :smile:

```haskell
Prelude> :t (**)
(**) :: Floating a => a -> a -> a
Prelude> :t (^)
(^) :: (Integral b, Num a) => a -> b -> a
```

So, it means that the `(**)` is applicable to Float, which means: `2.0 ** 0.5` (equal to square root of 2), `2 ** 3`.

The second one, we can only apply operations like: `2 ^ 2`, `2 ^ 0.5` will raise an error.

Checking docs about it I got the http://www.haskell.org/haskellwiki/Power_function

There a third operator: `(^^)`, lets check the type again:

```haskell
Prelude> :t (^^)
(^^) :: (Fractional a, Integral b) => a -> b -> a
```

This means that `(1 / 3) ^^ 2` are valid.

I think that each one address some precision elements in number, still have to read the Haskell Wiki.