Question

I’m reading the LYAH chapter on applicative functors, and I don’t seem to understand the following example:

ghci> :t fmap (++) (Just "hey")  
fmap (++) (Just "hey") :: Maybe ([Char] -> [Char])

But when I look at this:

ghci> :t (++)
(++) :: [a] -> [a] -> [a]
ghci> :t fmap
fmap :: Functor f => (a -> b) -> f a -> f b

I do understand how something like (*3) or (++”this”) fits into the (a -> b) type, but I just can’t see how [a] -> [a] -> [a] fits into (a -> b)?

Answer 1

Putting the stuff side-by-side as usual,

fmap :: Functor f => ( a    ->      b      )   ->      f a        ->   f b
fmap                       (++)                    (Just "hey")   ::   f b
(++) ::               [c]   -> ([c] -> [c])

So,

a ~ [c]  ,    b ~ ([c] -> [c])  ,    f ~ Maybe  ,    a ~ [Char]  ,   c ~ Char

f b ~ Maybe b ~ Maybe ([c] -> [c]) ~  Maybe ([Char] -> [Char])

No thinking is involved here. Unification of types is a mechanical process.

---

And to answer your specific question (paraphrased), ” how [c] -> [c] -> [c] can be matched with a -> b“, here goes:

• Omitting parentheses in type signatures is evil (when teaching Haskell to newbies)
• In Haskell, there are no binary functions. Every function is unary.
• Hence (as others mentioned already), arrows in type signatures associate to the right.