# Solved: functor

In the world of functional programming, concepts evolve differently. Among them, few may seem as abstract and difficult to grasp as the one we are going to demystify today – Functor. But once you comprehend its power and flexibility, functors can drastically simplify your solutions to complex programming challenges.

## Understanding Functors in Haskell

A functor, in Haskell, is a type that implements the Functor typeclass. It is essentially something that can be mapped over. Functor embodies two primary elements, ‘fmap’ function and some laws that ensure consistent behavior.

‘fmap’ is used to apply a function to the value inside a structure without changing the structure itself. This means, functors encapsulate the context enacting operations while leaving the context unaffected. It allows us to focus on problem-solving without getting entangled in handling the context.

```instance Functor Maybe where
fmap func (Just x) = Just (func x)
fmap func Nothing = Nothing
```

## The Functor Laws

For a type to qualify as a functor, it must satisfy two laws known as Functor Laws. These laws safeguard the integrity of the structure we are working on.

Law 1: Mapping the identity function over a functor should return the original functor – fmap id == id

```fmap id (Just 3)  -- Returns: Just 3
fmap id Nothing  -- Returns: Nothing
```

Law 2: Composing two functions and then mapping the resulting function over a functor should be the same as first mapping one function and then mapping another – fmap (f . g) == fmap f . fmap g

```fmap (abs . negate) (Just 5)  -- Returns: Just 5
(fmap abs . fmap negate) (Just 5)  -- Returns: Just 5
```

## Applying Functors to Solve Problems

Now, let’s illustrate how Functors can efficiently solve problems. For example, say we have a list of potential results as a list of Maybe values. If we want to increase each by one, normally, we have to write a lot of boilerplate code. Enter Functors.

‘fmap’ can easily iterate over the list, bypassing Nothing values and applying the operation only to Just values. All while retaining the original structure.

```let maybes = [Just 1, Nothing, Just 3]
fmap (+1) <\$> maybes  -- Returns: [Just 2, Nothing, Just 4]
```

Thus, functors offer a streamlined, intelligent way to manage computations within a context. They form an integral part of Haskell’s ability to handle complex tasks with simple, elegant code.

Related posts: