Let’s see how IO is an instance of Functor. When we fmap a function over an I/O action, we want to get back an I/O action that does the same thing but has our function applied over its result value. Here’s the code:

instance Functor IO where
  fmap f action = do
    result <- action
    return (f result)

Check out this piece of code

main = do line <- getLine
          let line' = reverse line
          putStrLn $ "You said " ++ line' ++ " backwards!"
          putStrLn $ "Yes, you said " ++ line' ++ " backwards!"

We can rewrite it use fmap.

main = do line <- fmap reverse getLine
          putStrLn $ "You said " ++ line ++ " backwards!"
          putStrLn $ "Yes, you said " ++ line ++ " backwards!"

getLine is an I/O action that has a type of IO String, and mapping reverse over it gives us an I/O action that will go out into the real world and get a line and then apply reverse to its result.

We can also fmap multi functions to I/O action.

import Data.Char

main = do line <- fmap (reverse . map toUpper) getLine
          putStrLn $ "You said " ++ line ++ " backwards!"

Another instance of Functor that we’ve been dealing with all along is (->) r. If you understand the that r -> a can be write as (->) r a, you may understand what is (->) r.

How are functions functors? Let’s take a look at the implementation, which lies in Control.Monad.Instances.

instance Functor ((->) r) where
    fmap f g = (\x -> f (g x))

First, let’s think about fmap’s type:

fmap :: (a -> b) -> f a -> f b

Next, let’s mentally replace each f, which is the role that our functor instance plays, with (->) r.

fmap :: (a -> b) -> ((->) r a) -> ((->) r b)

Then, we change prefix to infix.

fmap :: (a -> b) -> (r -> a) -> (r -> b)

We see that it takes a function from a to b and a function from r to a and returns a function from r to b. Does this remind you of anything? Yes, function composition!

Here’s another way to write this instance.

instance Functor ((->) r) where
    fmap = (.)

This makes it clear that using fmap over functions is just function composition. Let's see several examples.

ghci>(*3) . (+100) $ 2
306
ghci>(*3) `fmap` (+100) $ 2
306
ghci>fmap (*3) (+100) 2
306

Note that you should import Control.Monad.Instances first.

Using fmap (*3) on (+100) will create another function that acts like (+100), but before producing a result, (*3) will be applied to that result.Think about the similarity between this process with functors on IO action.

The first functor law states that if we map the id function over a functor value, the functor value that we get back should be the same as the original functor value.

ghci>id (Just 4)
Just 4
ghci>fmap id (Just 4)
Just 4

The second law says that composing two functions and then mapping the resulting function over a functor should be the same as first mapping one function over the functor and then mapping the other one.

fmap (f . g) = fmap f . fmap g

Let’s take a look at a pathological example of a type constructor being an instance of the Functor type class but not really being a functor, because it doesn’t satisfy the laws.

data CMaybe a = CNothing | CJust Int a deriving (Show)

Let’s play with our new type

ghci>CNothing 
CNothing
ghci>CJust 1 "hiahia"
CJust 1 "hiahia"

Let’s make this an instance of Functor so that each time we use fmap, the func- tion is applied to the second field, whereas the first field is increased by 1

data CMaybe a = CNothing | CJust Int a deriving (Show)
instance Functor CMaybe where
  fmap f CNothing = CNothing
  fmap f (CJust counter x) = CJust (counter+1) (f x)

ghci>fmap (++"hahia") (CJust 0 "ho")
CJust 1 "hohahia"
ghci>fmap (++"xxx") $ fmap (++"hahia") (CJust 0 "ho")
CJust 2 "hohahiaxxx"

Does this obey the functor laws?We can find a counterexample easily.

ghci>id (CJust 0 "hia")
CJust 0 "hia"
ghci>fmap id (CJust 0 "hia")
CJust 1 "hia"

Since CMaybe fails at being a functor even though it pretends to be one, using it as a functor might lead to some faulty code.

The next time you make a type an instance of Functor, take a minute to make sure that it obeys the functor laws.

It doesn’t provide a default implementation for either of them, so we need to define them both if we want something to be an applicative functor. The class is defined like so

class (Functor f) => Applicative f where
  pure :: a -> f a
  (<*>) :: f (a -> b) -> f a -> f b

Let’s take a look at the Applicative instance implementation for Maybe.

instance Applicative Maybe where
    pure = Just
    Nothing <*> _ = Nothing
    (Just f) <*> something = fmap f something

Now let’s give some examples:

ghci>Just (3+) <*> Just 4
Just 7
ghci>pure (3+) <*> Just 4
Just 7

You see how doing pure (+3) and Just (+3) is the same in this case.

With the Applicative type class, we can chain the use of the <*> function, thus enabling us to seamlessly operate on several applicative values instead of just one.

ghci>pure (+) <*> Just 3 <*> Just 5
Just 8
ghci>pure (+) <*> Just 3 <*> Nothing
Nothing
ghci>pure (+) <*> Nothing <*> Just 5
Nothing

Instead of writing pure f <*> x <*> y <*> …, we can write fmap f x <*> y <*> …. This is why Control.Applicative exports a function called <$>, which is just fmap as an infix operator. Here’s how it’s defined:

(<$>) :: (Functor f) => (a -> b) -> f a -> f b
f <$> x = fmap f x

By using <$>, the applicative style really shines, because now if we want to apply a function f between three applicative values, we can write f <$> x <*> y <*> z. If the parameters were normal values rather than ap- plicative functors, we would write f x y z.

ghci>(++) <$> Just "sdf" <*> Just "ewrq"
Just "sdfewrq"

Lists (actually the list type constructor, []) are applicative functors.

instance Applicative [] where
  pure x = [x]
  fs <*> xs = [f x | f <- fs, x<-xs]

Let's look at some example to see what's the meaning of the definition above.

ghci>pure "Hia" :: [String]
["Hia"]
ghci>pure "Hia" :: Maybe String
Just "Hia"

ghci>[(*0),(+1),(^2)] <*> [1,2,3]
[0,0,0,2,3,4,1,4,9]

In the following example, we apply two function between two lists:

ghci>[(*),(+)] <*> [1,2] <*> [3,4]
[3,4,6,8,4,5,5,6]

Using the applicative style with lists is fun!

ghci>(++) <$> ["a","b","c"] <*> ["?","!","~"]
["a?","a!","a~","b?","b!","b~","c?","c!","c~"]

Another instance of Applicative that we’ve already encountered is IO.

instance Applicative IO where
  pure = return
  a <*> b = do
    f <- a
    x <- b
    return (f x)

Consider this:

myAction :: IO String
myAction = do
  a <- getLine
  b <- getLine
  return $ a ++ b

Another way of writing this is to use the applicative style.

myAction :: IO String
myAction = (++) <$> getLine <*> getLine

Another instance of Applicative is (->) r, or functions.

instance Applicative ((->) r) where
  pure x = (\_ -> x)
  f <*> g = (\x -> f x ( g x))

Example:

ghci>(pure 3) "sdf"
3
ghci>(+) <$> (+3) <*> (*100) $ 4
407
ghci>(*) <$> (+3) <*> (*100) $ 4
2800

When we do (+) <$> (+3) <*> (*100), we’re making a function that will use + on the results of (3) and (*100) and return that. With () <$> (+3) <*> (*100) $ 5, (+3) and (*100) are first applied to 5, resulting in 8 and 500. Then + is called with 8 and 500, resulting in 508. The following example is similar.

ghci>(\x y z -> [x,y,z]) <$> (+3) <*> (*4) <*> (^2) $ 5
[8,20,25]

An instance of Applicative that we haven’t encountered yet is ZipList, and it lives in Control.Applicative.

instance Applicative ZipList where
  pure x = ZipList (repeat x)
  ZipList fs <*> ZipList xs = ZipList (zipWith (\f x -> f x) fs xs)

Like normal functors, applicative functors come with a few laws.