monad-resumption 0.1.2.0 → 0.1.3.0
raw patch · 4 files changed
+28/−11 lines, 4 filesdep ~basePVP: major bump suggested
API removals or changes: PVP suggests a major version bump
Dependency ranges changed: base
API changes (from Hackage documentation)
- Control.Monad.Resumption: deResT :: ResT m a -> m (Either a (ResT m a))
- Control.Monad.Resumption: instance MFunctor ResT
- Control.Monad.Resumption: instance Monad m => Applicative (ResT m)
- Control.Monad.Resumption: instance Monad m => Functor (ResT m)
- Control.Monad.Resumption: instance Monad m => Monad (ResT m)
- Control.Monad.Resumption: instance MonadIO m => MonadIO (ResT m)
- Control.Monad.Resumption: instance MonadTrans ResT
- Control.Monad.Resumption.Reactive: deReacT :: ReacT input output m a -> m (Either a (output, input -> ReacT input output m a))
- Control.Monad.Resumption.Reactive: instance MFunctor (ReacT i o)
- Control.Monad.Resumption.Reactive: instance Monad m => Applicative (ReacT input output m)
- Control.Monad.Resumption.Reactive: instance Monad m => Functor (ReacT input output m)
- Control.Monad.Resumption.Reactive: instance Monad m => Monad (ReacT input output m)
- Control.Monad.Resumption.Reactive: instance MonadIO m => MonadIO (ReacT input output m)
- Control.Monad.Resumption.Reactive: instance MonadTrans (ReacT input output)
+ Control.Monad.Resumption: [deResT] :: ResT m a -> m (Either a (ResT m a))
+ Control.Monad.Resumption: instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Resumption.ResT m)
+ Control.Monad.Resumption: instance Control.Monad.Morph.MFunctor Control.Monad.Resumption.ResT
+ Control.Monad.Resumption: instance Control.Monad.Trans.Class.MonadTrans Control.Monad.Resumption.ResT
+ Control.Monad.Resumption: instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Monad.Resumption.ResT m)
+ Control.Monad.Resumption: instance GHC.Base.Monad m => GHC.Base.Functor (Control.Monad.Resumption.ResT m)
+ Control.Monad.Resumption: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Resumption.ResT m)
+ Control.Monad.Resumption.Reactive: [deReacT] :: ReacT input output m a -> m (Either a (output, input -> ReacT input output m a))
+ Control.Monad.Resumption.Reactive: instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Resumption.Reactive.ReacT input output m)
+ Control.Monad.Resumption.Reactive: instance Control.Monad.Morph.MFunctor (Control.Monad.Resumption.Reactive.ReacT i o)
+ Control.Monad.Resumption.Reactive: instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Resumption.Reactive.ReacT input output)
+ Control.Monad.Resumption.Reactive: instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Monad.Resumption.Reactive.ReacT input output m)
+ Control.Monad.Resumption.Reactive: instance GHC.Base.Monad m => GHC.Base.Functor (Control.Monad.Resumption.Reactive.ReacT input output m)
+ Control.Monad.Resumption.Reactive: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Resumption.Reactive.ReacT input output m)
+ Control.Monad.Resumption.Reactive: iter :: Monad m => (i -> o) -> o -> ReacT i o m a
- Control.Monad.Resumption: runResT :: Monad m => ResT m a -> m a
+ Control.Monad.Resumption: runResT :: (Monad m) => ResT m a -> m a
- Control.Monad.Resumption.Connectors: (<||>) :: Monad m => ReacT i1 o1 m a -> ReacT i2 o2 m a -> ReacT (i1, i2) (o1, o2) m a
+ Control.Monad.Resumption.Connectors: (<||>) :: (Monad m) => ReacT i1 o1 m a -> ReacT i2 o2 m a -> ReacT (i1, i2) (o1, o2) m a
- Control.Monad.Resumption.Connectors: pipeline :: Monad m => ReacT i z m a -> ReacT z o m a -> ReacT i o m a
+ Control.Monad.Resumption.Connectors: pipeline :: (Monad m) => ReacT i z m a -> ReacT z o m a -> ReacT i o m a
- Control.Monad.Resumption.Connectors: refold :: Monad m => (o1 -> o2) -> (o1 -> i2 -> i1) -> ReacT i1 o1 m a -> ReacT i2 o2 m a
+ Control.Monad.Resumption.Connectors: refold :: (Monad m) => (o1 -> o2) -> (o1 -> i2 -> i1) -> ReacT i1 o1 m a -> ReacT i2 o2 m a
- Control.Monad.Resumption.Connectors: refoldT :: Monad m => (o1 -> o2) -> (o1 -> i2 -> Maybe i1) -> ReacT i1 o1 m a -> ReacT i2 o2 m a
+ Control.Monad.Resumption.Connectors: refoldT :: forall o1 o2 i1 i2 m a. Monad m => (o1 -> o2) -> (o1 -> i2 -> Maybe i1) -> ReacT i1 o1 m a -> ReacT i2 o2 m a
Files
- Control/Monad/Resumption.hs +2/−1
- Control/Monad/Resumption/Connectors.hs +1/−1
- Control/Monad/Resumption/Reactive.hs +23/−7
- monad-resumption.cabal +2/−2
Control/Monad/Resumption.hs view
@@ -4,9 +4,10 @@ module Control.Monad.Resumption where import Control.Monad+--import Control.Monad.Trans import Control.Applicative import Control.Monad.IO.Class-import Control.Monad.Morph+import Control.Monad.Morph -- | Resumption monad transformer. newtype ResT m a = ResT { deResT :: m (Either a (ResT m a)) }
Control/Monad/Resumption/Connectors.hs view
@@ -15,7 +15,7 @@ (_,Left a) -> return $ Left a (Right (o1,res1),Right (o2,res2)) -> return $ Right ((o1,o2),\(i1,i2) -> (res1 i1) <||> (res2 i2)) -{- Draft implementation of refoldT -}+-- | The refoldT operator is a refold where the input-modifying function yields a type in Maybe refoldT :: forall o1 o2 i1 i2 m a . Monad m => (o1 -> o2) -> (o1 -> i2 -> Maybe i1) -> ReacT i1 o1 m a
Control/Monad/Resumption/Reactive.hs view
@@ -7,7 +7,8 @@ import Control.Monad import Control.Applicative import Control.Monad.IO.Class-import Control.Monad.Morph+import qualified Control.Monad.Morph as Morph+import qualified Control.Monad.Trans as Trans import Control.Monad.Resumption -- | Reactive resumption monad transformer.@@ -22,9 +23,12 @@ Left v -> deReacT (f v) Right (output, resume) -> return (Right (output,\ p -> resume p >>= f)) -instance MonadTrans (ReacT input output) where+instance Trans.MonadTrans (ReacT input output) where lift m = ReacT $ m >>= return . Left +--instance Morph.MonadTrans (ReacT input output) where+-- lift m = ReacT $ m >>= return . Left+ instance Monad m => Functor (ReacT input output m) where fmap f (ReacT m) = ReacT (m >>= \ r -> case r of Left v -> return (Left (f v))@@ -35,22 +39,24 @@ (<*>) = ap instance MonadIO m => MonadIO (ReacT input output m) where- liftIO = lift . liftIO+ liftIO = Trans.lift . liftIO -instance MFunctor (ReacT i o) where- hoist f = ReacT . f . liftM (fmap (fmap (fmap (hoist f)))) . deReacT+instance Morph.MFunctor (ReacT i o) where+ hoist f = ReacT . f . liftM (fmap (fmap (fmap (Morph.hoist f)))) . deReacT ++ -- | Outputs its argument, then waits for the next input and returns it. signal :: Monad m => output -> ReacT input output m input signal o = ReacT (return (Right (o,return))) -- | Tennis operator. (<~>) :: Monad m => ReacT i o m a -> ReacT o i m b -> ResT m (Either a b)-m1 <~> m2 = do r1 <- lift (deReacT m1)+m1 <~> m2 = do r1 <- Trans.lift (deReacT m1) case r1 of Left v -> return (Left v) Right (o1,k1) -> do- r2 <- lift (deReacT m2)+ r2 <- Trans.lift (deReacT m2) case r2 of Left v -> return (Right v) Right (o2,k2) -> k1 o2 <~> k2 o1@@ -64,3 +70,13 @@ Right (!output,!fr) -> do next_input <- handler output runReacT (fr next_input) handler+-- | A function for lifting pure functions to Reactive Resumptions. Initial output is provided+-- as the second argument.+iter :: Monad m => (i -> o) -> o -> ReacT i o m a+iter f init_o = do+ i <- signal init_o+ iter' f i+ where+ iter' f i = do+ i' <- signal (f i)+ iter' f i'
monad-resumption.cabal view
@@ -2,7 +2,7 @@ -- documentation, see http://haskell.org/cabal/users-guide/ name: monad-resumption-version: 0.1.2.0+version: 0.1.3.0 synopsis: Resumption and reactive resumption monads for Haskell. description: This package contains the definitions of Resumption and Reactive Resumption Monads. homepage: https://github.com/igraves/resumption_monads@@ -26,6 +26,6 @@ Control.Monad.Resumption.Connectors -- other-modules: -- other-extensions: - build-depends: base >=4.6 && <= 4.9, transformers, mtl, mmorph+ build-depends: base >=4.6 && <= 4.11, transformers, mtl, mmorph -- hs-source-dirs: default-language: Haskell2010