learning-haskell/16-functor/16.7-typecheck.md

Wait, how does that even typecheck

(.) :: (b -> c) -> (a -> b) -> a -> c
--       fmap        fmap
fmap :: Functor f => (m -> n) -> f m -> f n
fmap :: Functor g => (x -> y) -> g x -> g y

Let's typecheck fmap . fmap..

1. First, it's important to note that fmap is a function that takes a function m -> n and returns a function f m -> f n.
2. Using that information we see that a is actually m -> n.
3. We also see that b is actually f m -> f n and x -> y, so x has to be f m and y has to be f n.
4. We can then also conclude that g x is g (f m) and g y is g (f n)

Armed with this knowledge, we can apply fmap to (.) a first time (fmap.) :: (Functor g) => (a -> (f m -> f n)) -> a -> g (f m) -> g (f n)

And now we apply it a second time: (fmap . fmap) :: (Functor g, Functor f) => (m -> n) -> g (f m) -> g (f n)