Haskell maps returning a monad

Question

The lookup function in Data.Map and Data.IntMap currently return values wrapped in Maybe with the type signature

lookup  :: Ord  k => k -> Map  k a -> Maybe  a

It used to have the more general type of

lookup  :: (Monad  m, Ord  k) => k -> Map  k a -> m a

I realize the former likely reduces the need of extra type specification, but the latter would make it much more general and allow lookup to be used in list comprehensions. Is there any way to mimic this behavior with the newer version, or would I have to use an older version of the library?

Answer 1

Don's lift converts Maybe's elements to their general Monad counterparts, so perhaps it should be named convert or generalize or something;-)

If you just want to use lookup mainly in list comprehensions and other monads that implement a fail, you could also make use of the mapping of pattern match failure to fail:

Prelude> [ v | Just v <- return $ lookup "hi" [("ho","silver")] ]
[]
Prelude> [ v | Just v <- return $ lookup "ho" [("ho","silver")] ]
["silver"]

Prelude> do Just v <- return $ lookup "hi" [("ho","silver")] ; print v
*** Exception: user error (Pattern match failure in do expression at <interactive>:1:3-8)
Prelude> do Just v <- return $ lookup "ho" [("ho","silver")] ; print v
"silver"

Answer 2

the latter would make it much more general and allow lookup to be used in list comprehensions

The latter is also more unsafe, as the majority of monad classes define fail as error. That is, the common case of not finding an element in the Map is a program-terminating error for most monads. That, coupled with the increased likelihood of the wrong type context being inferred, means we tend to discourage the 'monadic fail return' style now.

Is there any way to mimic this behavior with the newer version

Indeed there is! Simply lift Maybe a into Monad a, like so:

lift :: Monad m => Maybe a -> m a
lift Nothing  = fail "you die now"
lift (Just a) = return a

And now you can write, e.g. lift . lookup

Answer 3

For the specific case of the list monad, the simplest solution is to use maybeToList:

Prelude> :m +Data.Maybe -- Note: Use "import Data.Maybe" in a program file

Data.Maybe> [ v | v <- maybeToList $ lookup "hi" [("ho","silver")] ]
[]
Data.Maybe> [ v | v <- maybeToList $ lookup "ho" [("ho","silver")] ]
["silver"]