`map`

and `fmap`

in Haskell
Haskell’s standard module ships with two functions, called `map`

and
`fmap`

. The first one, `map`

, is the typical function we are all used to in
functional programming. Looking at its definition, reveals that it’s recursive
implementation is exactly what one would expect:

```
map :: (a -> b) -> [a] -> [b]
map _ [] = []
map f (x:xs) = f x : map f xs
```

Based on `foldr`

, we can write an identical function with an even shorter
defintion:

```
map' :: (a -> b) -> [a] -> [b]
map' f = foldr ( (:) . f ) []
```

It’s important to avoid tail recursion, because that would make lazy
evaluation impossible, which is a prerequisite for dealing with infinite
lists. That’s why `foldl`

is a bad idea, even though it would be faster
(assuming the compiler performs tail call optimization).

In addition to `map`

, there’s the `Functor`

class, whose instances are required
to implement `fmap`

:

```
class Functor (f :: * -> *) where
fmap :: (a -> b) -> f a -> f b
```

As it turns out, `[]`

is an instance of `Functor`

:

```
instance Functor [] where
fmap = map
```

So, at least for lists, there’s no difference between the two. However, there
are many more `Functor`

instances. For example, let’s examine the instance for
`Maybe`

:

```
instance Functor Maybe where
fmap _ Nothing = Nothing
fmap f (Just a) = Just (f a)
```

If the value we are mapping over is `Nothing`

, it returns `Nothing`

. Otherwise,
it’s applying the given function `f`

to the value from the `Just`

and returns
another `Just`

with `f`

’s return value.

Personally, this reminds me of ActiveSupport’s `Object#try`

method. The
`Functor`

instance for `Maybe`

is encapsulating exactly the same pattern, but in
a more abstract way. That’s because the implementation can be completely
different for other types.

The bottom line is that `fmap`

is a generalized version of `map`

. You can `fmap`

whatever you want, as long as there’s a `Functor`

instance for its type. This
is extremely powerful, because it allows us to push complexity from the caller
to the callee.

From now on, I’m going to use `fmap`

exclusively in my own code: Code that’s
using more generalized functions is easier to reuse and change later on.