Is there a way to generalise multiple generators and randoms in haskell

Question

I'm learning Haskell. Average of large number of Dice Rolls in Haskell How shall I make the below code work with multiple dices say 8 dices) instead of repeatedly creating let rolls..3,4,5...etc...

module Dice where
import System.Random
import Data.List

dice = do
    g <- getStdGen
    b <- newStdGen
    let trials = 1000
    let rolls1 = take trials (randomRs (1,6) g :: [Int])
    let rolls2 = take trials (randomRs (1,6) b::[Int])
    let rolls = zipWith (+) rolls1 rolls2
    let average = div (foldl' (+) 0 rolls) trials
    print average

[hint](https://www.haskell.org/hoogle/?hoogle=Int+-%3E+m+a+-%3E+m+%5Ba%5D). — AJF, Jun 23 '18 at 12:54

chi · Accepted Answer · 2018-06-23T13:02:14.257

The System.Random module offers some basic primitive, but (in my opinion) it lacks a proper monadic interface. More precisely, it offers an IO-based monadic interface, but lacks a State-based monadic interface. The latter is however easy to define , though.

Anyway, if one wants to stick with IO and the standard generator, one could write:

-- (untested code)

rollDie :: Int -> IO Int
rollDie n = randomIO (1,n) -- implicitly uses the global generator

rollManyDice :: Int -> Int -> IO [Int]
rollManyDice howMany n = replicateM howMany (rollDie n)

main :: IO ()
main = do
   dice <- rollManyDice 20 6
   putStrLn $ "Here's 20 6-sides dice : " ++ show dice

where replicateM executes howMany times a monadic action, collecting all the results in a list. Here the monad is IO, but it could be anything.

This is a fine and simple approach, but the IO type above is a bit too much, preventing us to call rollDie from non-IO code. A State-based solution would not have this limination

type R a = State StdGen a

rollDie :: Int -> R Int
rollDie n = state $ randomR (1,n) -- uses the generator inside the State monad

rollManyDice :: Int -> Int -> R [Int]
rollManyDice howMany n = replicateM howMany (rollDie n)

main :: IO ()
main = do
   g <- getStdGen
   let dice = evalState (rollManyDice 20 6) g
   putStrLn $ "Here's 20 6-sides dice : " ++ show dice

score 0 · Answer 2 · answered Jun 23 '18 at 05:41

Currently as it is formulated, you only need to sum up k*N individual die rolls and divide them by N, where k is amount of dice you want to roll "simultaneously", N amount of trials. Summing all dice in a single roll then summing all rolls is the same as summing all dice overall.

If you want it complicated, well, make single multiroll a list of random values of specified length, sum it (you can use plain sum even with no optimization when k is not too large), compute the average of results.

score 0 · Answer 3 · answered Jun 23 '18 at 11:08

module Dice where
import System.Random
import Data.List
import Control.Applicative
import Control.Monad

rollDie :: Int -> IO Int
rollDie n = randomRIO (1,n)

rollManyDice :: Int -> Int -> IO [Int]
rollManyDice howMany n = replicateM howMany (rollDie n)

dice2 = do
    dice <- rollManyDice 8 6
    putStrLn $ "Here's 20 -6 sided dice: " ++show dice

Is there a way to generalise multiple generators and randoms in haskell

3 Answers3