In Haskell, the Functor instance is only supposed to handle the mapping between objects, under the following rules:
1. Identity (fmap id = id)
2. Composition fmap f . fmap f = fmap (f o g)
So, if we want to declare a Functor instance over some type, that’s all we need to care about.
Functors are nothing more than that (to handle fmap for some actual type). The type definition of fmap is:
fmap :: Functor f => (a -> b) -> f a -> f b
So, from this we can see that the first parameter is a morphism, and the second parameter is the actual object. So, for instance, we can have:
fmap floor [1.5, 2.5, 3.5]
And we can see how our list “morphs” from a list with doubles to a list with integers!
Prelude> :t [1.5, 2.5, 3.5]
[1.5, 2.5, 3.5] :: Fractional t => [t]
Prelude> :t [1, 2, 3]
[1, 2, 3] :: Num t => [t]
Prelude> :t fmap floor [1.5, 2.5, 3.5]
fmap floor [1.5, 2.5, 3.5] :: Integral b => [b]
Another interesting thing to have a look at is the instance for ((->) r), which is defined as:
instance Functor ((->) r) where
fmap f g = (\x -> f (g x))
Now, by having this definition, and that of fmap’s, we can apply ((->) r) to fmap to get:
fmap :: Functor f -> (a -> b) (r -> a) (r -> b)
fmap f g = (\x -> f (g x))
So, with this we can see that we can apply fmap to functions too!
Prelude> fmap (* 123) succ 3
492
Prelude> fmap (* 100) (\x -> x + 1) 123
12400
And, for some more theory (if you care), Wikipedia states that Functors are morphisms, and for morphisms:
In many fields of mathematics, morphism refers to a structure-preserving mapping from one mathematical structure to another. The notion of morphism recurs in much of contemporary mathematics. In set theory, morphisms are functions; in linear algebra, linear transformations; in group theory, group homomorphisms; in topology, continuous functions, and so on.
In category theory, morphism is a broadly similar idea, but somewhat more abstract: the mathematical objects involved need not be sets, and the relationship between them may be something more general than a map.
bor0's blog 