diff --git a/Control/Monad/Resumption.hs b/Control/Monad/Resumption.hs
--- a/Control/Monad/Resumption.hs
+++ b/Control/Monad/Resumption.hs
@@ -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)) }
diff --git a/Control/Monad/Resumption/Connectors.hs b/Control/Monad/Resumption/Connectors.hs
--- a/Control/Monad/Resumption/Connectors.hs
+++ b/Control/Monad/Resumption/Connectors.hs
@@ -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
diff --git a/Control/Monad/Resumption/Reactive.hs b/Control/Monad/Resumption/Reactive.hs
--- a/Control/Monad/Resumption/Reactive.hs
+++ b/Control/Monad/Resumption/Reactive.hs
@@ -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'
diff --git a/monad-resumption.cabal b/monad-resumption.cabal
--- a/monad-resumption.cabal
+++ b/monad-resumption.cabal
@@ -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