diff --git a/Control/Monad/Operational/Mini.hs b/Control/Monad/Operational/Mini.hs
--- a/Control/Monad/Operational/Mini.hs
+++ b/Control/Monad/Operational/Mini.hs
@@ -16,9 +16,11 @@
     , cloneProgram
     , ReifiedProgram(..)
     , fromReified
-    , module Control.Monad.Operational.Class) where
+    , module Control.Monad.Operational.Class
+    , module Control.Monad.Operational.TH) where
 
 import Control.Monad.Operational.Class
+import Control.Monad.Operational.TH
 import Control.Applicative
 
 infixl 1 :>>=
diff --git a/Control/Monad/Trans/Operational/Mini.hs b/Control/Monad/Trans/Operational/Mini.hs
--- a/Control/Monad/Trans/Operational/Mini.hs
+++ b/Control/Monad/Trans/Operational/Mini.hs
@@ -14,9 +14,15 @@
 -- Simple operational monad transformer
 ----------------------------------------------------------------------------
 module Control.Monad.Trans.Operational.Mini (
-  ProgramT(..), interpret,  ReifiedProgramT(..), fromReifiedT,
-  module Control.Monad.Operational.Class,
-  module Control.Monad.Operational.TH
+  ProgramT(..)
+  , unProgram
+  , interpret
+  , ReifiedProgramT(..)
+  , fromReifiedT
+  , transReifiedT
+  , hoistReifiedT
+  , module Control.Monad.Operational.Class
+  , module Control.Monad.Operational.TH
   ) where
 
 import Control.Monad
@@ -25,29 +31,32 @@
 import Control.Applicative
 import Control.Monad.Trans.Class
 
-newtype ProgramT t m a = ProgramT { unProgram :: forall r. (a -> m r) -> (forall x. t x -> (x -> m r) -> m r) -> m r }
+newtype ProgramT t m a = ProgramT
+  { unProgramT :: forall r. (a -> r) -> (m r -> r) -> (forall x. t x -> (x -> r) -> r) -> r }
 
+unProgram :: Monad m => ProgramT t m a -> (a -> m r) -> (forall x. t x -> (x -> m r) -> m r) -> m r
+unProgram (ProgramT m) r b = m r join b
+
 instance Functor (ProgramT t m) where
-    fmap f (ProgramT m) = ProgramT $ \p i -> m (p . f) i
+    fmap f (ProgramT m) = ProgramT $ \p l i -> m (p . f) l i
 
 instance Applicative (ProgramT t m) where
-    pure a = ProgramT $ \p _ -> p a
-    ProgramT mf <*> ProgramT ma = ProgramT $ \p i -> mf (\f -> ma (p . f) i) i
+    pure a = ProgramT $ \p _ _ -> p a
+    ProgramT mf <*> ProgramT ma = ProgramT $ \p l i -> mf (\f -> ma (p . f) l i) l i
 
 instance Monad (ProgramT t m) where
-    return a = ProgramT $ \p _ -> p a
-    ProgramT m >>= k = ProgramT $ \p i -> m (\a -> unProgram (k a) p i) i
+    return a = ProgramT $ \p _ _ -> p a
+    ProgramT m >>= k = ProgramT $ \p l i -> m (\a -> unProgramT (k a) p l i) l i
 
 -- | Interpret a 'Program' using the given transformation.
 interpret :: Monad m => (forall x. t x -> m x) -> ProgramT t m a -> m a
-interpret e (ProgramT m) = m return (\t c -> e t >>= c)
+interpret e (ProgramT m) = m return join (\t c -> e t >>= c)
 
 instance t :! ProgramT t m where
-    singleton t = ProgramT $ \p i -> i t p
+    singleton t = ProgramT $ \p _ i -> i t p
 
 instance MonadTrans (ProgramT t) where
-    lift m = ProgramT $ \p _ -> m >>= p
-
+    lift m = ProgramT $ \p l _ -> l (liftM p m)
 
 infix 1 :>>=
 
@@ -57,12 +66,21 @@
   Lift :: m a -> (a -> ReifiedProgramT t m b) -> ReifiedProgramT t m b
 
 fromReifiedT :: Monad m => ReifiedProgramT t m a -> ProgramT t m a
-fromReifiedT m = ProgramT $ \p i ->
+fromReifiedT m = ProgramT $ \p l i ->
   let go (Return a) = p a
       go (t :>>= c) = i t (go . c)
-      go (Lift a c) = a >>= go . c
+      go (Lift a c) = l $ liftM (go . c) a
    in go m
 
+transReifiedT :: Monad m => (forall x. m x -> n x) -> ReifiedProgramT t m a -> ReifiedProgramT t n a
+transReifiedT _ (Return a) = Return a
+transReifiedT t (i :>>= cont) = i :>>= transReifiedT t . cont
+transReifiedT t (Lift m cont) = Lift (t m) (transReifiedT t . cont)
+
+hoistReifiedT :: Monad m => (forall x. t x -> s x) -> ReifiedProgramT t m a -> ReifiedProgramT s m a
+hoistReifiedT _ (Return a) = Return a
+hoistReifiedT t (i :>>= cont) = t i :>>= hoistReifiedT t . cont
+hoistReifiedT t (Lift m cont) = Lift m (hoistReifiedT t . cont)
 
 instance Monad m => Functor (ReifiedProgramT t m) where
     fmap f = go where
diff --git a/minioperational.cabal b/minioperational.cabal
--- a/minioperational.cabal
+++ b/minioperational.cabal
@@ -1,8 +1,5 @@
--- Initial minioperational.cabal generated by cabal init.  For further 
--- documentation, see http://haskell.org/cabal/users-guide/
-
 name:                minioperational
-version:             0.4.2
+version:             0.4.3
 synopsis:            fast and simple operational monad
 description:         This package provides tiny implementation of operational monad.
 homepage:            https://github.com/fumieval/minioperational