Copyright	(c) Brent Yorgey 2016
License	BSD3 (see LICENSE)
Maintainer	byorgey@gmail.com
Stability	experimental
Portability	non-portable (multi-param classes, functional dependencies, undecidable instances)
Safe Haskell	Safe
Language	Haskell2010

Control.Monad.Random.Lazy

Contents

The Rand monad
The RandT monad transformer
Some convenience re-exports

Description

Random monads that are lazy in the generator state. For a strict version, see Control.Monad.Random.Strict, which has the same interface.

Synopsis

type Rand g = RandT g Identity
liftRand :: (g -> (a, g)) -> Rand g a
runRand :: Rand g a -> g -> (a, g)
evalRand :: Rand g a -> g -> a
execRand :: Rand g a -> g -> g
mapRand :: ((a, g) -> (b, g)) -> Rand g a -> Rand g b
withRand :: (g -> g) -> Rand g a -> Rand g a
evalRandIO :: Rand StdGen a -> IO a
data RandT g m a
liftRandT :: (g -> m (a, g)) -> RandT g m a
runRandT :: RandT g m a -> g -> m (a, g)
evalRandT :: Monad m => RandT g m a -> g -> m a
execRandT :: Monad m => RandT g m a -> g -> m g
mapRandT :: (m (a, g) -> n (b, g)) -> RandT g m a -> RandT g n b
withRandT :: (g -> g) -> RandT g m a -> RandT g m a
evalRandTIO :: MonadIO m => RandT StdGen m a -> m a
module System.Random
module Control.Monad.Random.Class
module Control.Monad
module Control.Monad.Fix
module Control.Monad.Trans

The Rand monad

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

liftRand Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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

data RandT g m 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.

Instances

(MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy
MonadWriter w m => MonadWriter w (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy 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) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy 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) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy 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) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy 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) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods getSplit :: RandT g m g Source #
MonadTrans (RandT g) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods lift :: Monad m => m a -> RandT g m a #
Monad m => Monad (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy 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) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy 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) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods mfix :: (a -> RandT g m a) -> RandT g m a #
MonadFail m => MonadFail (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods fail :: String -> RandT g m a #
Monad m => Applicative (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy 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) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods liftIO :: IO a -> RandT g m a #
MonadPlus m => Alternative (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy 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) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy 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) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods callCC :: ((a -> RandT g m b) -> RandT g m a) -> RandT g m a #
PrimMonad m => PrimMonad (RandT s m) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy Associated Types type PrimState (RandT s m) :: Type # Methods primitive :: (State# (PrimState (RandT s m)) -> (#State# (PrimState (RandT s m)), a#)) -> RandT s m a #
(Monad m, RandomGen g) => MonadInterleave (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods interleave :: RandT g m a -> RandT g m a Source #
(RandomGen g, Monad m) => MonadRandom (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods getRandomR :: Random a => (a, a) -> RandT g m a Source # getRandom :: Random a => RandT g m a Source # getRandomRs :: Random a => (a, a) -> RandT g m [a] Source # getRandoms :: Random a => RandT g m [a] Source #
type PrimState (RandT s m) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy type PrimState (RandT s m) = PrimState m

liftRandT Source #

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 Source #

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

execRandT :: 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)

mapRandT :: (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

withRandT :: (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
```

evalRandTIO :: 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.

Some convenience re-exports

module System.Random

module Control.Monad.Random.Class

module Control.Monad

module Control.Monad.Fix

module Control.Monad.Trans