Control.Monad.Trans.Random.Strict

Strict random monads, passing a random number generator through a computation. See below for examples.

In this version, sequencing of computations is strict (but computations are not strict in the state unless you force it with seq or the like). For a lazy version with the same interface, see Control.Monad.Trans.Random.Lazy.

The Rand monad transformer

type Rand g = RandT g Identity

A random monad parameterized by the type g of the generator to carry.

The return function leaves the generator unchanged, while >>= uses the final generator of the first computation as the initial generator of the second.

liftRand

Arguments

:: (g -> (a, g))

pure random transformer

-> Rand g a

equivalent generator-passing computation

Construct a random monad computation from a function. (The inverse of runRand.)

runRand

Arguments

:: Rand g a

generator-passing computation to execute

-> g

initial generator

-> (a, g)

return value and final generator

Unwrap a random monad computation as a function. (The inverse of liftRand.)

evalRand

Arguments

:: Rand g a

generator-passing computation to execute

-> g

initial generator

-> a

return value of the random computation

Evaluate a random computation with the given initial generator and return the final value, discarding the final generator.

• evalRand m s = fst (runRand m s)

execRand

Arguments

:: Rand g a

generator-passing computation to execute

-> g

initial generator

-> g

final generator

Evaluate a random computation with the given initial generator and return the final generator, discarding the final value.

• execRand m s = snd (runRand m s)

mapRand :: ((a, g) -> (b, g)) -> Rand g a -> Rand g b

Map both the return value and final generator of a computation using the given function.

• runRand (mapRand f m) = f . runRand m

withRand :: (g -> g) -> Rand g a -> Rand g a

withRand f m executes action m on a generator modified by applying f.

• withRand f m = modify f >> m

evalRandIO :: Rand StdGen a -> IO a

Evaluate a random computation in the IO monad, splitting the global standard generator to get a new one for the computation.

The RandT monad transformer

data RandT g m a

A random transformer monad parameterized by:

• g - The generator.
• m - The inner monad.

The return function leaves the generator unchanged, while >>= uses the final generator of the first computation as the initial generator of the second.

Instances

(MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s (RandT g m)

MonadWriter w m => MonadWriter w (RandT g m)

Methods

writer :: (a, w) -> RandT g m a

tell :: w -> RandT g m ()

listen :: RandT g m a -> RandT g m (a, w)

pass :: RandT g m (a, w -> w) -> RandT g m a

MonadState s m => MonadState s (RandT g m)

Methods

get :: RandT g m s

put :: s -> RandT g m ()

state :: (s -> (a, s)) -> RandT g m a

MonadReader r m => MonadReader r (RandT g m)

Methods

ask :: RandT g m r

local :: (r -> r) -> RandT g m a -> RandT g m a

reader :: (r -> a) -> RandT g m a

MonadError e m => MonadError e (RandT g m)

Methods

throwError :: e -> RandT g m a

catchError :: RandT g m a -> (e -> RandT g m a) -> RandT g m a

(RandomGen g, Monad m) => MonadSplit g (RandT g m)

Methods

getSplit :: RandT g m g

MonadTrans (RandT g)

Methods

lift :: Monad m => m a -> RandT g m a

Monad m => Monad (RandT g m)

Methods

(>>=) :: RandT g m a -> (a -> RandT g m b) -> RandT g m b

(>>) :: RandT g m a -> RandT g m b -> RandT g m b

return :: a -> RandT g m a

fail :: String -> RandT g m a

Functor m => Functor (RandT g m)

Methods

fmap :: (a -> b) -> RandT g m a -> RandT g m b

(<$) :: a -> RandT g m b -> RandT g m a

MonadFix m => MonadFix (RandT g m)

Methods

mfix :: (a -> RandT g m a) -> RandT g m a

MonadFail m => MonadFail (RandT g m)

Methods

fail :: String -> RandT g m a

Monad m => Applicative (RandT g m)

Methods

pure :: a -> RandT g m a

(<*>) :: RandT g m (a -> b) -> RandT g m a -> RandT g m b

liftA2 :: (a -> b -> c) -> RandT g m a -> RandT g m b -> RandT g m c

(*>) :: RandT g m a -> RandT g m b -> RandT g m b

(<*) :: RandT g m a -> RandT g m b -> RandT g m a

MonadIO m => MonadIO (RandT g m)

Methods

liftIO :: IO a -> RandT g m a

MonadPlus m => Alternative (RandT g m)

Methods

empty :: RandT g m a

(<|>) :: RandT g m a -> RandT g m a -> RandT g m a

some :: RandT g m a -> RandT g m [a]

many :: RandT g m a -> RandT g m [a]

MonadPlus m => MonadPlus (RandT g m)

Methods

mzero :: RandT g m a

mplus :: RandT g m a -> RandT g m a -> RandT g m a

MonadCont m => MonadCont (RandT g m)

Methods

callCC :: ((a -> RandT g m b) -> RandT g m a) -> RandT g m a

PrimMonad m => PrimMonad (RandT s m)

Associated Types

type PrimState (RandT s m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (RandT s m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (RandT s m)), a#)) -> RandT s m a

(Monad m, RandomGen g) => MonadInterleave (RandT g m)

Methods

interleave :: RandT g m a -> RandT g m a

(RandomGen g, Monad m) => MonadRandom (RandT g m)

Methods

getRandomR :: Random a => (a, a) -> RandT g m a

getRandom :: Random a => RandT g m a

getRandomRs :: Random a => (a, a) -> RandT g m [a]

getRandoms :: Random a => RandT g m [a]

type PrimState (RandT s m)

type PrimState (RandT s m) = PrimState m

liftRandT

Arguments

:: (g -> m (a, g))

impure random transformer

-> RandT g m a

equivalent generator-passing computation

Construct a random monad computation from an impure function. (The inverse of runRandT.)

runRandT

Arguments

:: RandT g m a

generator-passing computation to execute

-> g

initial generator

-> m (a, g)

return value and final generator

Unwrap a random monad computation as an impure function. (The inverse of liftRandT.)

evalRandT :: Monad m => RandT g m a -> g -> m a

Evaluate a random computation with the given initial generator and return the final value, discarding the final generator.

• evalRandT m g = liftM fst (runRandT m g)

execRandT :: Monad m => RandT g m a -> g -> m g

Evaluate a random computation with the given initial generator and return the final generator, discarding the final value.

• execRandT m g = liftM snd (runRandT m g)

mapRandT :: (m (a, g) -> n (b, g)) -> RandT g m a -> RandT g n b

Map both the return value and final generator of a computation using the given function.

• runRandT (mapRandT f m) = f . runRandT m

withRandT :: (g -> g) -> RandT g m a -> RandT g m a

withRandT f m executes action m on a generator modified by applying f.

• withRandT f m = modify f >> m

evalRandTIO :: MonadIO m => RandT StdGen m a -> m a

Evaluate a random computation that is embedded in the IO monad, splitting the global standard generator to get a new one for the computation.

Lifting other operations

liftCallCC :: CallCC m (a, g) (b, g) -> CallCC (RandT g m) a b

Uniform lifting of a callCC operation to the new monad. This version rolls back to the original state on entering the continuation.

liftCallCC' :: CallCC m (a, g) (b, g) -> CallCC (RandT g m) a b

In-situ lifting of a callCC operation to the new monad. This version uses the current state on entering the continuation. It does not satisfy the uniformity property (see Control.Monad.Signatures).

liftCatch :: Catch e m (a, g) -> Catch e (RandT g m) a

Lift a catchE operation to the new monad.

liftListen :: Monad m => Listen w m (a, g) -> Listen w (RandT g m) a

Lift a listen operation to the new monad.

liftPass :: Monad m => Pass w m (a, g) -> Pass w (RandT g m) a

Lift a pass operation to the new monad.

Examples

Random monads

The die function simulates the roll of a die, picking a number between 1 and 6, inclusive, and returning it in the Rand monad transformer. Notice that this code will work with any random number generator g.

die :: (RandomGen g) => Rand g Int
die = getRandomR (1, 6)

The dice function uses replicate and sequence to simulate the roll of n dice.

dice :: (RandomGen g) => Int -> Rand g [Int]
dice n = sequence (replicate n die)

To extract a value from the Rand monad transformer, we can use evalRandIO.

main = do
  values <- evalRandIO (dice 2)
  putStrLn (show values)