在单子上下文中生成列表

Question

As I understand, you can use the 'draw from' (<-) keyword in haskell to take values out of a monadic context in do-notation:

func = do
    x <- getRandom
    let y = (x + 1)
    return y

How would I apply this when generating lists? Say I am mapping a function f :: (MonadRandom m) => Int -> ma that takes an integer and returns a value in a MonadRandom context. I want to generate a list of values of type a inside a MonadRandom context ie m [a] . I believe doing something like this:

func = do
    xs <- map f [0..10]
    return xs

would generate a list of values, each in a monadic context and then try to draw from the list which is not in the MonadRandom context

Apologies if my terminology/understanding is incorrect, I am new to haskell.

Answer 1

update

for your edit with the MonadRandom I think all you need is mapM :

import System.Random (randomRIO)

f :: Int -> IO Int
f n = randomRIO (n,n+n)

g :: [Int] -> IO [Int]
g xs = mapM f xs

example

λ> g [1..3]
[1,4,5]
λ> g [1..3]
[1,3,4]
λ> g [1..3]
[1,4,6]

btw: of course you can do this yourself using do :

g :: [Int] -> IO [Int]
g [] = return []
g (x:xs) = do
  r <- f x
  rs <- g xs
  return (r:rs)

just remember not to mix up the list and the IO monad here - so the do , <- and return here is in IO - for the rest of this answer it will be in the list-monad

---

First your example (if f :: a -> [b] ) will create a list of list of values (which you surely found out already) - if you want to flatten it look below (basically you just have to pull out once more)

---

Right now I don't understand exactly where you are going for, but here is a short example of how you can use the do notation with lists:

Look at this function:

combs :: [a] -> [b] -> [(a,b)]
combs xs ys = do
  x <- xs
  y <- ys
  return (x,y)

here is an example of it in action:

λ> combs [1..3] "Hi"
[(1,'H'),(1,'i'),(2,'H'),(2,'i'),(3,'H'),(3,'i')]

As you can see the trick is to draw an example x out of all xs (of course you will do all - therefore you can think of this as working with combinatorics) and a y out of ys and then do something with them (here just make a tuple) and finally return ing it.

Now of course you can first map it somehow (here just doubling the xs ):

combs :: [a] -> [b] -> [(a,b)]
combs xs ys = do
  x <- xs ++ xs
  y <- ys
  return (x,y)

and it will pull out of the mapped values:

λ> combs [1..3] "Hi"
[(1,'H'),(1,'i'),(2,'H'),(2,'i'),(3,'H'),(3,'i'),(1,'H'),(1,'i'),(2,'H'),(2,'i'),(3,'H'),(3,'i')]

does this help you?

---

here is another one where f creates a list itself:

func :: (a -> [b]) -> [a] -> [b]
func f xs = do
  x <- xs
  b <- f x
  return b

as you can see first we pull out an x from xs , apply f to get a lists of b s only to pull them out with b <- fx and then just returning those.

Which is of course just concatMap

Example

λ> func (\x -> [x,x]) [1..5]
[1,1,2,2,3,3,4,4,5,5]

is this where you are going for?