使用 Monad 进行函数映射

Question

I have the following code :

type Mapper a k v = a -> [(k,v)]
type Reducer k v = k -> [v] -> [v]


mapReduce :: Ord k => Mapper a k v -> Reducer k v -> [a] -> [(k,[v])]
mapReduce m r = reduce r . shuffleKeys . concatMap (map listifyVal . m)
  where listifyVal (k,v) = (k,[v])
        shuffleKeys = Map.fromListWith (++)
        reduce r = Map.toList . Map.mapWithKey r

I'm given a Monad types

   type MapperM m a k v = a -> m [(k,v)]
   type ReducerM m k v = k -> [v] -> m [v]

And I need to convert the existing code to use Monad

mapReduceM :: (Ord k, Monad m) => MapperM m a k v -> ReducerM m k v -> [a] -> m [(k,[v])]

I'm stuck on converting the expression concatMap (map listifyVal . m) I wrote this helper function

listifyValM:: (Ord k, Monad m) => m(k,v) ->  m(k,[v])                        
listifyValM mkv = do
                    (k,v) <- mkv
                    return (k,[v])

and tried

 mapReduceM :: (Ord k, Monad m) => MapperM m a k v -> ReducerM m k v -> [a] -> m [(k,[v])]
 mapReduceM m r input =  do      
                            let step0 =  (map listifyValM )                                                  
                            return []

But I can't get even this (very partial) simple thing to work as a starter. I get :

  Could not deduce (Ord k0) arising from a use of `listifyValM'
  from the context: (Ord k, Monad m)
    bound by the type signature for:

I'm probably missing something basic regarding mapping over Monads .

Answer 1

Writing mapReduceM from scratch may be easier than trying to mechanically convert mapReduce . You want:

mapReduceM :: (Monad m, Ord k) => MapperM m a k v -> ReducerM m k v -> [a] -> m [(k,[v])]
mapReduceM m r as = ...

So, let's assume arguments of the following types and try to build the function:

m :: a -> m [(k,v)]
r :: k -> [v] -> m [v]
as :: [a]

It can be helpful to create a skeleton file that uses concrete types which will let us type check expressions in GHCi:

import Data.Map (Map)
import qualified Data.Map as Map

data A
data K = K deriving (Eq, Ord)
data V
data M a
instance Functor M
instance Applicative M
instance Monad M

m :: A -> M [(K,V)]
m = undefined
r :: K -> [V] -> M [V]
r = undefined
as :: [A]
as = undefined

Obviously, we need to pass the elements of as to the only available function that can take them, namely m . The standard way of applying a monadic function a -> mb to a list [a] is to perform a traversal, using mapM or traverse . (In the old days, the former was for monads and the latter was for applicatives, but now that all monads are applicatives, traverse is preferred.) Specifically, with this skeleton loaded, we can type check this expression in GHCi:

> :t traverse m as
traverse m as :: M [[(K, V)]]

To collapse the lists of lists, we want to apply concat "under" the monad. Fortunately, monads are functors, so fmap (or its synonym (<$>) ) can do it:

> :t concat <$> traverse m as
concat <$> traverse m as :: M [(K, V)]

Now, we want to load this into a map by common keys. In other word, we want to apply the pure function:

combineByKey :: [(K, V)] -> Map K [V]
combineByKey = Map.fromListWith (++) . map (\(k,v) -> (k,[v]))

under the monad:

> :t combineByKey . concat <$> traverse m as
combineByKey . concat <$> traverse m as :: M (Map K [V])

Now, we want to apply the reduction r to the map. This is a little tricky. If we try to apply mapWithKey under the monad the same way we did with concat and combineByKey , we get an extra unwanted monad layer:

> :t Map.mapWithKey r . combineByKey . concat <$> traverse m as
Map.mapWithKey r . combineByKey . concat <$> traverse m as
  :: M (Map K (M [V]))
     ^---------^---------- two monad layers

Here, do notation can help us work through the process:

do mymap <- combineByKey . concat <$> traverse m as
   ...

Here, mymap is pulled out of the monad and so has type:

mymap :: Map K [V]
mymap = undefined

If we used mapWithKey to apply the reducer:

> Map.mapWithKey r mymap
Map.mapWithKey r mymap :: Map K (M [V])

we have a structure of monadic elements. Because Map is traversable, we can pull the monad to the outside with sequence :

> sequence $ Map.mapWithKey r mymap
sequence $ Map.mapWithKey r mymap :: M (Map K [V])

This is almost the return value we wanted from mapReduceM . We just need to change the map to a list under the monad:

> Map.toList <$> (sequence $ Map.mapWithKey r mymap)
Map.toList <$> (sequence $ Map.mapWithKey r mymap) :: M [(K, [V])]

In the end, our definition of mapReduceM is the completed do-block:

mapReduceM :: (Monad m, Ord k) => MapperM m a k v -> ReducerM m k v -> [a] -> m [(k,[v])]
mapReduceM m r as = do
  mymap <- combineByKey . concat <$> traverse m as
  Map.toList <$> (sequence $ Map.mapWithKey r mymap)
  where combineByKey :: (Ord k) => [(k, v)] -> Map k [v]
        combineByKey = Map.fromListWith (++) . map (\(k,v) -> (k,[v]))

This can be converted to a point-free form like so:

import Control.Monad

mapReduceM :: (Monad m, Ord k) => MapperM m a k v -> ReducerM m k v -> [a] -> m [(k,[v])]
mapReduceM m r =
  traverse m >=>                       -- apply the mapper
  pure . combineByKey . concat >=>     -- combine keys
  sequence . Map.mapWithKey r >=>      -- reduce
  pure . Map.toList                    -- convert to list

  where combineByKey :: (Ord k) => [(k, v)] -> Map k [v]
        combineByKey = Map.fromListWith (++) . map (\(k,v) -> (k,[v]))