Running :i Functor in ghci yields the following:

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

It also lists available instances of the Functor type class:

instance Functor (Either a) -- Defined in ‘Data.Either’
instance Functor [] -- Defined in ‘GHC.Base’
instance Functor Maybe -- Defined in ‘GHC.Base’
instance Functor IO -- Defined in ‘GHC.Base’
instance Functor ((->) r) -- Defined in ‘GHC.Base’
instance Functor ((,) a) -- Defined in ‘GHC.Base’

Concrete type signatures

To understand similarities and differences between various instances of the Functor type class we will take a look at the type signatures of the fmap and <$ functions for List, Maybe and Either types:

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

-- List
fmap :: (a -> b) -> [a] -> [b]

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

-- Either
fmap :: (b -> c) -> Either a b -> Either a c

-- Generic
(<$) :: a -> f b -> f a

-- List
(<$) :: c -> [a] -> [c]

-- Maybe
(<$) :: c -> Maybe a -> Maybe c

-- Either
(<$) :: c -> Either a b -> Either a c

Using fmap with different types

In order to use fmap we need to define a function we want to work with. After it is defined we will apply the function to some instances of the Functor type class:

addOne :: Num a => a -> a
addOne a = a + 1

-- List
fmap addOne [ ]       == [ ]
fmap addOne [1]       == [2]
fmap addOne [1, 2, 3] == [2, 3, 4]

-- Maybe
fmap addOne (Nothing) == Nothing
fmap addOne (Just 2)  == Just 3

-- Either
fmap addOne (Left  0) == Left  0
fmap addOne (Right 2) == Right 3

Interactive Examples:

Using <$ with different types

<$ swaps values in the instance of the Functor typeclass and is originally defined as fmap . const.

-- List
1 <$ [ ]     == [ ]
1 <$ [2]     == [1]
1 <$ [1,2,3] == [1,1,1]

-- Maybe
1 <$ (Nothing) == Nothing
1 <$ (Just 2)  == Just 1

-- Either
1 <$ (Left  0) == Left  0
1 <$ (Right 2) == Right 1

Interactive Examples:

It's not as bad as it looks, or is it? Let me know on twitter - @maciejsmolinski.

In the next post you will learn in a similar way about Applicatives.