    {-# LANGUAGE CPP                        #-}
    {-# 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,
        -- * StatefulGen interface
        RandGen(..),
        withRandGen,
        withRandGen_,
        -- * Examples
        -- ** Random monads
        -- $examples
      ) where

    import Control.Applicative ( Alternative )
    import Control.Arrow (first)
    import Control.Monad ( liftM, MonadPlus )
    import Control.Monad.Cont.Class (MonadCont(..))
    import Control.Monad.Error.Class ( MonadError(..) )
    import qualified Control.Monad.Fail as Fail
    import Control.Monad.Fix ( MonadFix )
    import Control.Monad.IO.Class ( MonadIO(..) )
    import Control.Monad.Primitive ( PrimMonad(..) )
    import Control.Monad.Random.Class ( MonadInterleave(..), MonadSplit(..), MonadRandom(..) )
    import Control.Monad.RWS.Class ( MonadState(..), MonadRWS, MonadReader, MonadWriter )
    import Control.Monad.Signatures ( Listen, Pass, CallCC, Catch )
    import Control.Monad.Trans.Class ( MonadTrans(..) )
    import qualified Control.Monad.Trans.State.Lazy as LazyState
    import Control.Monad.Trans.Random.Strict (RandGen(..))
    import Data.Functor.Identity ( Identity(runIdentity) )
    #if MIN_VERSION_random(1,2,0)
    import           System.Random.Stateful
    #else
    import           System.Random
    #endif

    -- | 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 :: forall g a. (g -> (a, g)) -> Rand g a
    liftRand = StateT g Identity a -> RandT g Identity a
    forall g (m :: * -> *) a. StateT g m a -> RandT g m a
    RandT (StateT g Identity a -> RandT g Identity a)
    -> ((g -> (a, g)) -> StateT g Identity a)
    -> (g -> (a, g))
    -> RandT g Identity a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (g -> (a, g)) -> StateT g Identity a
    forall a. (g -> (a, g)) -> StateT g Identity a
    forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
    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 :: forall g a. Rand g a -> g -> (a, g)
    runRand Rand g a
    t = Identity (a, g) -> (a, g)
    forall a. Identity a -> a
    runIdentity (Identity (a, g) -> (a, g))
    -> (g -> Identity (a, g)) -> g -> (a, g)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rand g a -> g -> Identity (a, g)
    forall g (m :: * -> *) a. RandT g m a -> g -> m (a, g)
    runRandT Rand g a
    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 :: forall g a. Rand g a -> g -> a
    evalRand Rand g a
    t = Identity a -> a
    forall a. Identity a -> a
    runIdentity (Identity a -> a) -> (g -> Identity a) -> g -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rand g a -> g -> Identity a
    forall (m :: * -> *) g a. Monad m => RandT g m a -> g -> m a
    evalRandT Rand g a
    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 :: forall g a. Rand g a -> g -> g
    execRand Rand g a
    t = Identity g -> g
    forall a. Identity a -> a
    runIdentity (Identity g -> g) -> (g -> Identity g) -> g -> g
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rand g a -> g -> Identity g
    forall (m :: * -> *) g a. Monad m => RandT g m a -> g -> m g
    execRandT Rand g a
    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 :: forall a g b. ((a, g) -> (b, g)) -> Rand g a -> Rand g b
    mapRand (a, g) -> (b, g)
    f = (Identity (a, g) -> Identity (b, g))
    -> RandT g Identity a -> RandT g Identity b
    forall (m :: * -> *) a g (n :: * -> *) b.
    (m (a, g) -> n (b, g)) -> RandT g m a -> RandT g n b
    mapRandT (((a, g) -> (b, g)) -> Identity (a, g) -> Identity (b, g)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (a, g) -> (b, g)
    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 :: forall g a. (g -> g) -> Rand g a -> Rand g a
    withRand = (g -> g) -> RandT g Identity a -> RandT g Identity a
    forall g (m :: * -> *) a. (g -> g) -> RandT g m a -> RandT g m a
    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 { forall g (m :: * -> *) a. RandT g m a -> StateT g m a
    unRandT :: LazyState.StateT g m a }
      deriving ((forall a b. (a -> b) -> RandT g m a -> RandT g m b)
    -> (forall a b. a -> RandT g m b -> RandT g m a)
    -> Functor (RandT g m)
    forall a b. a -> RandT g m b -> RandT g m a
    forall a b. (a -> b) -> RandT g m a -> RandT g m b
    forall g (m :: * -> *) a b.
    Functor m =>
    a -> RandT g m b -> RandT g m a
    forall g (m :: * -> *) a b.
    Functor m =>
    (a -> b) -> RandT g m a -> RandT g m b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall g (m :: * -> *) a b.
    Functor m =>
    (a -> b) -> RandT g m a -> RandT g m b
    fmap :: forall a b. (a -> b) -> RandT g m a -> RandT g m b
    $c<$ :: forall g (m :: * -> *) a b.
    Functor m =>
    a -> RandT g m b -> RandT g m a
    <$ :: forall a b. a -> RandT g m b -> RandT g m a
    Functor, Functor (RandT g m)
    Functor (RandT g m) =>
    (forall a. a -> RandT g m a)
    -> (forall a b. RandT g m (a -> b) -> RandT g m a -> RandT g m b)
    -> (forall a b c.
        (a -> b -> c) -> RandT g m a -> RandT g m b -> RandT g m c)
    -> (forall a b. RandT g m a -> RandT g m b -> RandT g m b)
    -> (forall a b. RandT g m a -> RandT g m b -> RandT g m a)
    -> Applicative (RandT g m)
    forall a. a -> RandT g m a
    forall a b. RandT g m a -> RandT g m b -> RandT g m a
    forall a b. RandT g m a -> RandT g m b -> RandT g m b
    forall a b. RandT g m (a -> b) -> RandT g m a -> RandT g m b
    forall a b c.
    (a -> b -> c) -> RandT g m a -> RandT g m b -> RandT g m c
    forall g (m :: * -> *). Monad m => Functor (RandT g m)
    forall g (m :: * -> *) a. Monad m => a -> RandT g m a
    forall g (m :: * -> *) a b.
    Monad m =>
    RandT g m a -> RandT g m b -> RandT g m a
    forall g (m :: * -> *) a b.
    Monad m =>
    RandT g m a -> RandT g m b -> RandT g m b
    forall g (m :: * -> *) a b.
    Monad m =>
    RandT g m (a -> b) -> RandT g m a -> RandT g m b
    forall g (m :: * -> *) a b c.
    Monad m =>
    (a -> b -> c) -> RandT g m a -> RandT g m b -> RandT g m c
    forall (f :: * -> *).
    Functor f =>
    (forall a. a -> f a)
    -> (forall a b. f (a -> b) -> f a -> f b)
    -> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
    -> (forall a b. f a -> f b -> f b)
    -> (forall a b. f a -> f b -> f a)
    -> Applicative f
    $cpure :: forall g (m :: * -> *) a. Monad m => a -> RandT g m a
    pure :: forall a. a -> RandT g m a
    $c<*> :: forall g (m :: * -> *) a b.
    Monad m =>
    RandT g m (a -> b) -> RandT g m a -> RandT g m b
    <*> :: forall a b. RandT g m (a -> b) -> RandT g m a -> RandT g m b
    $cliftA2 :: forall g (m :: * -> *) a b c.
    Monad m =>
    (a -> b -> c) -> RandT g m a -> RandT g m b -> RandT g m c
    liftA2 :: forall a b c.
    (a -> b -> c) -> RandT g m a -> RandT g m b -> RandT g m c
    $c*> :: forall g (m :: * -> *) a b.
    Monad m =>
    RandT g m a -> RandT g m b -> RandT g m b
    *> :: forall a b. RandT g m a -> RandT g m b -> RandT g m b
    $c<* :: forall g (m :: * -> *) a b.
    Monad m =>
    RandT g m a -> RandT g m b -> RandT g m a
    <* :: forall a b. RandT g m a -> RandT g m b -> RandT g m a
    Applicative, Applicative (RandT g m)
    Applicative (RandT g m) =>
    (forall a. RandT g m a)
    -> (forall a. RandT g m a -> RandT g m a -> RandT g m a)
    -> (forall a. RandT g m a -> RandT g m [a])
    -> (forall a. RandT g m a -> RandT g m [a])
    -> Alternative (RandT g m)
    forall a. RandT g m a
    forall a. RandT g m a -> RandT g m [a]
    forall a. RandT g m a -> RandT g m a -> RandT g m a
    forall g (m :: * -> *). MonadPlus m => Applicative (RandT g m)
    forall g (m :: * -> *) a. MonadPlus m => RandT g m a
    forall g (m :: * -> *) a.
    MonadPlus m =>
    RandT g m a -> RandT g m [a]
    forall g (m :: * -> *) a.
    MonadPlus m =>
    RandT g m a -> RandT g m a -> RandT g m a
    forall (f :: * -> *).
    Applicative f =>
    (forall a. f a)
    -> (forall a. f a -> f a -> f a)
    -> (forall a. f a -> f [a])
    -> (forall a. f a -> f [a])
    -> Alternative f
    $cempty :: forall g (m :: * -> *) a. MonadPlus m => RandT g m a
    empty :: forall a. RandT g m a
    $c<|> :: forall g (m :: * -> *) a.
    MonadPlus m =>
    RandT g m a -> RandT g m a -> RandT g m a
    <|> :: forall a. RandT g m a -> RandT g m a -> RandT g m a
    $csome :: forall g (m :: * -> *) a.
    MonadPlus m =>
    RandT g m a -> RandT g m [a]
    some :: forall a. RandT g m a -> RandT g m [a]
    $cmany :: forall g (m :: * -> *) a.
    MonadPlus m =>
    RandT g m a -> RandT g m [a]
    many :: forall a. RandT g m a -> RandT g m [a]
    Alternative, Applicative (RandT g m)
    Applicative (RandT g m) =>
    (forall a b. RandT g m a -> (a -> RandT g m b) -> RandT g m b)
    -> (forall a b. RandT g m a -> RandT g m b -> RandT g m b)
    -> (forall a. a -> RandT g m a)
    -> Monad (RandT g m)
    forall a. a -> RandT g m a
    forall a b. RandT g m a -> RandT g m b -> RandT g m b
    forall a b. RandT g m a -> (a -> RandT g m b) -> RandT g m b
    forall g (m :: * -> *). Monad m => Applicative (RandT g m)
    forall g (m :: * -> *) a. Monad m => a -> RandT g m a
    forall g (m :: * -> *) a b.
    Monad m =>
    RandT g m a -> RandT g m b -> RandT g m b
    forall g (m :: * -> *) a b.
    Monad m =>
    RandT g m a -> (a -> RandT g m b) -> RandT g m b
    forall (m :: * -> *).
    Applicative m =>
    (forall a b. m a -> (a -> m b) -> m b)
    -> (forall a b. m a -> m b -> m b)
    -> (forall a. a -> m a)
    -> Monad m
    $c>>= :: forall g (m :: * -> *) a b.
    Monad m =>
    RandT g m a -> (a -> RandT g m b) -> RandT g m b
    >>= :: forall a b. RandT g m a -> (a -> RandT g m b) -> RandT g m b
    $c>> :: forall g (m :: * -> *) a b.
    Monad m =>
    RandT g m a -> RandT g m b -> RandT g m b
    >> :: forall a b. RandT g m a -> RandT g m b -> RandT g m b
    $creturn :: forall g (m :: * -> *) a. Monad m => a -> RandT g m a
    return :: forall a. a -> RandT g m a
    Monad, Monad (RandT g m)
    Alternative (RandT g m)
    (Alternative (RandT g m), Monad (RandT g m)) =>
    (forall a. RandT g m a)
    -> (forall a. RandT g m a -> RandT g m a -> RandT g m a)
    -> MonadPlus (RandT g m)
    forall a. RandT g m a
    forall a. RandT g m a -> RandT g m a -> RandT g m a
    forall g (m :: * -> *). MonadPlus m => Monad (RandT g m)
    forall g (m :: * -> *). MonadPlus m => Alternative (RandT g m)
    forall g (m :: * -> *) a. MonadPlus m => RandT g m a
    forall g (m :: * -> *) a.
    MonadPlus m =>
    RandT g m a -> RandT g m a -> RandT g m a
    forall (m :: * -> *).
    (Alternative m, Monad m) =>
    (forall a. m a) -> (forall a. m a -> m a -> m a) -> MonadPlus m
    $cmzero :: forall g (m :: * -> *) a. MonadPlus m => RandT g m a
    mzero :: forall a. RandT g m a
    $cmplus :: forall g (m :: * -> *) a.
    MonadPlus m =>
    RandT g m a -> RandT g m a -> RandT g m a
    mplus :: forall a. RandT g m a -> RandT g m a -> RandT g m a
    MonadPlus, (forall (m :: * -> *). Monad m => Monad (RandT g m)) =>
    (forall (m :: * -> *) a. Monad m => m a -> RandT g m a)
    -> MonadTrans (RandT g)
    forall g (m :: * -> *). Monad m => Monad (RandT g m)
    forall g (m :: * -> *) a. Monad m => m a -> RandT g m a
    forall (m :: * -> *). Monad m => Monad (RandT g m)
    forall (m :: * -> *) a. Monad m => m a -> RandT g m a
    forall (t :: (* -> *) -> * -> *).
    (forall (m :: * -> *). Monad m => Monad (t m)) =>
    (forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
    $clift :: forall g (m :: * -> *) a. Monad m => m a -> RandT g m a
    lift :: forall (m :: * -> *) a. Monad m => m a -> RandT g m a
    MonadTrans, Monad (RandT g m)
    Monad (RandT g m) =>
    (forall a. IO a -> RandT g m a) -> MonadIO (RandT g m)
    forall a. IO a -> RandT g m a
    forall g (m :: * -> *). MonadIO m => Monad (RandT g m)
    forall g (m :: * -> *) a. MonadIO m => IO a -> RandT g m a
    forall (m :: * -> *).
    Monad m =>
    (forall a. IO a -> m a) -> MonadIO m
    $cliftIO :: forall g (m :: * -> *) a. MonadIO m => IO a -> RandT g m a
    liftIO :: forall a. IO a -> RandT g m a
    MonadIO, Monad (RandT g m)
    Monad (RandT g m) =>
    (forall a. (a -> RandT g m a) -> RandT g m a)
    -> MonadFix (RandT g m)
    forall a. (a -> RandT g m a) -> RandT g m a
    forall g (m :: * -> *). MonadFix m => Monad (RandT g m)
    forall g (m :: * -> *) a.
    MonadFix m =>
    (a -> RandT g m a) -> RandT g m a
    forall (m :: * -> *).
    Monad m =>
    (forall a. (a -> m a) -> m a) -> MonadFix m
    $cmfix :: forall g (m :: * -> *) a.
    MonadFix m =>
    (a -> RandT g m a) -> RandT g m a
    mfix :: forall a. (a -> RandT g m a) -> RandT g m a
    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 :: forall g (m :: * -> *) a. (g -> m (a, g)) -> RandT g m a
    liftRandT = StateT g m a -> RandT g m a
    forall g (m :: * -> *) a. StateT g m a -> RandT g m a
    RandT (StateT g m a -> RandT g m a)
    -> ((g -> m (a, g)) -> StateT g m a)
    -> (g -> m (a, g))
    -> RandT g m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (g -> m (a, g)) -> StateT g m a
    forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
    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 :: forall g (m :: * -> *) a. RandT g m a -> g -> m (a, g)
    runRandT = StateT g m a -> g -> m (a, g)
    forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
    LazyState.runStateT (StateT g m a -> g -> m (a, g))
    -> (RandT g m a -> StateT g m a) -> RandT g m a -> g -> m (a, g)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . RandT g m a -> StateT g m a
    forall g (m :: * -> *) a. RandT g m a -> StateT g m a
    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 :: forall (m :: * -> *) g a. Monad m => RandT g m a -> g -> m a
    evalRandT = StateT g m a -> g -> m a
    forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
    LazyState.evalStateT (StateT g m a -> g -> m a)
    -> (RandT g m a -> StateT g m a) -> RandT g m a -> g -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . RandT g m a -> StateT g m a
    forall g (m :: * -> *) a. RandT g m a -> StateT g m a
    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 :: forall (m :: * -> *) g a. Monad m => RandT g m a -> g -> m g
    execRandT = StateT g m a -> g -> m g
    forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m s
    LazyState.execStateT (StateT g m a -> g -> m g)
    -> (RandT g m a -> StateT g m a) -> RandT g m a -> g -> m g
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . RandT g m a -> StateT g m a
    forall g (m :: * -> *) a. RandT g m a -> StateT g m a
    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 :: forall (m :: * -> *) a g (n :: * -> *) b.
    (m (a, g) -> n (b, g)) -> RandT g m a -> RandT g n b
    mapRandT m (a, g) -> n (b, g)
    f = StateT g n b -> RandT g n b
    forall g (m :: * -> *) a. StateT g m a -> RandT g m a
    RandT (StateT g n b -> RandT g n b)
    -> (RandT g m a -> StateT g n b) -> RandT g m a -> RandT g n b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (m (a, g) -> n (b, g)) -> StateT g m a -> StateT g n b
    forall (m :: * -> *) a s (n :: * -> *) b.
    (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
    LazyState.mapStateT m (a, g) -> n (b, g)
    f (StateT g m a -> StateT g n b)
    -> (RandT g m a -> StateT g m a) -> RandT g m a -> StateT g n b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . RandT g m a -> StateT g m a
    forall g (m :: * -> *) a. RandT g m a -> StateT g m a
    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 :: forall g (m :: * -> *) a. (g -> g) -> RandT g m a -> RandT g m a
    withRandT g -> g
    f = StateT g m a -> RandT g m a
    forall g (m :: * -> *) a. StateT g m a -> RandT g m a
    RandT (StateT g m a -> RandT g m a)
    -> (RandT g m a -> StateT g m a) -> RandT g m a -> RandT g m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (g -> g) -> StateT g m a -> StateT g m a
    forall s (m :: * -> *) a. (s -> s) -> StateT s m a -> StateT s m a
    LazyState.withStateT g -> g
    f (StateT g m a -> StateT g m a)
    -> (RandT g m a -> StateT g m a) -> RandT g m a -> StateT g m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . RandT g m a -> StateT g m a
    forall g (m :: * -> *) a. RandT g m a -> StateT g m a
    unRandT

    instance (MonadCont m) => MonadCont (RandT g m) where
      callCC :: forall a b. ((a -> RandT g m b) -> RandT g m a) -> RandT g m a
    callCC = CallCC m (a, g) (b, g) -> CallCC (RandT g m) a b
    forall (m :: * -> *) a g b.
    CallCC m (a, g) (b, g) -> CallCC (RandT g m) a b
    liftCallCC' CallCC m (a, g) (b, g)
    forall a b. ((a -> m b) -> m a) -> m a
    forall (m :: * -> *) a b. MonadCont m => ((a -> m b) -> m a) -> m a
    callCC

    instance (MonadError e m) => MonadError e (RandT g m) where
      throwError :: forall a. e -> RandT g m a
    throwError = m a -> RandT g m a
    forall (m :: * -> *) a. Monad m => m a -> RandT g m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> RandT g m a) -> (e -> m a) -> e -> RandT g m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . e -> m a
    forall a. e -> m a
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError
      catchError :: forall a. RandT g m a -> (e -> RandT g m a) -> RandT g m a
    catchError = Catch e m (a, g) -> Catch e (RandT g m) a
    forall e (m :: * -> *) a g.
    Catch e m (a, g) -> Catch e (RandT g m) a
    liftCatch Catch e m (a, g)
    forall a. m a -> (e -> m a) -> m a
    forall e (m :: * -> *) a.
    MonadError e m =>
    m a -> (e -> m a) -> m a
    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 :: forall a. Random a => (a, a) -> RandT g m a
    getRandomR (a, a)
    lohi = StateT g m a -> RandT g m a
    forall g (m :: * -> *) a. StateT g m a -> RandT g m a
    RandT (StateT g m a -> RandT g m a)
    -> ((g -> (a, g)) -> StateT g m a) -> (g -> (a, g)) -> RandT g m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (g -> (a, g)) -> StateT g m a
    forall a. (g -> (a, g)) -> StateT g m a
    forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
    state ((g -> (a, g)) -> RandT g m a) -> (g -> (a, g)) -> RandT g m a
    forall a b. (a -> b) -> a -> b
    $ (a, a) -> g -> (a, g)
    forall g. RandomGen g => (a, a) -> g -> (a, g)
    forall a g. (Random a, RandomGen g) => (a, a) -> g -> (a, g)
    randomR (a, a)
    lohi
      getRandom :: forall a. Random a => RandT g m a
    getRandom = StateT g m a -> RandT g m a
    forall g (m :: * -> *) a. StateT g m a -> RandT g m a
    RandT (StateT g m a -> RandT g m a)
    -> ((g -> (a, g)) -> StateT g m a) -> (g -> (a, g)) -> RandT g m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (g -> (a, g)) -> StateT g m a
    forall a. (g -> (a, g)) -> StateT g m a
    forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
    state ((g -> (a, g)) -> RandT g m a) -> (g -> (a, g)) -> RandT g m a
    forall a b. (a -> b) -> a -> b
    $ g -> (a, g)
    forall g. RandomGen g => g -> (a, g)
    forall a g. (Random a, RandomGen g) => g -> (a, g)
    random
      getRandomRs :: forall a. Random a => (a, a) -> RandT g m [a]
    getRandomRs (a, a)
    lohi = StateT g m [a] -> RandT g m [a]
    forall g (m :: * -> *) a. StateT g m a -> RandT g m a
    RandT (StateT g m [a] -> RandT g m [a])
    -> ((g -> ([a], g)) -> StateT g m [a])
    -> (g -> ([a], g))
    -> RandT g m [a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (g -> ([a], g)) -> StateT g m [a]
    forall a. (g -> (a, g)) -> StateT g m a
    forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
    state ((g -> ([a], g)) -> RandT g m [a])
    -> (g -> ([a], g)) -> RandT g m [a]
    forall a b. (a -> b) -> a -> b
    $ (g -> [a]) -> (g, g) -> ([a], g)
    forall b c d. (b -> c) -> (b, d) -> (c, d)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (b, d) (c, d)
    first ((a, a) -> g -> [a]
    forall g. RandomGen g => (a, a) -> g -> [a]
    forall a g. (Random a, RandomGen g) => (a, a) -> g -> [a]
    randomRs (a, a)
    lohi) ((g, g) -> ([a], g)) -> (g -> (g, g)) -> g -> ([a], g)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . g -> (g, g)
    forall g. RandomGen g => g -> (g, g)
    split
      getRandoms :: forall a. Random a => RandT g m [a]
    getRandoms = StateT g m [a] -> RandT g m [a]
    forall g (m :: * -> *) a. StateT g m a -> RandT g m a
    RandT (StateT g m [a] -> RandT g m [a])
    -> ((g -> ([a], g)) -> StateT g m [a])
    -> (g -> ([a], g))
    -> RandT g m [a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (g -> ([a], g)) -> StateT g m [a]
    forall a. (g -> (a, g)) -> StateT g m a
    forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
    state ((g -> ([a], g)) -> RandT g m [a])
    -> (g -> ([a], g)) -> RandT g m [a]
    forall a b. (a -> b) -> a -> b
    $ (g -> [a]) -> (g, g) -> ([a], g)
    forall b c d. (b -> c) -> (b, d) -> (c, d)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (b, d) (c, d)
    first g -> [a]
    forall g. RandomGen g => g -> [a]
    forall a g. (Random a, RandomGen g) => g -> [a]
    randoms ((g, g) -> ([a], g)) -> (g -> (g, g)) -> g -> ([a], g)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . g -> (g, g)
    forall g. RandomGen g => g -> (g, g)
    split

    instance (RandomGen g, Monad m) => MonadSplit g (RandT g m) where
      getSplit :: RandT g m g
    getSplit = StateT g m g -> RandT g m g
    forall g (m :: * -> *) a. StateT g m a -> RandT g m a
    RandT (StateT g m g -> RandT g m g)
    -> ((g -> (g, g)) -> StateT g m g) -> (g -> (g, g)) -> RandT g m g
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (g -> (g, g)) -> StateT g m g
    forall a. (g -> (a, g)) -> StateT g m a
    forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
    state ((g -> (g, g)) -> RandT g m g) -> (g -> (g, g)) -> RandT g m g
    forall a b. (a -> b) -> a -> b
    $ g -> (g, g)
    forall g. RandomGen g => g -> (g, g)
    split

    instance (Monad m, RandomGen g) => MonadInterleave (RandT g m) where
      interleave :: forall a. RandT g m a -> RandT g m a
    interleave (RandT StateT g m a
    m) = (g -> m (a, g)) -> RandT g m a
    forall g (m :: * -> *) a. (g -> m (a, g)) -> RandT g m a
    liftRandT ((g -> m (a, g)) -> RandT g m a) -> (g -> m (a, g)) -> RandT g m a
    forall a b. (a -> b) -> a -> b
    $ \g
    g -> case g -> (g, g)
    forall g. RandomGen g => g -> (g, g)
    split g
    g of
        (g
    gl, g
    gr) -> ((a, g) -> (a, g)) -> m (a, g) -> m (a, g)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (\(a, g)
    p -> ((a, g) -> a
    forall a b. (a, b) -> a
    fst (a, g)
    p, g
    gr)) (m (a, g) -> m (a, g)) -> m (a, g) -> m (a, g)
    forall a b. (a -> b) -> a -> b
    $ StateT g m a -> g -> m (a, g)
    forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
    LazyState.runStateT StateT g m a
    m g
    gl

    instance (MonadState s m) => MonadState s (RandT g m) where
      get :: RandT g m s
    get = m s -> RandT g m s
    forall (m :: * -> *) a. Monad m => m a -> RandT g m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m s
    forall s (m :: * -> *). MonadState s m => m s
    get
      put :: s -> RandT g m ()
    put = m () -> RandT g m ()
    forall (m :: * -> *) a. Monad m => m a -> RandT g m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m () -> RandT g m ()) -> (s -> m ()) -> s -> RandT g m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . s -> m ()
    forall s (m :: * -> *). MonadState s m => s -> m ()
    put

    instance PrimMonad m => PrimMonad (RandT s m) where
      type PrimState (RandT s m) = PrimState m
      primitive :: forall a.
    (State# (PrimState (RandT s m))
     -> (# State# (PrimState (RandT s m)), a #))
    -> RandT s m a
    primitive = m a -> RandT s m a
    forall (m :: * -> *) a. Monad m => m a -> RandT s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> RandT s m a)
    -> ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #))
    -> RandT s m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive

    instance Fail.MonadFail m => Fail.MonadFail (RandT g m) where
      fail :: forall a. String -> RandT g m a
    fail = m a -> RandT g m a
    forall (m :: * -> *) a. Monad m => m a -> RandT g m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> RandT g m a) -> (String -> m a) -> String -> RandT g m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> m a
    forall a. String -> m a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    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 :: forall (m :: * -> *) a g b.
    CallCC m (a, g) (b, g) -> CallCC (RandT g m) a b
    liftCallCC CallCC m (a, g) (b, g)
    callCC_ (a -> RandT g m b) -> RandT g m a
    f = StateT g m a -> RandT g m a
    forall g (m :: * -> *) a. StateT g m a -> RandT g m a
    RandT (StateT g m a -> RandT g m a) -> StateT g m a -> RandT g m a
    forall a b. (a -> b) -> a -> b
    $ CallCC m (a, g) (b, g) -> CallCC (StateT g m) a b
    forall (m :: * -> *) a s b.
    CallCC m (a, s) (b, s) -> CallCC (StateT s m) a b
    LazyState.liftCallCC CallCC m (a, g) (b, g)
    callCC_ CallCC (StateT g m) a b -> CallCC (StateT g m) a b
    forall a b. (a -> b) -> a -> b
    $ \a -> StateT g m b
    c -> RandT g m a -> StateT g m a
    forall g (m :: * -> *) a. RandT g m a -> StateT g m a
    unRandT ((a -> RandT g m b) -> RandT g m a
    f (StateT g m b -> RandT g m b
    forall g (m :: * -> *) a. StateT g m a -> RandT g m a
    RandT (StateT g m b -> RandT g m b)
    -> (a -> StateT g m b) -> a -> RandT g m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> StateT g m b
    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' :: forall (m :: * -> *) a g b.
    CallCC m (a, g) (b, g) -> CallCC (RandT g m) a b
    liftCallCC' CallCC m (a, g) (b, g)
    callCC_ (a -> RandT g m b) -> RandT g m a
    f = StateT g m a -> RandT g m a
    forall g (m :: * -> *) a. StateT g m a -> RandT g m a
    RandT (StateT g m a -> RandT g m a) -> StateT g m a -> RandT g m a
    forall a b. (a -> b) -> a -> b
    $ CallCC m (a, g) (b, g) -> CallCC (StateT g m) a b
    forall (m :: * -> *) a s b.
    CallCC m (a, s) (b, s) -> CallCC (StateT s m) a b
    LazyState.liftCallCC' CallCC m (a, g) (b, g)
    callCC_ CallCC (StateT g m) a b -> CallCC (StateT g m) a b
    forall a b. (a -> b) -> a -> b
    $ \a -> StateT g m b
    c -> RandT g m a -> StateT g m a
    forall g (m :: * -> *) a. RandT g m a -> StateT g m a
    unRandT ((a -> RandT g m b) -> RandT g m a
    f (StateT g m b -> RandT g m b
    forall g (m :: * -> *) a. StateT g m a -> RandT g m a
    RandT (StateT g m b -> RandT g m b)
    -> (a -> StateT g m b) -> a -> RandT g m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> StateT g m b
    c))

    -- | Lift a @catchE@ operation to the new monad.
    liftCatch :: Catch e m (a, g) -> Catch e (RandT g m) a
    liftCatch :: forall e (m :: * -> *) a g.
    Catch e m (a, g) -> Catch e (RandT g m) a
    liftCatch Catch e m (a, g)
    catchE_ RandT g m a
    m e -> RandT g m a
    f = StateT g m a -> RandT g m a
    forall g (m :: * -> *) a. StateT g m a -> RandT g m a
    RandT (StateT g m a -> RandT g m a) -> StateT g m a -> RandT g m a
    forall a b. (a -> b) -> a -> b
    $ Catch e m (a, g) -> Catch e (StateT g m) a
    forall e (m :: * -> *) a s.
    Catch e m (a, s) -> Catch e (StateT s m) a
    LazyState.liftCatch Catch e m (a, g)
    catchE_ (RandT g m a -> StateT g m a
    forall g (m :: * -> *) a. RandT g m a -> StateT g m a
    unRandT RandT g m a
    m) (RandT g m a -> StateT g m a
    forall g (m :: * -> *) a. RandT g m a -> StateT g m a
    unRandT (RandT g m a -> StateT g m a)
    -> (e -> RandT g m a) -> e -> StateT g m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . e -> RandT g m a
    f)

    -- | Lift a @listen@ operation to the new monad.
    liftListen :: (Monad m) => Listen w m (a, g) -> Listen w (RandT g m) a
    liftListen :: forall (m :: * -> *) w a g.
    Monad m =>
    Listen w m (a, g) -> Listen w (RandT g m) a
    liftListen Listen w m (a, g)
    listen_ RandT g m a
    m = StateT g m (a, w) -> RandT g m (a, w)
    forall g (m :: * -> *) a. StateT g m a -> RandT g m a
    RandT (StateT g m (a, w) -> RandT g m (a, w))
    -> StateT g m (a, w) -> RandT g m (a, w)
    forall a b. (a -> b) -> a -> b
    $ Listen w m (a, g) -> Listen w (StateT g m) a
    forall (m :: * -> *) w a s.
    Monad m =>
    Listen w m (a, s) -> Listen w (StateT s m) a
    LazyState.liftListen Listen w m (a, g)
    listen_ (RandT g m a -> StateT g m a
    forall g (m :: * -> *) a. RandT g m a -> StateT g m a
    unRandT RandT g m a
    m)

    -- | Lift a @pass@ operation to the new monad.
    liftPass :: (Monad m) => Pass w m (a, g) -> Pass w (RandT g m) a
    liftPass :: forall (m :: * -> *) w a g.
    Monad m =>
    Pass w m (a, g) -> Pass w (RandT g m) a
    liftPass Pass w m (a, g)
    pass_ RandT g m (a, w -> w)
    m = StateT g m a -> RandT g m a
    forall g (m :: * -> *) a. StateT g m a -> RandT g m a
    RandT (StateT g m a -> RandT g m a) -> StateT g m a -> RandT g m a
    forall a b. (a -> b) -> a -> b
    $ Pass w m (a, g) -> Pass w (StateT g m) a
    forall (m :: * -> *) w a s.
    Monad m =>
    Pass w m (a, s) -> Pass w (StateT s m) a
    LazyState.liftPass Pass w m (a, g)
    pass_ (RandT g m (a, w -> w) -> StateT g m (a, w -> w)
    forall g (m :: * -> *) a. RandT g m a -> StateT g m a
    unRandT RandT g m (a, w -> w)
    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 :: forall a. Rand StdGen a -> IO a
    evalRandIO Rand StdGen a
    t = (StdGen -> a) -> IO StdGen -> IO a
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Rand StdGen a -> StdGen -> a
    forall g a. Rand g a -> g -> a
    evalRand Rand StdGen a
    t) IO StdGen
    forall (m :: * -> *). MonadIO m => m StdGen
    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 :: forall (m :: * -> *) a. MonadIO m => RandT StdGen m a -> m a
    evalRandTIO RandT StdGen m a
    t = IO StdGen -> m StdGen
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO IO StdGen
    forall (m :: * -> *). MonadIO m => m StdGen
    newStdGen m StdGen -> (StdGen -> m a) -> m a
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= RandT StdGen m a -> StdGen -> m a
    forall (m :: * -> *) g a. Monad m => RandT g m a -> g -> m a
    evalRandT RandT StdGen m a
    t

    #if MIN_VERSION_random(1,2,0)
    -- |
    --
    -- @since 0.5.3
    instance (Monad m, RandomGen g) => StatefulGen (RandGen g) (RandT g m) where
      uniformWord32R :: Word32 -> RandGen g -> RandT g m Word32
    uniformWord32R Word32
    r = (g -> (Word32, g)) -> RandGen g -> RandT g m Word32
    forall (m :: * -> *) g a.
    Applicative m =>
    (g -> (a, g)) -> RandGen g -> RandT g m a
    applyRandT (Word32 -> g -> (Word32, g)
    forall g. RandomGen g => Word32 -> g -> (Word32, g)
    genWord32R Word32
    r)
      uniformWord64R :: Word64 -> RandGen g -> RandT g m Word64
    uniformWord64R Word64
    r = (g -> (Word64, g)) -> RandGen g -> RandT g m Word64
    forall (m :: * -> *) g a.
    Applicative m =>
    (g -> (a, g)) -> RandGen g -> RandT g m a
    applyRandT (Word64 -> g -> (Word64, g)
    forall g. RandomGen g => Word64 -> g -> (Word64, g)
    genWord64R Word64
    r)
      uniformWord8 :: RandGen g -> RandT g m Word8
    uniformWord8 = (g -> (Word8, g)) -> RandGen g -> RandT g m Word8
    forall (m :: * -> *) g a.
    Applicative m =>
    (g -> (a, g)) -> RandGen g -> RandT g m a
    applyRandT g -> (Word8, g)
    forall g. RandomGen g => g -> (Word8, g)
    genWord8
      uniformWord16 :: RandGen g -> RandT g m Word16
    uniformWord16 = (g -> (Word16, g)) -> RandGen g -> RandT g m Word16
    forall (m :: * -> *) g a.
    Applicative m =>
    (g -> (a, g)) -> RandGen g -> RandT g m a
    applyRandT g -> (Word16, g)
    forall g. RandomGen g => g -> (Word16, g)
    genWord16
      uniformWord32 :: RandGen g -> RandT g m Word32
    uniformWord32 = (g -> (Word32, g)) -> RandGen g -> RandT g m Word32
    forall (m :: * -> *) g a.
    Applicative m =>
    (g -> (a, g)) -> RandGen g -> RandT g m a
    applyRandT g -> (Word32, g)
    forall g. RandomGen g => g -> (Word32, g)
    genWord32
      uniformWord64 :: RandGen g -> RandT g m Word64
    uniformWord64 = (g -> (Word64, g)) -> RandGen g -> RandT g m Word64
    forall (m :: * -> *) g a.
    Applicative m =>
    (g -> (a, g)) -> RandGen g -> RandT g m a
    applyRandT g -> (Word64, g)
    forall g. RandomGen g => g -> (Word64, g)
    genWord64
    #if MIN_VERSION_random(1,3,0)
      uniformByteArrayM pinned sz = applyRandT $ uniformByteArray pinned sz
    #else
      uniformShortByteString :: Int -> RandGen g -> RandT g m ShortByteString
    uniformShortByteString Int
    n = (g -> (ShortByteString, g))
    -> RandGen g -> RandT g m ShortByteString
    forall (m :: * -> *) g a.
    Applicative m =>
    (g -> (a, g)) -> RandGen g -> RandT g m a
    applyRandT (Int -> g -> (ShortByteString, g)
    forall g. RandomGen g => Int -> g -> (ShortByteString, g)
    genShortByteString Int
    n)
    #endif

    -- |
    --
    -- @since 0.5.3
    instance (Monad m, RandomGen g) => RandomGenM (RandGen g) g (RandT g m) where
      applyRandomGenM :: forall a. (g -> (a, g)) -> RandGen g -> RandT g m a
    applyRandomGenM = (g -> (a, g)) -> RandGen g -> RandT g m a
    forall (m :: * -> *) g a.
    Applicative m =>
    (g -> (a, g)) -> RandGen g -> RandT g m a
    applyRandT

    applyRandT :: Applicative m => (g -> (a, g)) -> RandGen g -> RandT g m a
    applyRandT :: forall (m :: * -> *) g a.
    Applicative m =>
    (g -> (a, g)) -> RandGen g -> RandT g m a
    applyRandT g -> (a, g)
    f RandGen g
    _ = (g -> m (a, g)) -> RandT g m a
    forall g (m :: * -> *) a. (g -> m (a, g)) -> RandT g m a
    liftRandT ((a, g) -> m (a, g)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ((a, g) -> m (a, g)) -> (g -> (a, g)) -> g -> m (a, g)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . g -> (a, g)
    f)
    #endif

    -- | A `RandT` runner that allows using it with `StatefulGen` restricted actions. Returns
    -- the outcome of random computation and the new pseudo-random-number generator
    --
    -- >>> withRandGen (mkStdGen 2021) uniformM :: IO (Int, StdGen)
    -- (6070831465987696718,StdGen {unStdGen = SMGen 4687568268719557181 4805600293067301895})
    --
    -- @since 0.5.3
    withRandGen ::
         g
      -- ^ initial generator
      -> (RandGen g -> RandT g m a)
      -> m (a, g)
      -- ^ return value and final generator
    withRandGen :: forall g (m :: * -> *) a.
    g -> (RandGen g -> RandT g m a) -> m (a, g)
    withRandGen g
    g RandGen g -> RandT g m a
    action = RandT g m a -> g -> m (a, g)
    forall g (m :: * -> *) a. RandT g m a -> g -> m (a, g)
    runRandT (RandGen g -> RandT g m a
    action RandGen g
    forall g. RandGen g
    RandGen) g
    g

    -- | Same as `withRandGen`, but discards the resulting generator.
    --
    -- >>> withRandGen_ (mkStdGen 2021) uniformM :: IO Int
    -- 6070831465987696718
    --
    -- @since 0.5.3
    withRandGen_ ::
         Monad m
      => g
      -- ^ initial generator
      -> (RandGen g -> RandT g m a)
      -> m a
      -- ^ return value and final generator
    withRandGen_ :: forall (m :: * -> *) g a.
    Monad m =>
    g -> (RandGen g -> RandT g m a) -> m a
    withRandGen_ g
    g RandGen g -> RandT g m a
    action = RandT g m a -> g -> m a
    forall (m :: * -> *) g a. Monad m => RandT g m a -> g -> m a
    evalRandT (RandGen g -> RandT g m a
    action RandGen g
    forall g. RandGen g
    RandGen) g
    g

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

    -}