Why do we have map, fmap and liftM?

Question

map :: (a -> b) -> [a] -> [b]

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

liftM :: Monad m => (a -> b) -> m a -> m b

Why do we have three different functions that do essentially the same thing?

History, mostly. fmap is distinct from map for pedagogical reasons, liftM distinct from fmap for historical reasons (namely Functor not being a superclass of Monad) — luqui
Oh, and just for the sake of being clear: They don't "essentially" do the same thing. Both map and liftM should most certainly do exactly the same thing as fmap. — C. A. McCann
While fmap and liftM do exactly the same thing, map of course is only a special case of them, i.e. something different. fmap id getLine is well-typed, whereas map id getLine is not. — Thorsten

li.davidm li.davidm · Accepted Answer · 2011-09-18T18:40:39

map exists to simplify operations on lists and for historical reasons (see What's the point of map in Haskell, when there is fmap?).

You might ask why we need a separate map function. Why not just do away with the current list-only map function, and rename fmap to map instead? Well, that’s a good question. The usual argument is that someone just learning Haskell, when using map incorrectly, would much rather see an error about lists than about Functors.

-- Typeclassopedia, page 20

fmap and liftM exist because monads were not automatically functors in Haskell:

The fact that we have both fmap and liftM is an unfortunate consequence of the fact that the Monad type class does not require a Functor instance, even though mathematically speaking, every monad is a functor. However, fmap and liftM are essentially interchangeable, since it is a bug (in a social rather than technical sense) for any type to be an instance of Monad without also being an instance of Functor.

-- Typeclassopedia, page 33

Edit: agustuss's history of map and fmap:

That's not actually how it happens. What happened was that the type of map was generalized to cover Functor in Haskell 1.3. I.e., in Haskell 1.3 fmap was called map. This change was then reverted in Haskell 1.4 and fmap was introduced. The reason for this change was pedagogical; when teaching Haskell to beginners the very general type of map made error messages more difficult to understand. In my opinion this wasn't the right way to solve the problem.

-- What's the point of map in Haskell, when there is fmap?

Why do we have map, fmap and liftM?

1 Answers