ModuleMonadRandom-0.6.2.1Haskell2010

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.

Contents

The Rand monad transformer
The RandT monad transformer
Lifting other operations
StatefulGen interface
Examples
Random monads

Synopsis

type Rand
value liftRand
value runRand
value evalRand
value execRand
value mapRand
value withRand
value evalRandIO
newtype RandT
value liftRandT
value runRandT
value evalRandT
value execRandT
value mapRandT
value withRandT
value evalRandTIO
value liftCallCC
value liftCallCC'
value liftCatch
value liftListen
value liftPass
data RandGen
value withRandGen
value withRandGen_

PackageMonadRandom-0.6.2.1
Exports24
LanguageHaskell2010
LicenceBSD-3-Clause
SourceStrict.hs

The Rand monad transformer

typetype Rand g = RandT g Identity

Source#

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.

valueliftRand

:: (g -> (a, g))
pure random transformer
-> Rand g a
equivalent generator-passing computation

Source#

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

valuerunRand

:: Rand g a
generator-passing computation to execute
-> g
initial generator
-> (a, g)
return value and final generator

Source#

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

valueevalRand

:: Rand g a
generator-passing computation to execute
-> g
initial generator
-> a
return value of the random computation

Source#

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)
```

valueexecRand

:: Rand g a
generator-passing computation to execute
-> g
initial generator
-> g
final generator

Source#

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)
```

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

Source#

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

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

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

Source#

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

```
withRand f m = modify f >> m
```

valueevalRandIO :: Rand StdGen a -> IO a

Source#

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

newtypenewtype RandT g (m :: Type -> Type) a

Source#

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.

Instances22MonadRWS, MonadError, MonadReader, MonadState, MonadWriter, MonadSplit, …

(MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
MonadError e m => MonadError e (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
MonadReader r m => MonadReader r (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
MonadState s m => MonadState s (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
MonadWriter w m => MonadWriter w (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
(RandomGen g, Monad m) => MonadSplit g (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
MonadTrans (RandT g)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
(Monad m, RandomGen g) => RandomGenM (RandGen g) g (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
(Monad m, RandomGen g) => StatefulGen (RandGen g) (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
Monad m => Monad (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
Functor m => Functor (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
MonadFix m => MonadFix (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
MonadFail m => MonadFail (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
Monad m => Applicative (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
MonadPlus m => Alternative (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
MonadPlus m => MonadPlus (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
MonadIO m => MonadIO (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
MonadCont m => MonadCont (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
PrimMonad m => PrimMonad (RandT s m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
(Monad m, RandomGen g) => MonadInterleave (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
(RandomGen g, Monad m) => MonadRandom (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
type PrimState (RandT s m) = PrimState mDefined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict

valueliftRandT

:: (g -> m (a, g))
impure random transformer
-> RandT g m a
equivalent generator-passing computation

Source#

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

valuerunRandT

:: RandT g m a
generator-passing computation to execute
-> g
initial generator
-> m (a, g)
return value and final generator

Source#

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

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

Source#

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)

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

Source#

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)

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

Source#

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

runRandT (mapRandT f m) = f . runRandT m

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

Source#

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

```
withRandT f m = modify f >> m
```

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

Source#

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

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

Source#

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

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

Source#

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).

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

Source#

Lift a catchE operation to the new monad.

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

Source#

Lift a listen operation to the new monad.

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

Source#

Lift a pass operation to the new monad.

StatefulGen interface

datadata RandGen g

Source#

A proxy that carries information about the type of generator to use with RandT monad and its StatefulGen instance.

RandGen

Instances4RandomGenM, StatefulGen

(Monad m, RandomGen g) => RandomGenM (RandGen g) g (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Lazy
(Monad m, RandomGen g) => RandomGenM (RandGen g) g (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict
(Monad m, RandomGen g) => StatefulGen (RandGen g) (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Lazy
(Monad m, RandomGen g) => StatefulGen (RandGen g) (RandT g m)Defined in MonadRandom-0.6.2.1 · Control.Monad.Trans.Random.Strict

valuewithRandGen

:: g
initial generator
-> (RandGen g -> RandT g m a)
-> m (a, g)
return value and final generator

Source#

A RandT runner that allows using it with StatefulGen restricted actions. Returns the outcome of random computation and the new pseudo-random-number generator

Example1 expression

>>> withRandGen (mkStdGen 2021) uniformM :: IO (Int, StdGen)(6070831465987696718,StdGen {unStdGen = SMGen 4687568268719557181 4805600293067301895})

valuewithRandGen_

:: Monad m
=> g
initial generator
-> (RandGen g -> RandT g m a)
-> m a
return value and final generator

Source#

Same as withRandGen, but discards the resulting generator.

Example1 expression

>>> withRandGen_ (mkStdGen 2021) uniformM :: IO Int6070831465987696718

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)