View source for New monads/MonadRandomSplittable

[[Category:Code]]

When using [[New monads/MonadRandom]], one may also want to use a <hask>MonadRandom</hask> equivalent of <hask>RandomGen</hask>'s <hask>split</hask> function:

<haskell>
class (MonadRandom m) => MonadRandomSplittable m where
    splitRandom :: m a -> m a

instance (Monad m, RandomGen g) => MonadRandomSplittable (RandomT g m) where
    splitRandom ma  = (RandomT . liftState) split >>= lift . evalRandomT ma
</haskell>

MonadRandomSplittable can then be derived for Rand by [[GHC]]:
<haskell>
newtype Rand g a = Rand { unRand :: RandomT g Identity a }
    deriving (Functor, Monad, MonadRandom, MonadRandomSplittable)
</haskell>

Some potentially useful functions
<haskell>
splitRandoms        :: MonadRandomSplittable m => [m a] -> m [a]
splitRandoms []     = splitRandom $ return []
splitRandoms (x:xs) = splitRandom $ liftM2 (:) x (splitRandoms xs)

getRandoms      :: (MonadRandomSplittable m, Random a) => m [a]
getRandoms      = liftM2 (:) getRandom (splitRandom getRandoms)

getRandomRs     :: (MonadRandomSplittable m, Random a) => (a, a) -> m [a]
getRandomRs b   = liftM2 (:) (getRandomR b) (splitRandom (getRandomRs b))
</haskell>

== Example of usage ==

<haskell>
test   :: Rand StdGen [Bool] -> (Int, [Bool], Int)
test ma = evalRand (liftM3 (,,) (getRandomR (0,99)) ma (getRandomR (0,99)))
                (mkStdGen 0)
</haskell>

Then
<haskell>
*MonadRandom> test (replicateM 0 getRandom)
(45,[],55)
*MonadRandom> test (replicateM 2 getRandom)
(45,[True,True],0)

*MonadRandom> test (splitRandom $ replicateM 0 getRandom)
(45,[],16)
*MonadRandom> test (splitRandom $ replicateM 2 getRandom)
(45,[False,True],16)

*MonadRandom> case test undefined of (a,_,c) -> (a,c)
*** Exception: Prelude.undefined
*MonadRandom> case test (splitRandom undefined) of (a,_,c) -> (a,c)
(45,16)
</haskell>

== Laws ==

It is not clear to me exactly what [[Monad laws|laws]] <hask>splitRandom</hask> should satisfy, besides monadic variations of the "split laws" from the  [http://haskell.org/onlinereport/random.html Haskell Library Report]

For all terminating <hask>ma</hask> and <hask>mb</hask>, it should hold that
<haskell>
  liftM3 (\a _ c -> (a,c)) getRandom ma getRandom === liftM3 (\a _ c -> (a,c)) getRandom mb getRandom
</haskell>

For [[monad transformer]]s, it would also be nice if
<haskell>
splitRandom undefined === splitRandom (return ()) >> lift undefined
</haskell>

For example,
<haskell>
>runIdentity $ runRandomT (splitRandom (return ()) >> lift undefined >> return ()) (mkStdGen 0)
((),40014 2147483398)
>runIdentity $ runRandomT (splitRandom undefined >> return ()) (mkStdGen 0)
((),40014 2147483398)
</haskell>
But
<haskell>
>runRandomT (splitRandom (return ()) >> lift undefined >> return ()) (mkStdGen 0)
*** Exception: Prelude.undefined
>runRandomT (splitRandom undefined >> return ()) (mkStdGen 0)
*** Exception: Prelude.undefined
</haskell>

I have no idea how to express this idea for monads that aren't transformers though. But for <hask>Rand</hask> it means that:
<haskell>
>runRand (splitRandom undefined >> return ()) (mkStdGen 0)
((),40014 2147483398)
</haskell>

== Why? ==
In <hask>replicateM 100 (splitRandom expensiveAction)</hask> There are no RNG-dependencies between the different expensiveActions, so they may be computed in parallel.

The following constructs a tree of infinite depth and width:
<haskell>
import Data.Tree
import Data.List

makeRandomTree  = liftM2 Node (getRandomR ('a','z')) (splitRandoms $ repeat makeRandomTree)
</haskell>
By removing the RNG-dependencies, infinite random data structures can be constructed lazily.

And for completeness the non-monadic version:
<haskell>
randomTree g    = Node a (map randomTree gs)
    where
        (a, g') = randomR ('a','z') g
        gs      = unfoldr (Just . split) g'
</haskell>
Note that the monadic version does more split operations, so yields different results.