Monadic concatMap for Data.Vector？

Question

I'm looking for something from the Data.Vector package which works like concatMap but works with monads. concatMap has type...

(a -> Vector b) -> Vector a -> Vector b 

but I'm looking for something with type...

(Monad m) => (a -> m (Vector b)) -> Vector a -> m (Vector b)

... or, in particular, either one of:

(MonadRandom m) => ((Int, Int) -> m (Vector Int)) 
                -> Vector (Int, Int) -> m (Vector Int)

(MonadRandom m) => (Int -> Int -> m (Vector Int))
                -> Vector (Int, Int) -> m (Vector Int)

The code below should give an idea of what I'm trying to do but produces the error

Couldn't match type VU.Vector Int with Int
Expected type: m (VU.Vector Int)
Actual type: m (VU.Vector (VU.Vector Int))
In the expression: return $ VU.concatMap mate mates

import           Control.Monad
import           Control.Monad.Random 
import qualified Data.Vector.Unboxed  as VU

testReprod :: IO()
testReprod = do
  let parents = VU.fromList [1::Int,2,3,4,5,6,7,8,9,10]
  children <- reproduce parents
  print children

-- concat monadic
reproduce :: (MonadRandom m) => (VU.Vector Int) -> m (VU.Vector Int)
reproduce parents = return $ VU.concatMap mate mates
    where
  half = VU.length parents `div` 2
  mates = VU.zip (VU.take half parents) (VU.drop half parents)
  mate :: (MonadRandom m) => (Int, Int) -> m (VU.Vector Int)
  mate (a, b) = do
    r1 <- getRandomR(0,5)
    r2 <- getRandomR(0,5)
    return $ VU.fromList [a+r1, b+r2]

While the mate function in the example does not actually rely on getting a tuple of values, the actual code from which the example is based on does.

Answer 1

Monad m => (a -> m (Vector b)) -> Vector a -> m (Vector b) is not too difficult - we can rely on the Functor , Monad , and Traversable instances of Vector . The big caveat is you will need to use a regular (not unboxed) Vector .

import Data.Vector (Vector)
import Control.Monad (join)

concatMapM :: Monad m => (a -> m (Vector b)) -> Vector a -> m (Vector b)
concatMapM f v = join <$> sequence (fmap f v)

The problem with doing this for unboxed vectors is that in the intermediate fmap fv step I have a Vector (m (Vector b)) and there is no reasonable data instance for that (nor the required corresponding Monad m => Vector Vector (m (Vector b)) class instance).