System.Random.MWC.Monad

This module provide monadic interface for mwc-random package. It's just a thin wrapper and all work is done mwc-random.

Random monad

data Rand m a

Random monad for mwc-random package

Instances

MonadTrans Rand

Monad m => Monad (Rand m)

Monad m => Functor (Rand m)

Monad m => Applicative (Rand m)

MonadPrim m => MonadPrim (Rand m)

MonadIO m => MonadIO (Rand m)

type BasePrimMonad (Rand m) = BasePrimMonad m

toRand :: MonadPrim m => (Gen (PrimState (BasePrimMonad m)) -> BasePrimMonad m a) -> Rand m a

Convert function to Rand monad

Type syhnonims

type RandIO a = Rand IO a

Type synonim for IO-based Rand monad

asRandIO :: RandIO a -> RandIO a

Fix type of monad to IO

type RandST s a = Rand (ST s) a

Type synonim for ST-based Rand monad

asRandST :: RandST s a -> RandST s a

Fix type of monad to ST

Running monad

runRand :: Rand m a -> Gen (PrimState (BasePrimMonad m)) -> m a

Run random monad

runWithCreate :: MonadPrim m => Rand m a -> m a

Run monad using fixed seed

runWithSeed :: MonadPrim m => Seed -> Rand m a -> m a

Run monad using seed

runWithVector :: (Vector v Word32, MonadPrim m) => Rand m a -> v Word32 -> m a

By creating seed from vector of values

runWithSystemRandom :: (PrimBase m, BasePrimMonad m ~ m) => Rand m a -> IO a

Run monad using seed obtained from system's fast source of pseudo-random numbers ("/dev/urandom" on Unix-like systems). m must be either IO or ST.

runWithSystemRandomT :: (MonadPrim m, BasePrimMonad m ~ IO) => Rand m a -> m a

Run monad using seed obtained from system's fast source of pseudo-random numbers ("/dev/urandom" on Unix-like systems). Unlike runWithSystemRandom it could be used with monad stacks.

Random numbers generation

uniform :: (MonadPrim m, Variate a) => Rand m a

Uniformly distributed values

uniformR :: (MonadPrim m, Variate a) => (a, a) -> Rand m a

Uniformly distributed values in range

Seed management

data Seed :: *

An immutable snapshot of the state of a Gen.

Instances

Eq Seed

Show Seed

Typeable * Seed

toSeed :: Vector v Word32 => v Word32 -> Seed

Convert vector to Seed. It acts similarily to initialize and will accept any vector. If you want to pass seed immediately to restore you better call initialize directly since following law holds:

restore (toSeed v) = initialize v

fromSeed :: Seed -> Vector Word32

Convert seed into vector.

save :: MonadPrim m => Rand m Seed

Save current seed for future reuse