monad-gen 0.2.0.3 → 0.3.0.0

raw patch · 2 files changed

+49/−21 lines, 2 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• monad-gen.cabal +1/−1
• src/Control/Monad/Gen.hs +48/−20

@@ -1,5 +1,5 @@ name:                monad-gen-version:             0.2.0.3+version:             0.3.0.0 synopsis:            A simple monad for generating fresh integers description:     This module provides a simple monad transformer @GenT@ to enumerate unique values within

@@ -5,10 +5,14 @@        ( GenT        , Gen        , module Control.Monad.Gen.Class+       , Successor+       , successor        , runGenT        , runGen        , runGenTWith-       , runGenWith) where+       , runGenWith+       , runGenTFrom+       , runGenFrom) where #if MIN_VERSION_mtl(2, 2, 1) import Control.Monad.Except #else@@ -16,23 +20,32 @@ #endif  import Control.Applicative-import Control.Monad.Identity import Control.Monad.Cont.Class+import Control.Monad.Gen.Class+import Control.Monad.Identity+import Control.Monad.Reader import Control.Monad.Reader.Class import Control.Monad.State import Control.Monad.Writer.Class-import Control.Monad.Gen.Class +newtype Successor a = Successor {suc :: a -> a}+ -- | The monad transformer for generating fresh values.-newtype GenT e m a = GenT {unGenT :: StateT e m a}+data GenT e m a = GenT {unGenT :: ReaderT (Successor e) (StateT e m) a}                    deriving(Functor) -instance (Monad m, Enum e) => MonadGen e (GenT e m) where-  gen = GenT (modify succ) >> GenT get+instance Monad m => MonadGen e (GenT e m) where+  gen = GenT $ do+    s <- asks suc+    modify s+    get  instance Monad m => Monad (GenT e m) where   return = GenT . return   (GenT m) >>= f = GenT $ m >>= unGenT . f+instance MonadPlus m =>  MonadPlus (GenT e m) where+  mzero = GenT mzero+  mplus (GenT m) (GenT m') = GenT $ mplus m m' instance (Functor f, Monad f) => Applicative (GenT e f) where   pure = GenT . pure   (GenT f) <*> (GenT a) = GenT $ f <*> a@@ -43,23 +56,20 @@ type Gen e = GenT e Identity  instance MonadTrans (GenT e) where-  lift = GenT . lift+  lift = GenT . lift . lift  instance MonadReader r m => MonadReader r (GenT e m) where-  local f = GenT . local f . unGenT-  ask     = GenT ask+  local f m = GenT $ ask >>= lift . local f . runReaderT (unGenT m)+  ask     = GenT (lift ask) instance MonadState s m => MonadState s (GenT e m) where-  get    = GenT $ lift get-  put    = GenT . lift . put+  get    = GenT $ (lift . lift) get+  put    = GenT . lift . lift . put instance (MonadWriter w m) => MonadWriter w (GenT e m) where   tell m = lift $ tell m   listen = GenT . listen . unGenT   pass   = GenT . pass . unGenT instance MonadFix m => MonadFix (GenT e m) where   mfix = GenT . mfix . (unGenT .)-instance MonadPlus m =>  MonadPlus (GenT e m) where-  mzero = GenT mzero-  mplus (GenT m) (GenT m') = GenT $ mplus m m' instance MonadIO m => MonadIO (GenT e m) where   liftIO = GenT . liftIO instance MonadCont m => MonadCont (GenT e m) where@@ -72,20 +82,38 @@   catchError m h = GenT $ catchError (unGenT m) (unGenT . h) #endif +successor :: (e -> e) -> Successor e+successor = Successor++enumSucc :: Enum e => Successor e+enumSucc = Successor succ+ -- | Run a @GenT@ computation starting from the value -- @toEnum 0@ runGenT :: (Enum e, Monad m) => GenT e m a -> m a-runGenT = runGenTWith (toEnum 0)+runGenT = runGenTFrom (toEnum 0)  -- | Run a @Gen@ computation starting from the value -- @toEnum 0@ runGen :: Enum e => Gen e a -> a-runGen = runGenWith (toEnum 0)+runGen = runGenFrom (toEnum 0)  -- | Run a @GenT@ computation starting from a specific value @e@.-runGenTWith :: Monad m => e -> GenT e m a -> m a-runGenTWith e = flip evalStateT e . unGenT+runGenTFrom :: (Monad m, Enum e) => e -> GenT e m a -> m a+runGenTFrom e = runGenTWith enumSucc e  -- | Run a @Gen@ computation starting from a specific value @e@.-runGenWith :: e -> Gen e a -> a-runGenWith e = runIdentity . runGenTWith e+runGenFrom :: Enum e => e -> Gen e a -> a+runGenFrom e = runGenWith enumSucc 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 s e = flip evalStateT e+                  . flip runReaderT s+                  . 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 s e = runIdentity . runGenTWith s e