How to generate an infinite list of random numbers using randomRIO?

Question

I'm trying to generate an infinite list of random numbers using randomRIO.

import System.Random

g :: IO [Integer]
g = do
  n <- randomRIO (1,6) :: IO Integer
  f <- g
  return (n : f)

It compiles but hangs when run.

Sibi · Accepted Answer · 2015-07-10T14:01:42.420

6

The problem with your code is that it never teminates. Whenever you execute g, it initially calcuates the first random number and stores it in n. Then it again recursively calls back to the same function g which goes on and on. To get an infinite list you can use the randomRs function:

g2 :: IO [Integer]
g2 = do
  g <- newStdGen
  return $ randomRs (1,6) g

And then you can produce any number of random numbers using it:

λ> g2 >>= \x -> return $ take 5 $ x
[5,4,6,5,6]

edited Jul 10 '15 at 14:01

answered Jul 10 '15 at 13:56

Sibi

47,472
16
95
163

This won't work correctly: `getStdGen` does not update the global RNG state, like `randomRIO` does. You need `getStdRandom` to achieve this effect. – leftaroundabout Jul 10 '15 at 13:58

score 5 · Answer 2 · edited May 23 '17 at 10:28

5

Well, you can't, for much the same reason why you can't lazily mapM over State (and then use the result state afterwards). randomRIO produces a single value and only hands on the monadic program flow after this value has been produced.

The way to produce infinite streams of random values is of course randomRs. You can easily couple it with getStdRandom to produce such streams right in IO:

import Control.Arrow

randomRsIO :: Random a => (a,a) -> IO [a]
randomRsIO range = getStdRandom $ split >>> first (randomRs range)

With that,

g :: IO [Integer]
g = randomRsIO (1,6)

edited May 23 '17 at 10:28

Community

1
1

answered Jul 10 '15 at 13:54

leftaroundabout

117,950
5
174
319

2

You can do it with [`unsafeInterleaveIO`](http://hackage.haskell.org/package/base-4.8.0.0/docs/System-IO-Unsafe.html#v:unsafeInterleaveIO): `g = do {r <- randomRIO (1,6); rs <- unsafeInterleaveIO g; return (r:rs)}`. But unless I had a reason, I'd use your approach. – cchalmers Jul 10 '15 at 13:57
I generally pretend the `unsafeXyzIO` functions don't exist. (But you're right, this could actually be a safe use case... but I don't see any benefit over `randomRs`.) – leftaroundabout Jul 10 '15 at 14:02
I can't compile `randomRsIO`. `Couldn't match type ‘[a]’ with ‘([a], StdGen)’` – Ηλεκτρολόγος Μηχανικός Jul 10 '15 at 14:51
Right, that's because `randomRs` doesn't return an updated generator. Fixed. – leftaroundabout Jul 10 '15 at 14:58
1

Thank you for introducing me to `Arrow` :) – Ηλεκτρολόγος Μηχανικός Jul 10 '15 at 16:35
I think you mean `IO`, not `State` - some kinds of lazy `mapM` work just fine in `State`, e.g. the `mapM return [1..]` in your link. (Just don't try to get at the "afterward" state.) – Ørjan Johansen Jul 11 '15 at 03:34
@ØrjanJohansen well, e.g. `mapM return [1..] >> state (const((),()))` terminates, it's true. But that's basically just a way of decoupling a “thread” of state. That thread will never terminate. – leftaroundabout Jul 11 '15 at 08:24
Because of laziness, "never terminate" doesn't mean it cannot be useful. Another example that actually *uses* the state: `evalState (mapM (\x -> modify (+x) >> get) $ [1..]) 0`. – Ørjan Johansen Jul 11 '15 at 08:54

score 0 · Answer 3 · answered Apr 01 '16 at 06:53

You wanted an answer using randomRIO. I know its been a long time since the question was asked.

This is using liftM where you can generate a random number in range low l to high h and keep appending to a list num times. So we have a list of length num of random numbers.

import Control.Monad
import System.Random
gx :: Int -> Int -> Int -> IO [Int]
gx l h num = do
        x <- randomRIO(l,h)
        if num <=1 then return [x] else liftM (x:) (gx l h (num-1))

How to generate an infinite list of random numbers using randomRIO?

3 Answers3