Functor on the [Typeclassopedia](https://wiki.haskell.org/Typeclassopedia#Functor).
</span>
The `Functor` is the most fundamental typeclass in the standard libraries. Intuitively, a `Functor` can be viewed as a sort of "container," coupled with an ability to apply a function to every element in the container. One example is a list: this is a container of elements, and we can uniformly apply a function to every element using `map`.
## Definition
```haskell
classFunctorfwhere
fmap::(a->b)->fa->fb
-- Replace all locations in the input with
-- the same value. This may be
-- overridden with a more efficient version.
(<$)::a->fb->fa
(<$)=fmap.const
```
Having a single `fmap` method means that we don't have to implement and remember several `map` methods for different data structures e.g. `map` over lists, `treeMap`, `maybeMap`.
This also enables us to write code that works with any `Functor`, simply by invoking `fmap` polymorphically. This enables a powerful sort of code reuse.
## Intuition
There are two main intuitions for `Functor`.
1) A `Functor` is a container, or more precisely, a _computational context_ we can map over. Data structures are the most natural example of this.
2) Since `fmap` is curried, we can write the type signature as `fmap :: (a -> b) -> (f a -> f b)`. It transforms a "normal" function `g :: a -> b` into one that operates over containers `fmap g :: f a -> f b`. This transformation is called a _lift_.
## The `[]` instance
Recalling the familiar pattern of mapping over a list, we can implement an instance of `Functor` as follows.
```haskell
instanceFunctor[]where
fmap::(a->b)->[a]->[b]
fmapg(x:xs)=gx:fmapgxs
-- Alternatively, fmap = map works here.
```
As we'd expect, `fmap` works like `map`:
```
ghci> fmap (\x -> x + 2) [1..10]
[3,4,5,6,7,8,9,10,11,12]
ghci> fmap (*2) [1..10]
[2,4,6,8,10,12,14,16,18,20]
```
## The `Maybe` instance
Similarly, `Maybe` is an instance of functor:
```haskell
instanceFunctorMaybewhere
fmap::(a->b)->Maybea->Maybeb
fmap_Nothing=Nothing
fmapg(Justa)=Just(ga)
```
## The `Tree` instance
Suppose we have a `Tree` data structure defined recursively as follows: