## Hidden structure

The unexpected similarities between mapping over a list and function composition

Trying to understand functors, I came accross the initially strange fact that functions are functors. Which means, roughly speaking, you can "map", another function over it. So given a function

```
g :: r -> a
```

and another function

```
f :: a -> b
```

you can "map" the second function over the first to get another function, which is defined as the composition of the two.

```
fmap f g :: r -> b
fmap f g = f . g
```

Similarly, and more familiarly, you can take a list

```
xs :: [a]
```

and a function

```
f :: a -> b
```

and map the function over the list to get another list.

```
fmap f xs :: [b]
fmap f xs = [f x | x <- xs]
```

(I suspect this isn't how `fmap`

is defined on a list in the real source, but I find list comprehensions quite easy to understand.)

The suprising thing is that you can express two seemingly very different activities, mapping a function over a list, and composing a function with another function, in Haskell using the same function: `fmap`

. Here "the same" is defined as having the same type signature.

```
fmap :: Functor f => (a -> b) -> f a -> f b
```

Although yes, the implementation of `fmap`

for functions and lists are indeed different.