MonadRandom 0.4.2.3 → 0.5

raw patch · 10 files changed

+1211/−361 lines, 10 filesdep +faildep +primitivedep ~randomPVP ok

version bump matches the API change (PVP)

Dependencies added: fail, primitive

Dependency ranges changed: random

API changes (from Hackage documentation)

Files

• CHANGES.markdown +52/−0
• Control/Monad/Random.hs +12/−286
• Control/Monad/Random/Class.hs +395/−36
• Control/Monad/Random/Lazy.hs +58/−0
• Control/Monad/Random/Strict.hs +56/−0
• Control/Monad/Trans/Random.hs +22/−0
• Control/Monad/Trans/Random/Lazy.hs +285/−0
• Control/Monad/Trans/Random/Strict.hs +286/−0
• LICENSE +27/−31
• MonadRandom.cabal +18/−8

@@ -1,3 +1,55 @@+0.5 (3 January 2016)+--------------------++  This release has quite a few small additions as well as a big module+  reorganization.  However, thanks to module re-exports, most existing+  code using the library should continue to work with no changes; the+  major version bump reflects the large reorganization and my+  inability to 100% guarantee that existing user code will not break.++  The biggest changes that may be of interest to users of the library+  include new lazy vs strict variants of the `Rand` monad; a new+  `MonadInterleave` class which is a big improvement over+  `MonadSplit`; new `PrimMonad` instances; and new random selection+  functions like `weighted`, `weightedMay`, `uniformMay`, *etc.*.  See+  the list below for full details.++  Although there was some discussion of generalizing `MonadRandom` to+  work for a wider range of underlying generators+  (see+  [#26](https://github.com/byorgey/MonadRandom/issues/26),+  [#31](https://github.com/byorgey/MonadRandom/issues/31), and+  [comments on this blog post](https://byorgey.wordpress.com/2016/11/16/monadrandom-0-5-and-mwc-random-feedback-wanted/)),+  I decided to punt on that for now. It seems rather complicated and+  there+  are+  [already good alternatives](http://hackage.haskell.org/package/random%2Dfu) so+  I decided to keep things simple for this release.  I'm still open to+  proposals for generalizing future releases.++  Changes in 0.5 include:++  - Refactor to reflect structure of `mtl` and `transformers` libraries.+  - Add lazy and strict variants of `RandT`.+  - Add `MonadRandom` and `MonadSplit` instances for `ListT`.+  - Add (but do not export) `unRandT` field to `RandT`.+  - Add `MonadCont`, `MonadError`, `MonadRWS`, `PrimMonad`, and `MonadFail`+    instances for `RandT`.+  - Add `evalRandTIO` operation.+  - Move `fromList` and `uniform` operations to+    `Control.Monad.Random.Class`.+  - `fromList` now raises an error when the total weight of elements+    is zero.+  - Generalize the type of `uniform` to work over any `Foldable`.+  - Add new operations `weighted`, `weightedMay`, `fromListMay`, and+    `uniformMay`.  `weighted` is like `fromList` but generalized to+    work over any `Foldable`.  The `May` variants return a `Maybe`+    result instead of raising an error.+  - New `MonadInterleave` class for random monads which can interleave+    random generation using `split`.  In some ways this is similar to+    `MonadSplit` but much more useful.+  - Improved documentation.+ 0.4.2.3 (21 April 2016) ----------------------- 

@@ -1,294 +1,20 @@-{-# LANGUAGE CPP                        #-}-{-# LANGUAGE FlexibleInstances          #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}-{-# LANGUAGE MultiParamTypeClasses      #-}-{-# LANGUAGE Trustworthy                #-}-{-# LANGUAGE UndecidableInstances       #-}-{-# OPTIONS -fno-warn-orphans #-}+{-# LANGUAGE Safe #-}  {- |-Copyright    : 2006-2007 Cale Gibbard, Russell O'Connor, Dan Doel, Remi Turk, Eric Kidd.-License      : OtherLicense-Stability    : experimental-Portability  : non-portable (multi-parameter type classes, undecidable instances)--A random number generation monad.  See-<http://www.haskell.org/haskellwiki/NewMonads/MonadRandom> for the original-version of this code.--The actual interface is defined by-'Control.Monad.Random.Class.MonadRandom'.--[Computation type:] Computations which consume random values.--[Binding strategy:] The computation proceeds in the same fashion as the-identity monad, but it carries a random number generator that may be-queried to generate random values.+Module       :  Control.Monad.Random+Copyright    :  (c) Brent Yorgey 2016+License      :  BSD3 (see LICENSE) -[Useful for:] Monte Carlo algorithms and simulating random processes.+Maintainer   :  byorgey@gmail.com+Stability    :  experimental+Portability  :  non-portable (multi-param classes, functional dependencies, undecidable instances) +This module is provided for backwards compatibility, and simply+re-exports "Control.Monad.Random.Lazy". -} -module Control.Monad.Random (-    module System.Random,-    module Control.Monad.Random.Class,-    evalRandT,-    runRandT,-    evalRand,-    runRand,-    evalRandIO,-    fromList,-    uniform,-    Rand, RandT, -- but not the data constructors-    -- * Special lift functions-    liftRand,-    liftRandT-    -- * Example-    -- $RandExample+module Control.Monad.Random+    ( module Control.Monad.Random.Lazy,     ) where -import           Control.Applicative-import           Control.Arrow-import           Control.Monad                ()-import           Control.Monad.Cont-import           Control.Monad.Error-import           Control.Monad.Identity-import           Control.Monad.Random.Class-import           Control.Monad.Reader-import qualified Control.Monad.RWS.Lazy       as RWSL-import qualified Control.Monad.RWS.Strict     as RWSS-import           Control.Monad.State-import qualified Control.Monad.State.Lazy     as SL-import qualified Control.Monad.State.Strict   as SS-import           Control.Monad.Trans          ()-import           Control.Monad.Trans.Except-import           Control.Monad.Trans.Identity-import           Control.Monad.Trans.Maybe-import           Control.Monad.Writer.Class-import qualified Control.Monad.Writer.Lazy    as WL-import qualified Control.Monad.Writer.Strict  as WS-import           Data.Monoid                  (Monoid)-import           System.Random---- | A monad transformer which adds a random number generator to an--- existing monad.-newtype RandT g m a = RandT (StateT g m a)-    deriving (Functor, Monad, MonadPlus, MonadTrans, MonadIO, MonadFix, MonadReader r, MonadWriter w)--instance (Functor m, Monad m) => Applicative (RandT g m) where-  pure = return-  (<*>) = ap--instance (Functor m, MonadPlus m) => Alternative (RandT g m) where-  empty = mzero-  (<|>) = mplus---- | Lift arbitrary action to RandT-liftRandT :: (g -> m (a, g)) -- ^ action returning value and new generator state-             -> RandT g m a-liftRandT = RandT . StateT---- | Lift arbitrary action to Rand-liftRand :: (g -> (a, g)) -- ^ action returning value and new generator state-            -> Rand g a-liftRand = RandT . state--instance (Monad m, RandomGen g) => MonadRandom (RandT g m) where-    getRandom = RandT . state $ random-    getRandoms = RandT . state $ first randoms . split-    getRandomR (x,y) = RandT . state $ randomR (x,y)-    getRandomRs (x,y) = RandT . state $-                            first (randomRs (x,y)) . split--instance (Monad m, RandomGen g) => MonadSplit g (RandT g m) where-    getSplit = RandT . state $ split---- | Evaluate a RandT computation using the generator @g@.  Note that the--- generator @g@ is not returned, so there's no way to recover the--- updated version of @g@.-evalRandT :: (Monad m) => RandT g m a -> g -> m a-evalRandT (RandT x) g = evalStateT x g---- | Run a RandT computation using the generator @g@, returning the result and--- the updated generator.-runRandT  :: RandT g m a -> g -> m (a, g)-runRandT (RandT x) g = runStateT x g---- | A basic random monad.-type Rand g = RandT g Identity---- | Evaluate a random computation using the generator @g@.  Note that the--- generator @g@ is not returned, so there's no way to recover the--- updated version of @g@.-evalRand :: Rand g a -> g -> a-evalRand x g = runIdentity (evalRandT x g)---- | Run a random computation using the generator @g@, returning the result--- and the updated generator.-runRand :: Rand g a -> g -> (a, g)-runRand x g = runIdentity (runRandT x g)---- | Evaluate a random computation in the IO monad, splitting the global standard generator to get a new one for the computation.-evalRandIO :: Rand StdGen a -> IO a-evalRandIO x = fmap (evalRand x) newStdGen---- | Sample a random value from a weighted list.  The total weight of all--- elements must not be 0.-fromList :: (MonadRandom m) => [(a,Rational)] -> m a-fromList [] = error "MonadRandom.fromList called with empty list"-fromList [(x,_)] = return x-fromList xs = do-  -- TODO: Do we want to be able to use floats as weights?-  -- TODO: Better error message if weights sum to 0.-  let s = (fromRational (sum (map snd xs))) :: Double -- total weight-      cs = scanl1 (\(_,q) (y,s') -> (y, s'+q)) xs       -- cumulative weight-  p <- liftM toRational $ getRandomR (0.0,s)-  return . fst . head $ dropWhile (\(_,q) -> q < p) cs---- | Sample a value from a uniform distribution of a list of elements.-uniform :: (MonadRandom m) => [a] -> m a-uniform = fromList . fmap (flip (,) 1)--instance (MonadRandom m) => MonadRandom (IdentityT m) where-    getRandom = lift getRandom-    getRandomR = lift . getRandomR-    getRandoms = lift getRandoms-    getRandomRs = lift . getRandomRs--instance (MonadRandom m) => MonadRandom (SL.StateT s m) where-    getRandom = lift getRandom-    getRandomR = lift . getRandomR-    getRandoms = lift getRandoms-    getRandomRs = lift . getRandomRs--instance (MonadRandom m) => MonadRandom (SS.StateT s m) where-    getRandom = lift getRandom-    getRandomR = lift . getRandomR-    getRandoms = lift getRandoms-    getRandomRs = lift . getRandomRs--instance (MonadRandom m, Monoid w) => MonadRandom (WL.WriterT w m) where-    getRandom = lift getRandom-    getRandomR = lift . getRandomR-    getRandoms = lift getRandoms-    getRandomRs = lift . getRandomRs--instance (MonadRandom m, Monoid w) => MonadRandom (WS.WriterT w m) where-    getRandom = lift getRandom-    getRandomR = lift . getRandomR-    getRandoms = lift getRandoms-    getRandomRs = lift . getRandomRs--instance (MonadRandom m) => MonadRandom (ReaderT r m) where-    getRandom = lift getRandom-    getRandomR = lift . getRandomR-    getRandoms = lift getRandoms-    getRandomRs = lift . getRandomRs--instance (MonadRandom m, Monoid w) => MonadRandom (RWSL.RWST r w s m) where-    getRandom = lift getRandom-    getRandomR = lift . getRandomR-    getRandoms = lift getRandoms-    getRandomRs = lift . getRandomRs--instance (MonadRandom m, Monoid w) => MonadRandom (RWSS.RWST r w s m) where-    getRandom = lift getRandom-    getRandomR = lift . getRandomR-    getRandoms = lift getRandoms-    getRandomRs = lift . getRandomRs--instance (MonadRandom m) => MonadRandom (ExceptT e m) where-    getRandom = lift getRandom-    getRandomR = lift . getRandomR-    getRandoms = lift getRandoms-    getRandomRs = lift . getRandomRs--instance (Error e, MonadRandom m) => MonadRandom (ErrorT e m) where-    getRandom = lift getRandom-    getRandomR = lift . getRandomR-    getRandoms = lift getRandoms-    getRandomRs = lift . getRandomRs--instance (MonadRandom m) => MonadRandom (MaybeT m) where-    getRandom = lift getRandom-    getRandomR = lift . getRandomR-    getRandoms = lift getRandoms-    getRandomRs = lift . getRandomRs--instance MonadRandom m => MonadRandom (ContT r m) where-    getRandom = lift getRandom-    getRandomR = lift . getRandomR-    getRandoms = lift getRandoms-    getRandomRs = lift . getRandomRs--instance (MonadSplit g m) => MonadSplit g (IdentityT m) where-    getSplit = lift getSplit--instance (MonadSplit g m) => MonadSplit g (SL.StateT s m) where-    getSplit = lift getSplit--instance (MonadSplit g m) => MonadSplit g (SS.StateT s m) where-    getSplit = lift getSplit--instance (MonadSplit g m, Monoid w) => MonadSplit g (WL.WriterT w m) where-    getSplit = lift getSplit--instance (MonadSplit g m, Monoid w) => MonadSplit g (WS.WriterT w m) where-    getSplit = lift getSplit--instance (MonadSplit g m) => MonadSplit g (ReaderT r m) where-    getSplit = lift getSplit--instance (MonadSplit g m, Monoid w) => MonadSplit g (RWSL.RWST r w s m) where-    getSplit = lift getSplit--instance (MonadSplit g m, Monoid w) => MonadSplit g (RWSS.RWST r w s m) where-    getSplit = lift getSplit--instance (MonadSplit g m) => MonadSplit g (ExceptT e m) where-    getSplit = lift getSplit--instance (Error e, MonadSplit g m) => MonadSplit g (ErrorT e m) where-    getSplit = lift getSplit--instance (MonadSplit g m) => MonadSplit g (MaybeT m) where-    getSplit = lift getSplit--instance (MonadSplit g m) => MonadSplit g (ContT r m) where-    getSplit = lift getSplit--instance (MonadState s m) => MonadState s (RandT g m) where-    get = lift get-    put = lift . put--instance MonadRandom IO where-    getRandom = randomIO-    getRandomR = randomRIO-    getRandoms = fmap randoms newStdGen-    getRandomRs b = fmap (randomRs b) newStdGen--instance MonadSplit StdGen IO where-    getSplit = newStdGen--{- $RandExample--The @die@ function simulates the roll of a die, picking a number between 1-and 6, inclusive, and returning it in the 'Rand' monad.  Notice that this-code will work with any source of random numbers @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, we can can use 'evalRandIO'.-->main = do->  values <- evalRandIO (dice 2)->  putStrLn (show values)---}+import           Control.Monad.Random.Lazy

@@ -1,50 +1,409 @@-{-# LANGUAGE MultiParamTypeClasses, UndecidableInstances, FunctionalDependencies #-}+{-# LANGUAGE CPP                    #-}+{-# LANGUAGE FlexibleInstances      #-}+{-# LANGUAGE FunctionalDependencies #-}+{-# LANGUAGE MultiParamTypeClasses  #-}+{-# LANGUAGE Safe                   #-}+{-# LANGUAGE UndecidableInstances   #-}  {- |-Copyright    : 2006-2007 Cale Gibbard, Russell O'Connor, Dan Doel, Remi Turk, Eric Kidd.-License      : OtherLicense-Stability    : experimental-Portability  : non-portable (multi-parameter type classes, undecidable instances)+Module       :  Control.Monad.Random.Class+Copyright    :  (c) Brent Yorgey 2016+License      :  BSD3 (see LICENSE)+Maintainer   :  byorgey@gmail.com -A type class for random number generation monads.  See-<http://www.haskell.org/haskellwiki/NewMonads/MonadRandom> for the original-version of this code.+The 'MonadRandom', 'MonadSplit', and 'MonadInterleave' classes. -Instances of this type class include 'Control.Monad.Random.Rand' and-monads created using 'Control.Monad.Random.RandT'.+* 'MonadRandom' abstracts over monads with the capability of+  generating random values. +* 'MonadSplit' abstracts over random monads with the ability to get a+  split generator state.  It is not very useful but kept here for+  backwards compatibility.++* 'MonadInterleave' abstracts over random monads supporting an+  'interleave' operation, which allows sequencing computations which do+  not depend on each other's random generator state, by splitting the+  generator between them.++This module also defines convenience functions for sampling from a+given collection of values, either uniformly or according to given+weights.+ -}  module Control.Monad.Random.Class (-    MonadRandom,-    getRandom,-    getRandomR,-    getRandoms,-    getRandomRs,-    MonadSplit,-    getSplit++    -- * MonadRandom+    MonadRandom(..),++    -- * MonadSplit+    MonadSplit(..),++    -- * MonadInterleave+    MonadInterleave(..),++    -- * Sampling functions+    fromList,+    fromListMay,+    uniform,+    uniformMay,+    weighted,+    weightedMay     ) where -import System.Random+import           Control.Monad+import           Control.Monad.Trans.Class+import           Control.Monad.Trans.Cont+import           Control.Monad.Trans.Error+import           Control.Monad.Trans.Except+import           Control.Monad.Trans.Identity+import           Control.Monad.Trans.List+import           Control.Monad.Trans.Maybe+import           Control.Monad.Trans.Reader+import qualified Control.Monad.Trans.RWS.Lazy      as LazyRWS+import qualified Control.Monad.Trans.RWS.Strict    as StrictRWS+import qualified Control.Monad.Trans.State.Lazy    as LazyState+import qualified Control.Monad.Trans.State.Strict  as StrictState+import qualified Control.Monad.Trans.Writer.Lazy   as LazyWriter+import qualified Control.Monad.Trans.Writer.Strict as StrictWriter+import           System.Random --- | An interface to random number generation monads.+import qualified Data.Foldable                     as F++#if MIN_VERSION_base(4,8,0)+#else+import           Data.Monoid                       (Monoid)+#endif++------------------------------------------------------------+-- MonadRandom+------------------------------------------------------------++-- | With a source of random number supply in hand, the 'MonadRandom' class+-- allows the programmer to extract random values of a variety of types. class (Monad m) => MonadRandom m where-    -- | Return a randomly-selected value of type @a@.  See-    -- 'System.Random.random' for details.-    getRandom :: (Random a) => m a-    -- | Return an infinite stream of random values of type @a@.  See-    -- 'System.Random.randoms' for details.-    getRandoms :: (Random a) => m [a]-    -- | Return a randomly-selected value of type @a@ in the range-    -- /[lo,hi]/.  See 'System.Random.randomR' for details.-    getRandomR :: (Random a) => (a,a) -> m a-    -- | Return an infinite stream of randomly-selected value of type @a@-    -- in the range /[lo,hi]/.  See 'System.Random.randomRs' for details.-    getRandomRs :: (Random a) => (a,a) -> m [a]+  -- | Takes a range /(lo,hi)/ and a random number generator+  -- /g/, and returns a computation that returns a random value uniformly+  -- distributed in the closed interval /[lo,hi]/, together with a new+  -- generator. It is unspecified what happens if /lo>hi/. For continuous+  -- types there is no requirement that the values /lo/ and /hi/ are ever+  -- produced, but they may be, depending on the implementation and the+  -- interval.+  --+  -- See 'System.Random.randomR' for details.+  getRandomR :: (Random a) => (a, a) -> m a --- | An interface to monads with splittable state (as most random number generation monads will have).--- The intention is that the 'getSplit' action splits the state, returning one half of the result, and--- setting the new state to the other.-class (Monad m) => MonadSplit s m | m -> s where-    getSplit :: m s+  -- | The same as 'getRandomR', but using a default range determined by the type:+  --+  -- * For bounded types (instances of 'Bounded', such as 'Char'),+  --   the range is normally the whole type.+  --+  -- * For fractional types, the range is normally the semi-closed interval+  -- @[0,1)@.+  --+  -- * For 'Integer', the range is (arbitrarily) the range of 'Int'.+  --+  -- See 'System.Random.random' for details.+  getRandom :: (Random a) => m a +  -- | Plural variant of 'getRandomR', producing an infinite list of+  -- random values instead of returning a new generator.+  --+  -- See 'System.Random.randomRs' for details.+  getRandomRs :: (Random a) => (a, a) -> m [a]++  -- | Plural variant of 'getRandom', producing an infinite list of+  -- random values instead of returning a new generator.+  --+  -- See 'System.Random.randoms' for details.+  getRandoms :: (Random a) => m [a]++instance MonadRandom IO where+  getRandomR       = randomRIO+  getRandom        = randomIO+  getRandomRs lohi = liftM (randomRs lohi) newStdGen+  getRandoms       = liftM randoms newStdGen++instance (MonadRandom m) => MonadRandom (ContT r m) where+  getRandomR  = lift . getRandomR+  getRandom   = lift getRandom+  getRandomRs = lift . getRandomRs+  getRandoms  = lift getRandoms++instance (Error e, MonadRandom m) => MonadRandom (ErrorT e m) where+  getRandomR  = lift . getRandomR+  getRandom   = lift getRandom+  getRandomRs = lift . getRandomRs+  getRandoms  = lift getRandoms++instance (MonadRandom m) => MonadRandom (ExceptT e m) where+  getRandomR  = lift . getRandomR+  getRandom   = lift getRandom+  getRandomRs = lift . getRandomRs+  getRandoms  = lift getRandoms++instance (MonadRandom m) => MonadRandom (IdentityT m) where+  getRandomR  = lift . getRandomR+  getRandom   = lift getRandom+  getRandomRs = lift . getRandomRs+  getRandoms  = lift getRandoms++instance (MonadRandom m) => MonadRandom (ListT m) where+  getRandomR  = lift . getRandomR+  getRandom   = lift getRandom+  getRandomRs = lift . getRandomRs+  getRandoms  = lift getRandoms++instance (MonadRandom m) => MonadRandom (MaybeT m) where+  getRandomR  = lift . getRandomR+  getRandom   = lift getRandom+  getRandomRs = lift . getRandomRs+  getRandoms  = lift getRandoms++instance (Monoid w, MonadRandom m) => MonadRandom (LazyRWS.RWST r w s m) where+  getRandomR  = lift . getRandomR+  getRandom   = lift getRandom+  getRandomRs = lift . getRandomRs+  getRandoms  = lift getRandoms++instance (Monoid w, MonadRandom m) => MonadRandom (StrictRWS.RWST r w s m) where+  getRandomR  = lift . getRandomR+  getRandom   = lift getRandom+  getRandomRs = lift . getRandomRs+  getRandoms  = lift getRandoms++instance (MonadRandom m) => MonadRandom (ReaderT r m) where+  getRandomR  = lift . getRandomR+  getRandom   = lift getRandom+  getRandomRs = lift . getRandomRs+  getRandoms  = lift getRandoms++instance (MonadRandom m) => MonadRandom (LazyState.StateT s m) where+  getRandomR  = lift . getRandomR+  getRandom   = lift getRandom+  getRandomRs = lift . getRandomRs+  getRandoms  = lift getRandoms++instance (MonadRandom m) => MonadRandom (StrictState.StateT s m) where+  getRandomR  = lift . getRandomR+  getRandom   = lift getRandom+  getRandomRs = lift . getRandomRs+  getRandoms  = lift getRandoms++instance (MonadRandom m, Monoid w) => MonadRandom (LazyWriter.WriterT w m) where+  getRandomR  = lift . getRandomR+  getRandom   = lift getRandom+  getRandomRs = lift . getRandomRs+  getRandoms  = lift getRandoms++instance (MonadRandom m, Monoid w) => MonadRandom (StrictWriter.WriterT w m) where+  getRandomR  = lift . getRandomR+  getRandom   = lift getRandom+  getRandomRs = lift . getRandomRs+  getRandoms  = lift getRandoms++------------------------------------------------------------+-- MonadSplit+------------------------------------------------------------++-- | The class 'MonadSplit' proivides a way to specify a random number+--   generator that can be split into two new generators.+--+--   This class is not very useful in practice: typically, one cannot+--   actually do anything with a generator.  It remains here to avoid+--   breaking existing code unnecessarily.  For a more practically+--   useful interface, see 'MonadInterleave'.+class (Monad m) => MonadSplit g m | m -> g where++  -- | The 'getSplit' operation allows one to obtain two distinct random number+  -- generators.+  --+  -- See 'System.Random.split' for details.+  getSplit :: m g++instance MonadSplit StdGen IO where+  getSplit = newStdGen++instance (MonadSplit g m) => MonadSplit g (ContT r m) where+  getSplit = lift getSplit++instance (Error e, MonadSplit g m) => MonadSplit g (ErrorT e m) where+  getSplit = lift getSplit++instance (MonadSplit g m) => MonadSplit g (ExceptT e m) where+  getSplit = lift getSplit++instance (MonadSplit g m) => MonadSplit g (IdentityT m) where+  getSplit = lift getSplit++instance (MonadSplit g m) => MonadSplit g (ListT m) where+  getSplit = lift getSplit++instance (MonadSplit g m) => MonadSplit g (MaybeT m) where+  getSplit = lift getSplit++instance (Monoid w, MonadSplit g m) => MonadSplit g (LazyRWS.RWST r w s m) where+  getSplit = lift getSplit++instance (Monoid w, MonadSplit g m) => MonadSplit g (StrictRWS.RWST r w s m) where+  getSplit = lift getSplit++instance (MonadSplit g m) => MonadSplit g (ReaderT r m) where+  getSplit = lift getSplit++instance (MonadSplit g m) => MonadSplit g (LazyState.StateT s m) where+  getSplit = lift getSplit++instance (MonadSplit g m) => MonadSplit g (StrictState.StateT s m) where+  getSplit = lift getSplit++instance (Monoid w, MonadSplit g m) => MonadSplit g (LazyWriter.WriterT w m) where+  getSplit = lift getSplit++instance (Monoid w, MonadSplit g m) => MonadSplit g (StrictWriter.WriterT w m) where+  getSplit = lift getSplit++------------------------------------------------------------+-- MonadInterleave+------------------------------------------------------------++-- | The class 'MonadInterleave' proivides a convenient interface atop+--   a 'split' operation on a random generator.+class MonadRandom m => MonadInterleave m where++  -- | If @x :: m a@ is a computation in some random monad, then+  --   @interleave x@ works by splitting the generator, running @x@+  --   using one half, and using the other half as the final generator+  --   state of @interleave x@ (replacing whatever the final generator+  --   state otherwise would have been).  This means that computation+  --   needing random values which comes after @interleave x@ does not+  --   necessarily depend on the computation of @x@.  For example:+  --+  --   > >>> evalRandIO $ snd <$> ((,) <$> undefined <*> getRandom)+  --   > *** Exception: Prelude.undefined+  --   > >>> evalRandIO $ snd <$> ((,) <$> interleave undefined <*> getRandom)+  --   > 6192322188769041625+  --+  --   This can be used, for example, to allow random computations to+  --   run in parallel, or to create lazy infinite structures of+  --   random values.  In the example below, the infinite tree+  --   @randTree@ cannot be evaluated lazily: even though it is cut+  --   off at two levels deep by @hew 2@, the random value in the+  --   right subtree still depends on generation of all the random+  --   values in the (infinite) left subtree, even though they are+  --   ultimately unneeded.  Inserting a call to @interleave@, as in+  --   @randTreeI@, solves the problem: the generator splits at each+  --   @Node@, so random values in the left and right subtrees are+  --   generated independently.+  --+  --   > data Tree = Leaf | Node Int Tree Tree deriving Show+  --   >+  --   > hew :: Int -> Tree -> Tree+  --   > hew 0 _    = Leaf+  --   > hew _ Leaf = Leaf+  --   > hew n (Node x l r) = Node x (hew (n-1) l) (hew (n-1) r)+  --   >+  --   > randTree :: Rand StdGen Tree+  --   > randTree = Node <$> getRandom <*> randTree <*> randTree+  --   >+  --   > randTreeI :: Rand StdGen Tree+  --   > randTreeI = interleave $ Node <$> getRandom <*> randTreeI <*> randTreeI+  --+  --   > >>> hew 2 <$> evalRandIO randTree+  --   > Node 2168685089479838995 (Node (-1040559818952481847) Leaf Leaf) (Node ^CInterrupted.+  --   > >>> hew 2 <$> evalRandIO randTreeI+  --   > Node 8243316398511136358 (Node 4139784028141790719 Leaf Leaf) (Node 4473998613878251948 Leaf Leaf)+  interleave :: m a -> m a++instance (MonadInterleave m) => MonadInterleave (ContT r m) where+  interleave = mapContT interleave++instance (Error e, MonadInterleave m) => MonadInterleave (ErrorT e m) where+  interleave = mapErrorT interleave++instance (MonadInterleave m) => MonadInterleave (ExceptT e m) where+  interleave = mapExceptT interleave++instance (MonadInterleave m) => MonadInterleave (IdentityT m) where+  interleave = mapIdentityT interleave++instance (MonadInterleave m) => MonadInterleave (ListT m) where+  interleave = mapListT interleave++instance (MonadInterleave m) => MonadInterleave (MaybeT m) where+  interleave = mapMaybeT interleave++instance (Monoid w, MonadInterleave m) => MonadInterleave (LazyRWS.RWST r w s m) where+  interleave = LazyRWS.mapRWST interleave++instance (Monoid w, MonadInterleave m) => MonadInterleave (StrictRWS.RWST r w s m) where+  interleave = StrictRWS.mapRWST interleave++instance (MonadInterleave m) => MonadInterleave (ReaderT r m) where+  interleave = mapReaderT interleave++instance (MonadInterleave m) => MonadInterleave (LazyState.StateT s m) where+  interleave = LazyState.mapStateT interleave++instance (MonadInterleave m) => MonadInterleave (StrictState.StateT s m) where+  interleave = StrictState.mapStateT interleave++instance (Monoid w, MonadInterleave m) => MonadInterleave (LazyWriter.WriterT w m) where+  interleave = LazyWriter.mapWriterT interleave++instance (Monoid w, MonadInterleave m) => MonadInterleave (StrictWriter.WriterT w m) where+  interleave = StrictWriter.mapWriterT interleave++------------------------------------------------------------+-- Convenience samplers+------------------------------------------------------------++-- | Sample a random value from a weighted nonempty collection of+--   elements.  Crashes with a call to @error@ if the collection is+--   empty or the total weight is zero.+weighted :: (F.Foldable t, MonadRandom m) => t (a, Rational) -> m a+weighted t = do+  ma <- weightedMay t+  case ma of+    Nothing -> error "Control.Monad.Random.Class.weighted: empty collection, or total weight = 0"+    Just a  -> return a++-- | Sample a random value from a weighted collection of elements.+--   Returns @Nothing@ if the collection is empty or the total weight is+--   zero.+weightedMay :: (F.Foldable t, MonadRandom m) => t (a, Rational) -> m (Maybe a)+weightedMay = fromListMay . F.toList++-- | Sample a random value from a weighted list.  The list must be+--   non-empty and the total weight must be non-zero.+fromList :: (MonadRandom m) => [(a, Rational)] -> m a+fromList ws = do+  ma <- fromListMay ws+  case ma of+    Nothing -> error "Control.Monad.Random.Class.fromList: empty list, or total weight = 0"+    Just a  -> return a++-- | Sample a random value from a weighted list.  Return @Nothing@ if+--   the list is empty or the total weight is zero.+fromListMay :: (MonadRandom m) => [(a, Rational)] -> m (Maybe a)+fromListMay xs = do+  let s    = fromRational (sum (map snd xs)) :: Double+      cums = scanl1 (\ ~(_,q) ~(y,s') -> (y, s'+q)) xs+  case s of+    0 -> return Nothing+    _ -> do+      p <- liftM toRational $ getRandomR (0, s)+      return . Just . fst . head . dropWhile ((< p) . snd) $ cums++-- | Sample a value uniformly from a nonempty collection of elements.+uniform :: (F.Foldable t, MonadRandom m) => t a -> m a+uniform t = do+  ma <- uniformMay t+  case ma of+    Nothing -> error "Control.Monad.Random.Class.uniform: empty collection"+    Just a  -> return a++-- | Sample a value uniformly from a collection of elements.  Return+--   @Nothing@ if the collection is empty.+uniformMay :: (F.Foldable t, MonadRandom m) => t a -> m (Maybe a)+uniformMay = fromListMay . map (flip (,) 1) . F.toList

@@ -0,0 +1,58 @@+{-# LANGUAGE Safe #-}++{- |+Module       :  Control.Monad.Random.Lazy+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)++Random monads that are lazy in the generator state. For a strict+version, see "Control.Monad.Random.Strict", which has the same+interface.+-}++module Control.Monad.Random.Lazy+    ( -- * The Rand monad+      Rand,+      liftRand,+      runRand,+      evalRand,+      execRand,+      mapRand,+      withRand,+      evalRandIO,++      -- * The RandT monad transformer+      RandT,+      liftRandT,+      runRandT,+      evalRandT,+      execRandT,+      mapRandT,+      withRandT,+      evalRandTIO,++      -- * Some convenience re-exports++      module Control.Monad.Random.Class,+      module Control.Monad,+      module Control.Monad.Fix,+      module Control.Monad.Trans,+    ) where++import           Control.Monad.Random.Class++import           Control.Monad.Trans+import           Control.Monad.Trans.Random.Lazy (Rand, RandT, evalRand,+                                                  evalRandIO, evalRandT,+                                                  evalRandTIO, execRand,+                                                  execRandT, liftRand,+                                                  liftRandT, mapRand, mapRandT,+                                                  runRand, runRandT, withRand,+                                                  withRandT)++import           Control.Monad+import           Control.Monad.Fix

@@ -0,0 +1,56 @@+{-# LANGUAGE Safe #-}++{- |+Module       :  Control.Monad.Random.Strict+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)++Random monads that are strict in the generator state.  For a lazy+version, see "Control.Monad.Random.Lazy", which has the same+interface.+-}++module Control.Monad.Random.Strict+    ( -- * The Rand monad transformer+      Rand,+      liftRand,+      runRand,+      evalRand,+      execRand,+      mapRand,+      withRand,+      evalRandIO,+      -- * The RandT monad transformer+      RandT,+      liftRandT,+      runRandT,+      evalRandT,+      execRandT,+      mapRandT,+      withRandT,+      evalRandTIO,+      -- * Some convenience re-exports++      module Control.Monad.Random.Class,+      module Control.Monad,+      module Control.Monad.Fix,+      module Control.Monad.Trans,+    ) where++import           Control.Monad.Random.Class++import           Control.Monad.Trans+import           Control.Monad.Trans.Random.Strict (Rand, RandT, evalRand,+                                                    evalRandIO, evalRandT,+                                                    evalRandTIO, execRand,+                                                    execRandT, liftRand,+                                                    liftRandT, mapRand,+                                                    mapRandT, runRand, runRandT,+                                                    withRand, withRandT)++import           Control.Monad+import           Control.Monad.Fix

@@ -0,0 +1,22 @@+{-# LANGUAGE Safe #-}++{- |+Module       :  Control.Monad.Trans.Random+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)++Random monads, passing a random number generator through a computation.++This version is lazy; for a strict version, see+"Control.Monad.Trans.Random.Strict", which has the same interface.+-}++module Control.Monad.Trans.Random+    ( module Control.Monad.Trans.Random.Lazy,+    ) where++import           Control.Monad.Trans.Random.Lazy

@@ -0,0 +1,285 @@+{-# LANGUAGE FlexibleInstances          #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE MultiParamTypeClasses      #-}+{-# LANGUAGE Trustworthy                #-}+{-# LANGUAGE TypeFamilies               #-}+{-# LANGUAGE UndecidableInstances       #-}++{- |+Module       :  Control.Monad.Trans.Random.Lazy+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)++Lazy random monads, passing a random number generator through a computation.+See below for examples.++For a strict version with the same interface, see+"Control.Monad.Trans.Random.Strict".+-}++module Control.Monad.Trans.Random.Lazy+  ( -- * The Rand monad transformer+    Rand,+    liftRand,+    runRand,+    evalRand,+    execRand,+    mapRand,+    withRand,+    evalRandIO,+    -- * The RandT monad transformer+    RandT,+    liftRandT,+    runRandT,+    evalRandT,+    execRandT,+    mapRandT,+    withRandT,+    -- * Lifting other operations+    liftCallCC,+    liftCallCC',+    liftCatch,+    liftListen,+    liftPass,+    evalRandTIO,+    -- * Examples+    -- ** Random monads+    -- $examples+  ) where++import           Control.Applicative+import           Control.Arrow                  (first)+import           Control.Monad+import           Control.Monad.Cont.Class+import           Control.Monad.Error.Class+import qualified Control.Monad.Fail             as Fail+import           Control.Monad.Fix+import           Control.Monad.IO.Class+import           Control.Monad.Primitive+import           Control.Monad.Random.Class+import           Control.Monad.RWS.Class+import           Control.Monad.Signatures+import           Control.Monad.Trans.Class+import qualified Control.Monad.Trans.State.Lazy as LazyState+import           Data.Functor.Identity+import           System.Random++-- | 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.+type Rand g = RandT g Identity++-- | Construct a random monad computation from a function.+-- (The inverse of 'runRand'.)+liftRand+  :: (g -> (a, g))+  -- ^ pure random transformer+  -> Rand g a+  -- ^ equivalent generator-passing computation+liftRand = RandT . state++-- | Unwrap a random monad computation as a function.+-- (The inverse of 'liftRand'.)+runRand+  :: Rand g a+  -- ^ generator-passing computation to execute+  -> g+  -- ^ initial generator+  -> (a, g)+  -- ^ return value and final generator+runRand t = runIdentity . runRandT t++-- | 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)@+evalRand+  :: Rand g a+  -- ^ generator-passing computation to execute+  -> g+  -- ^ initial generator+  -> a+  -- ^ return value of the random computation+evalRand t = runIdentity . evalRandT t++-- | 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)@+execRand+  :: Rand g a+  -- ^ generator-passing computation to execute+  -> g+  -- ^ initial generator+  -> g+  -- ^ final generator+execRand t = runIdentity . execRandT t++-- | Map both the return value and final generator of a computation using the+-- given function.+--+-- * @'runRand' ('mapRand' f m) = f . 'runRand' m@+mapRand :: ((a, g) -> (b, g)) -> Rand g a -> Rand g b+mapRand f = mapRandT (liftM f)++-- | @'withRand' f m@ executes action @m@ on a generator modified by applying @f@.+--+-- * @'withRand' f m = 'modify' f >> m@+withRand :: (g -> g) -> Rand g a -> Rand g a+withRand = withRandT++-- | 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.+newtype RandT g m a = RandT { unRandT :: LazyState.StateT g m a }+  deriving (Functor, Applicative, Alternative, Monad, MonadPlus, MonadTrans, MonadIO, MonadFix, MonadReader r, MonadWriter w)++-- | Construct a random monad computation from an impure function.+-- (The inverse of 'runRandT'.)+liftRandT+  :: (g -> m (a, g))+  -- ^ impure random transformer+  -> RandT g m a+  -- ^ equivalent generator-passing computation+liftRandT = RandT . LazyState.StateT++-- | Unwrap a random monad computation as an impure function.+-- (The inverse of 'liftRandT'.)+runRandT+  :: RandT g m a+  -- ^ generator-passing computation to execute+  -> g+  -- ^ initial generator+  -> m (a, g)+  -- ^ return value and final generator+runRandT = LazyState.runStateT . unRandT++-- | 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)@+evalRandT :: (Monad m) => RandT g m a -> g -> m a+evalRandT = LazyState.evalStateT . unRandT++-- | 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)@+execRandT :: (Monad m) => RandT g m a -> g -> m g+execRandT = LazyState.execStateT . unRandT++-- | Map both the return value and final generator of a computation using the+-- given function.+--+-- * @'runRandT' ('mapRandT' f m) = f . 'runRandT' m@+mapRandT :: (m (a, g) -> n (b, g)) -> RandT g m a -> RandT g n b+mapRandT f = RandT . LazyState.mapStateT f . unRandT++-- | @'withRandT' f m@ executes action @m@ on a generator modified by applying @f@.+--+-- * @'withRandT' f m = 'modify' f >> m@+withRandT :: (g -> g) -> RandT g m a -> RandT g m a+withRandT f = RandT . LazyState.withStateT f . unRandT++instance (MonadCont m) => MonadCont (RandT g m) where+  callCC = liftCallCC' callCC++instance (MonadError e m) => MonadError e (RandT g m) where+  throwError = lift . throwError+  catchError = liftCatch catchError++instance (MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s (RandT g m)++instance (RandomGen g, Monad m) => MonadRandom (RandT g m) where+  getRandomR lohi = RandT . state $ randomR lohi+  getRandom = RandT . state $ random+  getRandomRs lohi = RandT . state $ first (randomRs lohi) . split+  getRandoms = RandT . state $ first randoms . split++instance (RandomGen g, Monad m) => MonadSplit g (RandT g m) where+  getSplit = RandT . state $ split++instance (Monad m, RandomGen g) => MonadInterleave (RandT g m) where+  interleave (RandT m) = liftRandT $ \g -> case split g of+    (gl, gr) -> liftM (\p -> (fst p, gr)) $ LazyState.runStateT m gl++instance (MonadState s m) => MonadState s (RandT g m) where+  get = lift get+  put = lift . put++instance PrimMonad m => PrimMonad (RandT s m) where+  type PrimState (RandT s m) = PrimState m+  primitive = lift . primitive++instance Fail.MonadFail m => Fail.MonadFail (RandT g m) where+  fail = lift . Fail.fail++-- | 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+liftCallCC callCC_ f = RandT $ LazyState.liftCallCC callCC_ $ \c -> unRandT (f (RandT . c))++-- | 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").+liftCallCC' :: CallCC m (a, g) (b, g) -> CallCC (RandT g m) a b+liftCallCC' callCC_ f = RandT $ LazyState.liftCallCC' callCC_ $ \c -> unRandT (f (RandT . c))++-- | Lift a @catchE@ operation to the new monad.+liftCatch :: Catch e m (a, g) -> Catch e (RandT g m) a+liftCatch catchE_ m f = RandT $ LazyState.liftCatch catchE_ (unRandT m) (unRandT . f)++-- | Lift a @listen@ operation to the new monad.+liftListen :: (Monad m) => Listen w m (a, g) -> Listen w (RandT g m) a+liftListen listen_ m = RandT $ LazyState.liftListen listen_ (unRandT m)++-- | Lift a @pass@ operation to the new monad.+liftPass :: (Monad m) => Pass w m (a, g) -> Pass w (RandT g m) a+liftPass pass_ m = RandT $ LazyState.liftPass pass_ (unRandT m)++-- | Evaluate a random computation in the `IO` monad, splitting the global+-- standard generator to get a new one for the computation.+evalRandIO :: Rand StdGen a -> IO a+evalRandIO t = liftM (evalRand t) newStdGen++-- | Evaluate a random computation that is embedded in the `IO` monad,+-- splitting the global standard generator to get a new one for the+-- computation.+evalRandTIO :: (MonadIO m) => RandT StdGen m a -> m a+evalRandTIO t = liftIO newStdGen >>= evalRandT t++{- $examples++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)++-}

@@ -0,0 +1,286 @@+{-# LANGUAGE FlexibleInstances          #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE MultiParamTypeClasses      #-}+{-# LANGUAGE Trustworthy                #-}+{-# LANGUAGE TypeFamilies               #-}+{-# LANGUAGE UndecidableInstances       #-}++{- |+Module       :  Control.Monad.Trans.Random.Strict+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)++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".+-}++module Control.Monad.Trans.Random.Strict+  ( -- * The Rand monad transformer+    Rand,+    liftRand,+    runRand,+    evalRand,+    execRand,+    mapRand,+    withRand,+    evalRandIO,+    -- * The RandT monad transformer+    RandT,+    liftRandT,+    runRandT,+    evalRandT,+    execRandT,+    mapRandT,+    withRandT,+    evalRandTIO,+    -- * Lifting other operations+    liftCallCC,+    liftCallCC',+    liftCatch,+    liftListen,+    liftPass,+    -- * Examples+    -- ** Random monads+    -- $examples+  ) where++import           Control.Applicative+import           Control.Arrow                    (first)+import           Control.Monad+import           Control.Monad.Cont.Class+import           Control.Monad.Error.Class+import qualified Control.Monad.Fail               as Fail+import           Control.Monad.Fix+import           Control.Monad.IO.Class+import           Control.Monad.Primitive+import           Control.Monad.Random.Class+import           Control.Monad.RWS.Class+import           Control.Monad.Signatures+import           Control.Monad.Trans.Class+import qualified Control.Monad.Trans.State.Strict as StrictState+import           Data.Functor.Identity+import           System.Random++-- | 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.+type Rand g = RandT g Identity++-- | Construct a random monad computation from a function.+-- (The inverse of 'runRand'.)+liftRand+  :: (g -> (a, g))+  -- ^ pure random transformer+  -> Rand g a+  -- ^ equivalent generator-passing computation+liftRand = RandT . state++-- | Unwrap a random monad computation as a function.+-- (The inverse of 'liftRand'.)+runRand+  :: Rand g a+  -- ^ generator-passing computation to execute+  -> g+  -- ^ initial generator+  -> (a, g)+  -- ^ return value and final generator+runRand t = runIdentity . runRandT t++-- | 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)@+evalRand+  :: Rand g a+  -- ^ generator-passing computation to execute+  -> g+  -- ^ initial generator+  -> a+  -- ^ return value of the random computation+evalRand t = runIdentity . evalRandT t++-- | 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)@+execRand+  :: Rand g a+  -- ^ generator-passing computation to execute+  -> g+  -- ^ initial generator+  -> g+  -- ^ final generator+execRand t = runIdentity . execRandT t++-- | Map both the return value and final generator of a computation using the+-- given function.+--+-- * @'runRand' ('mapRand' f m) = f . 'runRand' m@+mapRand :: ((a, g) -> (b, g)) -> Rand g a -> Rand g b+mapRand f = mapRandT (liftM f)++-- | @'withRand' f m@ executes action @m@ on a generator modified by applying @f@.+--+-- * @'withRand' f m = 'modify' f >> m@+withRand :: (g -> g) -> Rand g a -> Rand g a+withRand = withRandT++-- | 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.+newtype RandT g m a = RandT { unRandT :: StrictState.StateT g m a }+  deriving (Functor, Applicative, Alternative, Monad, MonadPlus, MonadTrans, MonadIO, MonadFix, MonadReader r, MonadWriter w)++-- | Construct a random monad computation from an impure function.+-- (The inverse of 'runRandT'.)+liftRandT+  :: (g -> m (a, g))+  -- ^ impure random transformer+  -> RandT g m a+  -- ^ equivalent generator-passing computation+liftRandT = RandT . StrictState.StateT++-- | Unwrap a random monad computation as an impure function.+-- (The inverse of 'liftRandT'.)+runRandT+  :: RandT g m a+  -- ^ generator-passing computation to execute+  -> g+  -- ^ initial generator+  -> m (a, g)+  -- ^ return value and final generator+runRandT = StrictState.runStateT . unRandT++-- | 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)@+evalRandT :: (Monad m) => RandT g m a -> g -> m a+evalRandT = StrictState.evalStateT . unRandT++-- | 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)@+execRandT :: (Monad m) => RandT g m a -> g -> m g+execRandT = StrictState.execStateT . unRandT++-- | Map both the return value and final generator of a computation using the+-- given function.+--+-- * @'runRandT' ('mapRandT' f m) = f . 'runRandT' m@+mapRandT :: (m (a, g) -> n (b, g)) -> RandT g m a -> RandT g n b+mapRandT f = RandT . StrictState.mapStateT f . unRandT++-- | @'withRandT' f m@ executes action @m@ on a generator modified by applying @f@.+--+-- * @'withRandT' f m = 'modify' f >> m@+withRandT :: (g -> g) -> RandT g m a -> RandT g m a+withRandT f = RandT . StrictState.withStateT f . unRandT++instance (MonadCont m) => MonadCont (RandT g m) where+  callCC = liftCallCC' callCC++instance (MonadError e m) => MonadError e (RandT g m) where+  throwError = lift . throwError+  catchError = liftCatch catchError++instance (MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s (RandT g m)++instance (RandomGen g, Monad m) => MonadRandom (RandT g m) where+  getRandomR lohi = RandT . state $ randomR lohi+  getRandom = RandT . state $ random+  getRandomRs lohi = RandT . state $ first (randomRs lohi) . split+  getRandoms = RandT . state $ first randoms . split++instance (RandomGen g, Monad m) => MonadSplit g (RandT g m) where+  getSplit = RandT . state $ split++instance (Monad m, RandomGen g) => MonadInterleave (RandT g m) where+  interleave (RandT m) = liftRandT $ \g -> case split g of+    (gl, gr) -> liftM (\p -> (fst p, gr)) $ StrictState.runStateT m gl++instance (MonadState s m) => MonadState s (RandT g m) where+  get = lift get+  put = lift . put++instance PrimMonad m => PrimMonad (RandT s m) where+  type PrimState (RandT s m) = PrimState m+  primitive = lift . primitive++instance Fail.MonadFail m => Fail.MonadFail (RandT g m) where+  fail = lift . Fail.fail++-- | 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+liftCallCC callCC_ f = RandT $ StrictState.liftCallCC callCC_ $ \c -> unRandT (f (RandT . c))++-- | 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").+liftCallCC' :: CallCC m (a, g) (b, g) -> CallCC (RandT g m) a b+liftCallCC' callCC_ f = RandT $ StrictState.liftCallCC' callCC_ $ \c -> unRandT (f (RandT . c))++-- | Lift a @catchE@ operation to the new monad.+liftCatch :: Catch e m (a, g) -> Catch e (RandT g m) a+liftCatch catchE_ m f = RandT $ StrictState.liftCatch catchE_ (unRandT m) (unRandT . f)++-- | Lift a @listen@ operation to the new monad.+liftListen :: (Monad m) => Listen w m (a, g) -> Listen w (RandT g m) a+liftListen listen_ m = RandT $ StrictState.liftListen listen_ (unRandT m)++-- | Lift a @pass@ operation to the new monad.+liftPass :: (Monad m) => Pass w m (a, g) -> Pass w (RandT g m) a+liftPass pass_ m = RandT $ StrictState.liftPass pass_ (unRandT m)++-- | Evaluate a random computation in the `IO` monad, splitting the global+-- standard generator to get a new one for the computation.+evalRandIO :: Rand StdGen a -> IO a+evalRandIO t = liftM (evalRand t) newStdGen++-- | Evaluate a random computation that is embedded in the `IO` monad,+-- splitting the global standard generator to get a new one for the+-- computation.+evalRandTIO :: (MonadIO m) => RandT StdGen m a -> m a+evalRandTIO t = liftIO newStdGen >>= evalRandT t++{- $examples++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)++-}

@@ -1,38 +1,34 @@-MonadRandom library.-Copyright 2006-2007 Cale Gibbard.  All rights reserved.-Copyright 2006 Russell O'Connor, Dan Doel, Remi Turk.  All rights reserved.-Copyright 2007 Eric Kidd.  All rights reserved.--[This code was originally posted by Cale Gibbard to the Haskell Wiki,-remnants of which can be seen at:--http://web.archive.org/web/20070615071737/http://haskell.org/hawiki/MonadRandom--This code was relicensed from a 2-clause BSD license to the license below-by Cale Gibbard's statement at:--http://www.haskell.org/haskellwiki/User:CaleGibbard+Copyright (c) 2016, Brent Yorgey -The code was then moved to:+All rights reserved. -http://www.haskell.org/haskellwiki/NewMonads/MonadRandom+Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are met: -New additions by several people were provided under the implicit license at:+    * Redistributions of source code must retain the above copyright+      notice, this list of conditions and the following disclaimer. -http://www.haskell.org/haskellwiki/HaskellWiki:Copyrights+    * Redistributions in binary form must reproduce the above+      copyright notice, this list of conditions and the following+      disclaimer in the documentation and/or other materials provided+      with the distribution. -So, in theory, this license should apply to everything in this library.]+    * Neither the name of Brent Yorgey nor the names of other+      contributors may be used to endorse or promote products derived+      from this software without specific prior written permission. -Permission is hereby granted, free of charge, to any person obtaining this-work (the "Work"), to deal in the Work without restriction, including-without limitation the rights to use, copy, modify, merge, publish,-distribute, sublicense, and/or sell copies of the Work, and to permit-persons to whom the Work is furnished to do so.+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -THE WORK IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING-FROM, OUT OF OR IN CONNECTION WITH THE WORK OR THE USE OR OTHER DEALINGS IN-THE WORK.+Previous versions of this package were distributed under the simple+permissive license used on the Haskell Wiki; see OLD-LICENSE for+details.

@@ -1,8 +1,8 @@ name:                MonadRandom-version:             0.4.2.3+version:             0.5 synopsis:            Random-number generation monad. description:         Support for computations which consume random values.-license:             OtherLicense+license:             BSD3 license-file:        LICENSE author:              Cale Gibbard and others maintainer:          Brent Yorgey <byorgey@gmail.com>@@ -23,11 +23,21 @@   location: git://github.com/byorgey/MonadRandom.git  library-  exposed-modules:     Control.Monad.Random, Control.Monad.Random.Class-  build-depends:       base >= 2 && < 5,-                       transformers >= 0.3 && < 0.6,-                       transformers-compat >= 0.4 && < 0.6,-                       mtl >= 2.1 && < 2.3,-                       random+  exposed-modules:+    Control.Monad.Random,+    Control.Monad.Random.Class,+    Control.Monad.Random.Lazy,+    Control.Monad.Random.Strict,+    Control.Monad.Trans.Random,+    Control.Monad.Trans.Random.Lazy,+    Control.Monad.Trans.Random.Strict+  build-depends:+    base                >=2   && <5,+    transformers        >=0.3 && <0.6,+    transformers-compat >=0.4 && <0.6,+    mtl                 >=2.1 && <2.3,+    primitive           >=0.6 && <0.7,+    fail                >=4.9        ,+    random   ghc-options:         -Wall   default-language:    Haskell2010