{-# LANGUAGE FlexibleInstances, UndecidableInstances  #-}

-- | This module defines another Par-related class to capture the
--   random number generation capability.  
-- 
--   The `rand` operation provides deterministic parallel random
--   number generation from within a Par monad.
-- 
--   Most likely one will simply use the `ParRand` the instance
--   provided in this file, which is based on a state transformer
--   carrying the random generator.


module Control.Monad.Par.RNG 
 (
  ParRand(..), runParRand, ParRandStd
 ) where 

import System.Random
import Control.Exception

import Control.Monad.Par.Class
import Control.Monad.Par.State
import Control.Monad.Trans
import Control.Monad.Trans.State.Strict as S 

-- | A `ParRand` monad is a Par monad with support for random number generation..
class ParRand p where 
  rand :: Random a => p a
  -- This can be more efficient:
  randInt :: p Int
  randInt = p Int
forall a. Random a => p a
forall (p :: * -> *) a. (ParRand p, Random a) => p a
rand 

-- | Trivial instance.
instance RandomGen g => SplittableState g where
  splitState :: g -> (g, g)
splitState = g -> (g, g)
forall g. RandomGen g => g -> (g, g)
split

-- | The most straightforward way to get a `ParRand` monad: carry a
--   RNG in a state transformer.
instance (ParFuture fut p, RandomGen g) => ParRand (StateT g p) where 
  rand :: forall a. Random a => StateT g p a
rand    = do 
               g
g <- StateT g p g
forall (m :: * -> *) s. Monad m => StateT s m s
S.get
	       let (a
x,g
g') = g -> (a, g)
forall a g. (Random a, RandomGen g) => g -> (a, g)
forall g. RandomGen g => g -> (a, g)
random g
g 
	       g -> StateT g p ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
S.put g
g'
	       a -> StateT g p a
forall a. a -> StateT g p a
forall (m :: * -> *) a. Monad m => a -> m a
return a
x
  randInt :: StateT g p Int
randInt = do 
               g
g <- StateT g p g
forall (m :: * -> *) s. Monad m => StateT s m s
S.get
               let (Int
x,g
g') = g -> (Int, g)
forall g. RandomGen g => g -> (Int, g)
next g
g
	       g -> StateT g p ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
S.put g
g'
	       Int -> StateT g p Int
forall a. a -> StateT g p a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
x

-- An alternative is for these operators to be standalone without a class:
-- rand    :: (ParFuture p fut, RandomGen g, Random a) => StateT g p a
-- randInt :: (ParFuture p fut, RandomGen g)           => StateT g p Int

-- runParRand :: ParRand p => (p a -> a) -> p a -> IO a
runParRand :: ParFuture fut p => (p a -> a) -> StateT StdGen p a -> IO a
runParRand :: forall (fut :: * -> *) (p :: * -> *) a.
ParFuture fut p =>
(p a -> a) -> StateT StdGen p a -> IO a
runParRand p a -> a
runPar StateT StdGen p a
m = 
  do StdGen
g <- IO StdGen
forall (m :: * -> *). MonadIO m => m StdGen
newStdGen
     a -> IO a
forall a. a -> IO a
evaluate (p a -> a
runPar (StateT StdGen p a -> StdGen -> p a
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT StateT StdGen p a
m StdGen
g))


-- | A convenience type for the most standard
type ParRandStd par a = StateT StdGen par a