{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses #-}
{-# LANGUAGE UndecidableInstances, DeriveFunctor      #-}
{-# LANGUAGE CPP #-}
module Control.Monad.Gen
       ( GenT
       , Gen
       , module Control.Monad.Gen.Class
       , Successor
       , successor
       , runGenT
       , runGen
       , runGenTWith
       , runGenWith
       , runGenTFrom
       , runGenFrom) where
#if MIN_VERSION_mtl(2, 2, 1)
import Control.Monad.Except
#else
import Control.Monad.Error
#endif

import Control.Applicative
import Control.Monad.Cont.Class
import Control.Monad.Gen.Class
import Control.Monad.Identity
import Control.Monad.Reader
import Control.Monad.State
import Control.Monad.Writer.Class

newtype Successor a = Successor {Successor a -> a -> a
suc :: a -> a}

-- | The monad transformer for generating fresh values.
data GenT e m a = GenT {GenT e m a -> ReaderT (Successor e) (StateT e m) a
unGenT :: ReaderT (Successor e) (StateT e m) a}
                   deriving(a -> GenT e m b -> GenT e m a
(a -> b) -> GenT e m a -> GenT e m b
(forall a b. (a -> b) -> GenT e m a -> GenT e m b)
-> (forall a b. a -> GenT e m b -> GenT e m a)
-> Functor (GenT e m)
forall a b. a -> GenT e m b -> GenT e m a
forall a b. (a -> b) -> GenT e m a -> GenT e m b
forall e (m :: * -> *) a b.
Functor m =>
a -> GenT e m b -> GenT e m a
forall e (m :: * -> *) a b.
Functor m =>
(a -> b) -> GenT e m a -> GenT e m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> GenT e m b -> GenT e m a
$c<$ :: forall e (m :: * -> *) a b.
Functor m =>
a -> GenT e m b -> GenT e m a
fmap :: (a -> b) -> GenT e m a -> GenT e m b
$cfmap :: forall e (m :: * -> *) a b.
Functor m =>
(a -> b) -> GenT e m a -> GenT e m b
Functor)

instance Monad m => MonadGen e (GenT e m) where
  gen :: GenT e m e
gen = ReaderT (Successor e) (StateT e m) e -> GenT e m e
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e) (StateT e m) e -> GenT e m e)
-> ReaderT (Successor e) (StateT e m) e -> GenT e m e
forall a b. (a -> b) -> a -> b
$ do
    e -> e
s <- (Successor e -> e -> e)
-> ReaderT (Successor e) (StateT e m) (e -> e)
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks Successor e -> e -> e
forall a. Successor a -> a -> a
suc
    (e -> e) -> ReaderT (Successor e) (StateT e m) ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify e -> e
s
    ReaderT (Successor e) (StateT e m) e
forall s (m :: * -> *). MonadState s m => m s
get

instance Monad m => Monad (GenT e m) where
  return :: a -> GenT e m a
return = ReaderT (Successor e) (StateT e m) a -> GenT e m a
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e) (StateT e m) a -> GenT e m a)
-> (a -> ReaderT (Successor e) (StateT e m) a) -> a -> GenT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ReaderT (Successor e) (StateT e m) a
forall (m :: * -> *) a. Monad m => a -> m a
return
  (GenT m :: ReaderT (Successor e) (StateT e m) a
m) >>= :: GenT e m a -> (a -> GenT e m b) -> GenT e m b
>>= f :: a -> GenT e m b
f = ReaderT (Successor e) (StateT e m) b -> GenT e m b
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e) (StateT e m) b -> GenT e m b)
-> ReaderT (Successor e) (StateT e m) b -> GenT e m b
forall a b. (a -> b) -> a -> b
$ ReaderT (Successor e) (StateT e m) a
m ReaderT (Successor e) (StateT e m) a
-> (a -> ReaderT (Successor e) (StateT e m) b)
-> ReaderT (Successor e) (StateT e m) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= GenT e m b -> ReaderT (Successor e) (StateT e m) b
forall e (m :: * -> *) a.
GenT e m a -> ReaderT (Successor e) (StateT e m) a
unGenT (GenT e m b -> ReaderT (Successor e) (StateT e m) b)
-> (a -> GenT e m b) -> a -> ReaderT (Successor e) (StateT e m) b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> GenT e m b
f
instance MonadPlus m =>  MonadPlus (GenT e m) where
  mzero :: GenT e m a
mzero = ReaderT (Successor e) (StateT e m) a -> GenT e m a
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT ReaderT (Successor e) (StateT e m) a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
  mplus :: GenT e m a -> GenT e m a -> GenT e m a
mplus (GenT m :: ReaderT (Successor e) (StateT e m) a
m) (GenT m' :: ReaderT (Successor e) (StateT e m) a
m') = ReaderT (Successor e) (StateT e m) a -> GenT e m a
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e) (StateT e m) a -> GenT e m a)
-> ReaderT (Successor e) (StateT e m) a -> GenT e m a
forall a b. (a -> b) -> a -> b
$ ReaderT (Successor e) (StateT e m) a
-> ReaderT (Successor e) (StateT e m) a
-> ReaderT (Successor e) (StateT e m) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus ReaderT (Successor e) (StateT e m) a
m ReaderT (Successor e) (StateT e m) a
m'
instance (Functor f, Monad f) => Applicative (GenT e f) where
  pure :: a -> GenT e f a
pure = ReaderT (Successor e) (StateT e f) a -> GenT e f a
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e) (StateT e f) a -> GenT e f a)
-> (a -> ReaderT (Successor e) (StateT e f) a) -> a -> GenT e f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ReaderT (Successor e) (StateT e f) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
  (GenT f :: ReaderT (Successor e) (StateT e f) (a -> b)
f) <*> :: GenT e f (a -> b) -> GenT e f a -> GenT e f b
<*> (GenT a :: ReaderT (Successor e) (StateT e f) a
a) = ReaderT (Successor e) (StateT e f) b -> GenT e f b
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e) (StateT e f) b -> GenT e f b)
-> ReaderT (Successor e) (StateT e f) b -> GenT e f b
forall a b. (a -> b) -> a -> b
$ ReaderT (Successor e) (StateT e f) (a -> b)
f ReaderT (Successor e) (StateT e f) (a -> b)
-> ReaderT (Successor e) (StateT e f) a
-> ReaderT (Successor e) (StateT e f) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReaderT (Successor e) (StateT e f) a
a
instance (Monad m, Functor m, MonadPlus m) => Alternative (GenT e m) where
  empty :: GenT e m a
empty = GenT e m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
  <|> :: GenT e m a -> GenT e m a -> GenT e m a
(<|>) = GenT e m a -> GenT e m a -> GenT e m a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus

type Gen e = GenT e Identity

instance MonadTrans (GenT e) where
  lift :: m a -> GenT e m a
lift = ReaderT (Successor e) (StateT e m) a -> GenT e m a
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e) (StateT e m) a -> GenT e m a)
-> (m a -> ReaderT (Successor e) (StateT e m) a)
-> m a
-> GenT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StateT e m a -> ReaderT (Successor e) (StateT e m) a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (StateT e m a -> ReaderT (Successor e) (StateT e m) a)
-> (m a -> StateT e m a)
-> m a
-> ReaderT (Successor e) (StateT e m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> StateT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

instance MonadReader r m => MonadReader r (GenT e m) where
  local :: (r -> r) -> GenT e m a -> GenT e m a
local f :: r -> r
f m :: GenT e m a
m = ReaderT (Successor e) (StateT e m) a -> GenT e m a
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e) (StateT e m) a -> GenT e m a)
-> ReaderT (Successor e) (StateT e m) a -> GenT e m a
forall a b. (a -> b) -> a -> b
$ ReaderT (Successor e) (StateT e m) (Successor e)
forall r (m :: * -> *). MonadReader r m => m r
ask ReaderT (Successor e) (StateT e m) (Successor e)
-> (Successor e -> ReaderT (Successor e) (StateT e m) a)
-> ReaderT (Successor e) (StateT e m) a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= StateT e m a -> ReaderT (Successor e) (StateT e m) a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (StateT e m a -> ReaderT (Successor e) (StateT e m) a)
-> (Successor e -> StateT e m a)
-> Successor e
-> ReaderT (Successor e) (StateT e m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (r -> r) -> StateT e m a -> StateT e m a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local r -> r
f (StateT e m a -> StateT e m a)
-> (Successor e -> StateT e m a) -> Successor e -> StateT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReaderT (Successor e) (StateT e m) a -> Successor e -> StateT e m a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (GenT e m a -> ReaderT (Successor e) (StateT e m) a
forall e (m :: * -> *) a.
GenT e m a -> ReaderT (Successor e) (StateT e m) a
unGenT GenT e m a
m)
  ask :: GenT e m r
ask     = ReaderT (Successor e) (StateT e m) r -> GenT e m r
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (StateT e m r -> ReaderT (Successor e) (StateT e m) r
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT e m r
forall r (m :: * -> *). MonadReader r m => m r
ask)
instance MonadState s m => MonadState s (GenT e m) where
  get :: GenT e m s
get    = ReaderT (Successor e) (StateT e m) s -> GenT e m s
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e) (StateT e m) s -> GenT e m s)
-> ReaderT (Successor e) (StateT e m) s -> GenT e m s
forall a b. (a -> b) -> a -> b
$ (StateT e m s -> ReaderT (Successor e) (StateT e m) s
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (StateT e m s -> ReaderT (Successor e) (StateT e m) s)
-> (m s -> StateT e m s)
-> m s
-> ReaderT (Successor e) (StateT e m) s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m s -> StateT e m s
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 -> GenT e m ()
put    = ReaderT (Successor e) (StateT e m) () -> GenT e m ()
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e) (StateT e m) () -> GenT e m ())
-> (s -> ReaderT (Successor e) (StateT e m) ()) -> s -> GenT e m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StateT e m () -> ReaderT (Successor e) (StateT e m) ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (StateT e m () -> ReaderT (Successor e) (StateT e m) ())
-> (s -> StateT e m ())
-> s
-> ReaderT (Successor e) (StateT e m) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m () -> StateT e m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> StateT e m ()) -> (s -> m ()) -> s -> StateT e m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> m ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put
instance (MonadWriter w m) => MonadWriter w (GenT e m) where
  tell :: w -> GenT e m ()
tell m :: w
m = m () -> GenT e m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> GenT e m ()) -> m () -> GenT e m ()
forall a b. (a -> b) -> a -> b
$ w -> m ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell w
m
  listen :: GenT e m a -> GenT e m (a, w)
listen = ReaderT (Successor e) (StateT e m) (a, w) -> GenT e m (a, w)
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e) (StateT e m) (a, w) -> GenT e m (a, w))
-> (GenT e m a -> ReaderT (Successor e) (StateT e m) (a, w))
-> GenT e m a
-> GenT e m (a, w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReaderT (Successor e) (StateT e m) a
-> ReaderT (Successor e) (StateT e m) (a, w)
forall w (m :: * -> *) a. MonadWriter w m => m a -> m (a, w)
listen (ReaderT (Successor e) (StateT e m) a
 -> ReaderT (Successor e) (StateT e m) (a, w))
-> (GenT e m a -> ReaderT (Successor e) (StateT e m) a)
-> GenT e m a
-> ReaderT (Successor e) (StateT e m) (a, w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenT e m a -> ReaderT (Successor e) (StateT e m) a
forall e (m :: * -> *) a.
GenT e m a -> ReaderT (Successor e) (StateT e m) a
unGenT
  pass :: GenT e m (a, w -> w) -> GenT e m a
pass   = ReaderT (Successor e) (StateT e m) a -> GenT e m a
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e) (StateT e m) a -> GenT e m a)
-> (GenT e m (a, w -> w) -> ReaderT (Successor e) (StateT e m) a)
-> GenT e m (a, w -> w)
-> GenT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReaderT (Successor e) (StateT e m) (a, w -> w)
-> ReaderT (Successor e) (StateT e m) a
forall w (m :: * -> *) a. MonadWriter w m => m (a, w -> w) -> m a
pass (ReaderT (Successor e) (StateT e m) (a, w -> w)
 -> ReaderT (Successor e) (StateT e m) a)
-> (GenT e m (a, w -> w)
    -> ReaderT (Successor e) (StateT e m) (a, w -> w))
-> GenT e m (a, w -> w)
-> ReaderT (Successor e) (StateT e m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenT e m (a, w -> w)
-> ReaderT (Successor e) (StateT e m) (a, w -> w)
forall e (m :: * -> *) a.
GenT e m a -> ReaderT (Successor e) (StateT e m) a
unGenT
instance MonadFix m => MonadFix (GenT e m) where
  mfix :: (a -> GenT e m a) -> GenT e m a
mfix = ReaderT (Successor e) (StateT e m) a -> GenT e m a
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e) (StateT e m) a -> GenT e m a)
-> ((a -> GenT e m a) -> ReaderT (Successor e) (StateT e m) a)
-> (a -> GenT e m a)
-> GenT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> ReaderT (Successor e) (StateT e m) a)
-> ReaderT (Successor e) (StateT e m) a
forall (m :: * -> *) a. MonadFix m => (a -> m a) -> m a
mfix ((a -> ReaderT (Successor e) (StateT e m) a)
 -> ReaderT (Successor e) (StateT e m) a)
-> ((a -> GenT e m a) -> a -> ReaderT (Successor e) (StateT e m) a)
-> (a -> GenT e m a)
-> ReaderT (Successor e) (StateT e m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GenT e m a -> ReaderT (Successor e) (StateT e m) a
forall e (m :: * -> *) a.
GenT e m a -> ReaderT (Successor e) (StateT e m) a
unGenT (GenT e m a -> ReaderT (Successor e) (StateT e m) a)
-> (a -> GenT e m a) -> a -> ReaderT (Successor e) (StateT e m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.)
instance MonadIO m => MonadIO (GenT e m) where
  liftIO :: IO a -> GenT e m a
liftIO = ReaderT (Successor e) (StateT e m) a -> GenT e m a
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e) (StateT e m) a -> GenT e m a)
-> (IO a -> ReaderT (Successor e) (StateT e m) a)
-> IO a
-> GenT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO a -> ReaderT (Successor e) (StateT e m) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO
instance MonadCont m => MonadCont (GenT e m) where
  callCC :: ((a -> GenT e m b) -> GenT e m a) -> GenT e m a
callCC f :: (a -> GenT e m b) -> GenT e m a
f = ReaderT (Successor e) (StateT e m) a -> GenT e m a
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e) (StateT e m) a -> GenT e m a)
-> ReaderT (Successor e) (StateT e m) a -> GenT e m a
forall a b. (a -> b) -> a -> b
$ ((a -> ReaderT (Successor e) (StateT e m) b)
 -> ReaderT (Successor e) (StateT e m) a)
-> ReaderT (Successor e) (StateT e m) a
forall (m :: * -> *) a b. MonadCont m => ((a -> m b) -> m a) -> m a
callCC (GenT e m a -> ReaderT (Successor e) (StateT e m) a
forall e (m :: * -> *) a.
GenT e m a -> ReaderT (Successor e) (StateT e m) a
unGenT (GenT e m a -> ReaderT (Successor e) (StateT e m) a)
-> ((a -> ReaderT (Successor e) (StateT e m) b) -> GenT e m a)
-> (a -> ReaderT (Successor e) (StateT e m) b)
-> ReaderT (Successor e) (StateT e m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> GenT e m b) -> GenT e m a
f ((a -> GenT e m b) -> GenT e m a)
-> ((a -> ReaderT (Successor e) (StateT e m) b) -> a -> GenT e m b)
-> (a -> ReaderT (Successor e) (StateT e m) b)
-> GenT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ReaderT (Successor e) (StateT e m) b -> GenT e m b
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e) (StateT e m) b -> GenT e m b)
-> (a -> ReaderT (Successor e) (StateT e m) b) -> a -> GenT e m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
.))
instance MonadError e m => MonadError e (GenT e' m) where
  throwError :: e -> GenT e' m a
throwError = ReaderT (Successor e') (StateT e' m) a -> GenT e' m a
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e') (StateT e' m) a -> GenT e' m a)
-> (e -> ReaderT (Successor e') (StateT e' m) a)
-> e
-> GenT e' m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> ReaderT (Successor e') (StateT e' m) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError
  catchError :: GenT e' m a -> (e -> GenT e' m a) -> GenT e' m a
catchError m :: GenT e' m a
m h :: e -> GenT e' m a
h = ReaderT (Successor e') (StateT e' m) a -> GenT e' m a
forall e (m :: * -> *) a.
ReaderT (Successor e) (StateT e m) a -> GenT e m a
GenT (ReaderT (Successor e') (StateT e' m) a -> GenT e' m a)
-> ReaderT (Successor e') (StateT e' m) a -> GenT e' m a
forall a b. (a -> b) -> a -> b
$ ReaderT (Successor e') (StateT e' m) a
-> (e -> ReaderT (Successor e') (StateT e' m) a)
-> ReaderT (Successor e') (StateT e' m) a
forall e (m :: * -> *) a.
MonadError e m =>
m a -> (e -> m a) -> m a
catchError (GenT e' m a -> ReaderT (Successor e') (StateT e' m) a
forall e (m :: * -> *) a.
GenT e m a -> ReaderT (Successor e) (StateT e m) a
unGenT GenT e' m a
m) (GenT e' m a -> ReaderT (Successor e') (StateT e' m) a
forall e (m :: * -> *) a.
GenT e m a -> ReaderT (Successor e) (StateT e m) a
unGenT (GenT e' m a -> ReaderT (Successor e') (StateT e' m) a)
-> (e -> GenT e' m a)
-> e
-> ReaderT (Successor e') (StateT e' m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> GenT e' m a
h)

successor :: (e -> e) -> Successor e
successor :: (e -> e) -> Successor e
successor = (e -> e) -> Successor e
forall a. (a -> a) -> Successor a
Successor

enumSucc :: Enum e => Successor e
enumSucc :: Successor e
enumSucc = (e -> e) -> Successor e
forall a. (a -> a) -> Successor a
Successor e -> e
forall a. Enum a => a -> a
succ

-- | Run a @GenT@ computation starting from the value
-- @toEnum 0@
runGenT :: (Enum e, Monad m) => GenT e m a -> m a
runGenT :: GenT e m a -> m a
runGenT = e -> GenT e m a -> m a
forall (m :: * -> *) e a.
(Monad m, Enum e) =>
e -> GenT e m a -> m a
runGenTFrom (Int -> e
forall a. Enum a => Int -> a
toEnum 0)

-- | Run a @Gen@ computation starting from the value
-- @toEnum 0@
runGen :: Enum e => Gen e a -> a
runGen :: Gen e a -> a
runGen = e -> Gen e a -> a
forall e a. Enum e => e -> Gen e a -> a
runGenFrom (Int -> e
forall a. Enum a => Int -> a
toEnum 0)

-- | Run a @GenT@ computation starting from a specific value @e@.
runGenTFrom :: (Monad m, Enum e) => e -> GenT e m a -> m a
runGenTFrom :: e -> GenT e m a -> m a
runGenTFrom e :: e
e = Successor e -> e -> GenT e m a -> m a
forall (m :: * -> *) e a.
Monad m =>
Successor e -> e -> GenT e m a -> m a
runGenTWith Successor e
forall e. Enum e => Successor e
enumSucc e
e

-- | Run a @Gen@ computation starting from a specific value @e@.
runGenFrom :: Enum e => e -> Gen e a -> a
runGenFrom :: e -> Gen e a -> a
runGenFrom e :: e
e = Successor e -> e -> Gen e a -> a
forall e a. Successor e -> e -> Gen e a -> a
runGenWith Successor e
forall e. Enum e => Successor e
enumSucc e
e

-- | Run a @GenT@ computation starting from a specific value @e@ with
-- a the next fresh value determined by @Successor e@.
runGenTWith :: Monad m => Successor e -> e -> GenT e m a -> m a
runGenTWith :: Successor e -> e -> GenT e m a -> m a
runGenTWith s :: Successor e
s e :: e
e = (StateT e m a -> e -> m a) -> e -> StateT e m a -> m a
forall a b c. (a -> b -> c) -> b -> a -> c
flip StateT e m a -> e -> m a
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT e
e
                  (StateT e m a -> m a)
-> (GenT e m a -> StateT e m a) -> GenT e m a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ReaderT (Successor e) (StateT e m) a
 -> Successor e -> StateT e m a)
-> Successor e
-> ReaderT (Successor e) (StateT e m) a
-> StateT e m a
forall a b c. (a -> b -> c) -> b -> a -> c
flip ReaderT (Successor e) (StateT e m) a -> Successor e -> StateT e m a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT Successor e
s
                  (ReaderT (Successor e) (StateT e m) a -> StateT e m a)
-> (GenT e m a -> ReaderT (Successor e) (StateT e m) a)
-> GenT e m a
-> StateT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenT e m a -> ReaderT (Successor e) (StateT e m) a
forall e (m :: * -> *) a.
GenT e m a -> ReaderT (Successor e) (StateT e m) a
unGenT

-- | Run a @GenT@ computation starting from a specific value @e@ with
-- a the next fresh value determined by @Successor e@.
runGenWith :: Successor e -> e -> Gen e a -> a
runGenWith :: Successor e -> e -> Gen e a -> a
runGenWith s :: Successor e
s e :: e
e = Identity a -> a
forall a. Identity a -> a
runIdentity (Identity a -> a) -> (Gen e a -> Identity a) -> Gen e a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Successor e -> e -> Gen e a -> Identity a
forall (m :: * -> *) e a.
Monad m =>
Successor e -> e -> GenT e m a -> m a
runGenTWith Successor e
s e
e