This module provides functions useful for implementing new MonadRandom
and RandomSource
instances for state-abstractions containing PureMT
values (the pure pseudorandom generator provided by the
mersenne-random-pure64 package), as well as instances for some common
cases.
A PureMT
generator is immutable, so PureMT
by itself cannot be a
RandomSource
(if it were, it would always give the same "random"
values). Some form of mutable state must be used, such as an IORef
,
State
monad, etc.. A few default instances are provided by this module
along with more-general functions (getRandomPrimFromMTRef
and
getRandomPrimFromMTState
) usable as implementations for new cases
users might need.
- data PureMT
- newPureMT :: IO PureMT
- pureMT :: Word64 -> PureMT
- getRandomPrimBy :: Monad m => (forall t. (PureMT -> (t, PureMT)) -> m t) -> Prim a -> m a
- getRandomPrimFromMTRef :: forall sr m t. (Monad m, ModifyRef sr m PureMT) => sr -> Prim t -> m t
- getRandomPrimFromMTState :: forall m t. MonadState PureMT m => Prim t -> m t
Documentation
data PureMT
PureMT
, a pure mersenne twister pseudo-random number generator
Show PureMT | |
RandomGen PureMT | |
(Monad m, ModifyRef (IORef PureMT) m PureMT) => RandomSource m (IORef PureMT) | |
(Monad m, ModifyRef (STRef s PureMT) m PureMT) => RandomSource m (STRef s PureMT) | |
(Monad m1, ModifyRef (Ref m2 PureMT) m1 PureMT) => RandomSource m1 (Ref m2 PureMT) | |
Monad m => MonadRandom (StateT PureMT m) | |
Monad m => MonadRandom (StateT PureMT m) |
getRandomPrimBy :: Monad m => (forall t. (PureMT -> (t, PureMT)) -> m t) -> Prim a -> m aSource
Given a function for applying a PureMT
transformation to some hidden
state, this function derives a function able to generate all Prim
s
in the given monad. This is then suitable for either a MonadRandom
or
RandomSource
instance, where the supportedPrims
or
supportedPrimsFrom
function (respectively) is const True
.
getRandomPrimFromMTRef :: forall sr m t. (Monad m, ModifyRef sr m PureMT) => sr -> Prim t -> m tSource
Given a mutable reference to a PureMT
generator, we can implement
RandomSource
for in any monad in which the reference can be modified.
Typically this would be used to define a new RandomSource
instance for
some new reference type or new monad in which an existing reference type
can be modified atomically. As an example, the following instance could
be used to describe how IORef
PureMT
can be a RandomSource
in the
IO
monad:
instance RandomSource IO (IORef PureMT) where supportedPrimsFrom _ _ = True getSupportedRandomPrimFrom = getRandomPrimFromMTRef
(note that there is actually a more general instance declared already covering this as a a special case, so there's no need to repeat this declaration anywhere)
Example usage:
main = do src <- newIORef (pureMT 1234) -- OR: newPureMT >>= newIORef x <- sampleFrom src (uniform 0 100) -- OR: runRVar (uniform 0 100) src print x
getRandomPrimFromMTState :: forall m t. MonadState PureMT m => Prim t -> m tSource
Similarly, getRandomPrimFromMTState x
can be used in any "state"
monad in the mtl sense whose state is a PureMT
generator.
Additionally, the standard mtl state monads have MonadRandom
instances
which do precisely that, allowing an easy conversion of RVar
s and
other Distribution
instances to "pure" random variables (e.g., by
runState . sample :: Distribution d t => d t -> PureMT -> (t, PureMT)
.
PureMT
in the type there can be replaced by StdGen
or anything else
satisfying MonadRandom (State s) => s
).
For example, this module includes the following declaration:
instance MonadRandom (State PureMT) where supportedPrims _ _ = True getSupportedRandomPrim = getRandomPrimFromMTState
This describes a "standard" way of getting random values in State
PureMT
, which can then be used in various ways, for example (assuming
some RVar
foo
and some Word64
seed
):
runState (runRVar foo StdRandom) (pureMT seed) runState (sampleFrom StdRandom foo) (pureMT seed) runState (sample foo) (pureMT seed)
Of course, the initial PureMT
state could also be obtained by any other
convenient means, such as newPureMT
if you don't care what seed is used.