diff --git a/DeepControl/Monad/Trans.hs b/DeepControl/Monad/Trans.hs
--- a/DeepControl/Monad/Trans.hs
+++ b/DeepControl/Monad/Trans.hs
@@ -23,19 +23,19 @@
 
     -- * Level-2
     -- ** trans-roll
-    transroll2, untransroll2,
+    transfold2, untransfold2,
 
     -- * Level-3
     -- ** trans-roll
-    transroll3, untransroll3,
+    transfold3, untransfold3,
 
     -- * Level-4
     -- ** trans-roll
-    transroll4, untransroll4,
+    transfold4, untransfold4,
 
     -- * Level-5
     -- ** trans-roll
-    transroll5, untransroll5,
+    transfold5, untransfold5,
 
     -- * Level-2 example
     -- $Example_Level2
@@ -64,7 +64,7 @@
 ----------------------------------------------------------------------
 -- Level-1
 
--- | Required only for transroll
+-- | Required only for transfold
 class (Monad m, MonadTrans t) => MonadTrans_ m t | m -> t, t -> m where
     trans :: (Monad n) => n (m a) -> t n a
     untrans :: (Monad n) => t n a -> n (m a)
@@ -96,61 +96,61 @@
 
 -- | 
 --
--- >>> transroll2 $ [Just 1]
+-- >>> transfold2 $ [Just 1]
 -- MaybeT [Just 1]
 --
--- >>> transroll2 $ Just [1]
+-- >>> transfold2 $ Just [1]
 -- ListT (Just [1])
 --
-transroll2 :: (Monad m1, MonadTrans_ m2 t2) => m1 (m2 a) -> (t2 m1) a
-transroll2 = trans
+transfold2 :: (Monad m1, MonadTrans_ m2 t2) => m1 (m2 a) -> (t2 m1) a
+transfold2 = trans
 
 -- | 
 --
--- >>> untransroll2 $ MaybeT [Just 1]
+-- >>> untransfold2 $ MaybeT [Just 1]
 -- [Just 1]
 --
--- >>> untransroll2 $ ListT (Just [1])
+-- >>> untransfold2 $ ListT (Just [1])
 -- Just [1]
 --
-untransroll2 :: (Monad m1, MonadTrans_ m2 t2) => (t2 m1) a -> m1 (m2 a)
-untransroll2 = untrans
+untransfold2 :: (Monad m1, MonadTrans_ m2 t2) => (t2 m1) a -> m1 (m2 a)
+untransfold2 = untrans
 
 ----------------------------------------------------------------------
 -- Level-3
 
 -- | 
 --
--- >>> transroll3 $ ExceptT (Identity (Right [Just 1]))
+-- >>> transfold3 $ ExceptT (Identity (Right [Just 1]))
 -- MaybeT (ListT (ExceptT (Identity (Right [Just 1]))))
 --
-transroll3 :: (Monad m1, Monad (t2 m1), MonadTrans_ m2 t2, MonadTrans_ m3 t3) => m1 (m2 (m3 a)) -> t3 (t2 m1) a
-transroll3 = trans . trans
+transfold3 :: (Monad m1, Monad (t2 m1), MonadTrans_ m2 t2, MonadTrans_ m3 t3) => m1 (m2 (m3 a)) -> t3 (t2 m1) a
+transfold3 = trans . trans
 -- | 
 --
--- >>> untransroll3 $ MaybeT (ListT (ExceptT (Identity (Right [Just 1]))))
+-- >>> untransfold3 $ MaybeT (ListT (ExceptT (Identity (Right [Just 1]))))
 -- ExceptT (Identity (Right [Just 1]))
 --
-untransroll3 :: (Monad m1, Monad (t2 m1), MonadTrans_ m2 t2, MonadTrans_ m3 t3) => t3 (t2 m1) a -> m1 (m2 (m3 a))
-untransroll3 = untrans . untrans
+untransfold3 :: (Monad m1, Monad (t2 m1), MonadTrans_ m2 t2, MonadTrans_ m3 t3) => t3 (t2 m1) a -> m1 (m2 (m3 a))
+untransfold3 = untrans . untrans
 
 ----------------------------------------------------------------------
 -- Level-4
 
-transroll4 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4) => m1 (m2 (m3 (m4 a))) -> t4 (t3 (t2 m1)) a
-transroll4 = trans . trans . trans
-untransroll4 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4) => t4 (t3 (t2 m1)) a -> m1 (m2 (m3 (m4 a)))
-untransroll4 = untrans . untrans . untrans
+transfold4 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4) => m1 (m2 (m3 (m4 a))) -> t4 (t3 (t2 m1)) a
+transfold4 = trans . trans . trans
+untransfold4 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4) => t4 (t3 (t2 m1)) a -> m1 (m2 (m3 (m4 a)))
+untransfold4 = untrans . untrans . untrans
 
 ----------------------------------------------------------------------
 -- Level-4
 
-transroll5 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4, MonadTrans_ m5 t5) => 
+transfold5 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4, MonadTrans_ m5 t5) => 
               m1 (m2 (m3 (m4 (m5 a)))) -> t5 (t4 (t3 (t2 m1))) a
-transroll5 = trans . trans . trans . trans
-untransroll5 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4, MonadTrans_ m5 t5) => 
+transfold5 = trans . trans . trans . trans
+untransfold5 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4, MonadTrans_ m5 t5) => 
                 t5 (t4 (t3 (t2 m1))) a -> m1 (m2 (m3 (m4 (m5 a))))
-untransroll5 = untrans . untrans . untrans . untrans
+untransfold5 = untrans . untrans . untrans . untrans
 
 ----------------------------------------------------------------------
 -- Examples
@@ -162,7 +162,7 @@
 >import DeepControl.Traversable (sink)
 >import DeepControl.Monad ((>-))
 >import DeepControl.Monad.Morph ((|*|), (|>|))
->import DeepControl.Monad.Trans (transroll2, untransroll2)
+>import DeepControl.Monad.Trans (transfold2, untransfold2)
 >import DeepControl.Monad.Trans.Identity (Identity(..), IdentityT(..), IdentityT2(..))
 >import Control.Monad.Reader
 >import Control.Monad.Trans.Maybe
@@ -195,11 +195,11 @@
 >
 >ackermann' :: Int -> Int -> 
 >              ReaderT TimeLimit (MaybeT IO) Int                 -- ReaderT-MaybeT-IO monad
->ackermann' x y = (transroll2 . runIdentityT2) |>| ackermann x y -- You can get usual ReaderT-MaybeT-IO function from ReaderT-IdentityT2-IO-Maybe function
+>ackermann' x y = (transfold2 . runIdentityT2) |>| ackermann x y -- You can get usual ReaderT-MaybeT-IO function from ReaderT-IdentityT2-IO-Maybe function
 >
 >ackermann'' :: Int -> Int -> 
 >               ReaderT TimeLimit (IdentityT2 IO Maybe) Int       -- ReaderT-IdentityT2-IO-Maybe monad
->ackermann'' x y = (IdentityT2 . untransroll2) |>| ackermann' x y -- You can get ReaderT-IdentityT2-IO-Maybe function from usual ReaderT-MaybeT-IO function
+>ackermann'' x y = (IdentityT2 . untransfold2) |>| ackermann' x y -- You can get ReaderT-IdentityT2-IO-Maybe function from usual ReaderT-MaybeT-IO function
 -}
 
 
diff --git a/DeepControl/Monad/Trans/Identity.hs b/DeepControl/Monad/Trans/Identity.hs
--- a/DeepControl/Monad/Trans/Identity.hs
+++ b/DeepControl/Monad/Trans/Identity.hs
@@ -28,7 +28,7 @@
     (**:),
     (-*:), (*-:),
     -- ** identity-roll  
-    transrollI2, untransrollI2,
+    transfoldI2, untransfoldI2,
     -- ** lift
     mapIdentityT2, liftCallCC2, liftCatch2,
 
@@ -39,7 +39,7 @@
     (--*:), (-*-:), (*--:),
     (-**:), (*-*:), (**-:),
     -- ** identity-roll  
-    transrollI3, untransrollI3,
+    transfoldI3, untransfoldI3,
     -- ** lift 
     mapIdentityT3, liftCallCC3, liftCatch3,
 
@@ -51,7 +51,7 @@
     (--**:), (-*-*:), (*--*:), (*-*-:), (-**-:), (**--:), 
     (-***:), (*-**:), (**-*:), (***-:), 
     -- ** identity-roll  
-    transrollI4, untransrollI4,
+    transfoldI4, untransfoldI4,
     -- ** lift 
     mapIdentityT4, liftCallCC4, liftCatch4,
 
@@ -64,7 +64,7 @@
     (--***:), (-*-**:), (*--**:), (*-*-*:), (-**-*:), (**--*:), (**-*-:), (*-**-:), (-***-:), (***--:),
     (-****:), (*-***:), (**-**:), (***-*:), (****-:),
     -- ** identity-roll  
-    transrollI5, untransrollI5,
+    transfoldI5, untransfoldI5,
     -- ** lift 
     mapIdentityT5, liftCallCC5, liftCatch5,
 
@@ -126,10 +126,10 @@
 instance (MonadIO m1, Monad m1, Monad m2, Traversable m2) => MonadIO (IdentityT2 m1 m2) where
     liftIO = IdentityT2 . (-*) . liftIO
 
-transrollI2 :: (Monad m1, MonadTrans_ m2 t2) => IdentityT2 m1 m2 a -> IdentityT (t2 m1) a
-transrollI2 = IdentityT . transroll2 . runIdentityT2
-untransrollI2 :: (Monad m1, MonadTrans_ m2 t2) => IdentityT (t2 m1) a -> IdentityT2 m1 m2 a
-untransrollI2 = IdentityT2 . untransroll2 . runIdentityT
+transfoldI2 :: (Monad m1, MonadTrans_ m2 t2) => IdentityT2 m1 m2 a -> IdentityT (t2 m1) a
+transfoldI2 = IdentityT . transfold2 . runIdentityT2
+untransfoldI2 :: (Monad m1, MonadTrans_ m2 t2) => IdentityT (t2 m1) a -> IdentityT2 m1 m2 a
+untransfoldI2 = IdentityT2 . untransfold2 . runIdentityT
 
 lift2IdentityT2 :: (m1 (m2 a) -> n1 (n2 b) -> p1 (p2 c)) -> IdentityT2 m1 m2 a -> IdentityT2 n1 n2 b -> IdentityT2 p1 p2 c
 lift2IdentityT2 f a b = IdentityT2 (f (runIdentityT2 a) (runIdentityT2 b))
@@ -199,10 +199,10 @@
 instance (MonadIO m1, Monad m1, Monad m2, Traversable m2, Monad m3, Traversable m3) => MonadIO (IdentityT3 m1 m2 m3) where
     liftIO = IdentityT3 . (-**) . liftIO
 
-transrollI3 :: (Monad m1, Monad (t2 m1), MonadTrans_ m2 t2, MonadTrans_ m3 t3) => IdentityT3 m1 m2 m3 a -> IdentityT (t3 (t2 m1)) a
-transrollI3 = IdentityT . transroll3 . runIdentityT3
-untransrollI3 :: (Monad m1, Monad (t2 m1), MonadTrans_ m2 t2, MonadTrans_ m3 t3) => IdentityT (t3 (t2 m1)) a -> IdentityT3 m1 m2 m3 a
-untransrollI3 = IdentityT3 . untransroll3 . runIdentityT
+transfoldI3 :: (Monad m1, Monad (t2 m1), MonadTrans_ m2 t2, MonadTrans_ m3 t3) => IdentityT3 m1 m2 m3 a -> IdentityT (t3 (t2 m1)) a
+transfoldI3 = IdentityT . transfold3 . runIdentityT3
+untransfoldI3 :: (Monad m1, Monad (t2 m1), MonadTrans_ m2 t2, MonadTrans_ m3 t3) => IdentityT (t3 (t2 m1)) a -> IdentityT3 m1 m2 m3 a
+untransfoldI3 = IdentityT3 . untransfold3 . runIdentityT
 
 lift2IdentityT3 :: (m1 (m2 (m3 a)) -> n1 (n2 (n3 b)) -> p1 (p2 (p3 c))) -> IdentityT3 m1 m2 m3 a -> IdentityT3 n1 n2 n3 b -> IdentityT3 p1 p2 p3 c
 lift2IdentityT3 f a b = IdentityT3 (f (runIdentityT3 a) (runIdentityT3 b))
@@ -259,10 +259,10 @@
 instance (MonadIO m1, Monad m1, Monad m2, Traversable m2, Monad m3, Traversable m3, Monad m4, Traversable m4) => MonadIO (IdentityT4 m1 m2 m3 m4) where
     liftIO = IdentityT4 . (-***) . liftIO
 
-transrollI4 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4) => IdentityT4 m1 m2 m3 m4 a -> IdentityT (t4 (t3 (t2 m1))) a
-transrollI4 = IdentityT . transroll4 . runIdentityT4
-untransrollI4 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4) => IdentityT (t4 (t3 (t2 m1))) a -> IdentityT4 m1 m2 m3 m4 a
-untransrollI4 = IdentityT4 . untransroll4 . runIdentityT
+transfoldI4 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4) => IdentityT4 m1 m2 m3 m4 a -> IdentityT (t4 (t3 (t2 m1))) a
+transfoldI4 = IdentityT . transfold4 . runIdentityT4
+untransfoldI4 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4) => IdentityT (t4 (t3 (t2 m1))) a -> IdentityT4 m1 m2 m3 m4 a
+untransfoldI4 = IdentityT4 . untransfold4 . runIdentityT
 
 lift2IdentityT4 :: (m1 (m2 (m3 (m4 a))) -> n1 (n2 (n3 (n4 b))) -> p1 (p2 (p3 (p4 c)))) -> IdentityT4 m1 m2 m3 m4 a -> IdentityT4 n1 n2 n3 n4 b -> IdentityT4 p1 p2 p3 p4 c
 lift2IdentityT4 f a b = IdentityT4 (f (runIdentityT4 a) (runIdentityT4 b))
@@ -337,12 +337,12 @@
 instance (MonadIO m1, Monad m1, Monad m2, Traversable m2, Monad m3, Traversable m3, Monad m4, Traversable m4, Monad m5, Traversable m5) => MonadIO (IdentityT5 m1 m2 m3 m4 m5) where
     liftIO = IdentityT5 . (-****) . liftIO
 
-transrollI5 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4, MonadTrans_ m5 t5) => 
+transfoldI5 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4, MonadTrans_ m5 t5) => 
                 IdentityT5 m1 m2 m3 m4 m5 a -> IdentityT (t5 (t4 (t3 (t2 m1)))) a
-transrollI5 = IdentityT . transroll5 . runIdentityT5
-untransrollI5 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4, MonadTrans_ m5 t5) => 
+transfoldI5 = IdentityT . transfold5 . runIdentityT5
+untransfoldI5 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4, MonadTrans_ m5 t5) => 
                   IdentityT (t5 (t4 (t3 (t2 m1)))) a -> IdentityT5 m1 m2 m3 m4 m5 a
-untransrollI5 = IdentityT5 . untransroll5 . runIdentityT
+untransfoldI5 = IdentityT5 . untransfold5 . runIdentityT
 
 lift2IdentityT5 :: (m1 (m2 (m3 (m4 (m5 a)))) -> n1 (n2 (n3 (n4 (n5 b)))) -> p1 (p2 (p3 (p4 (p5 c))))) -> IdentityT5 m1 m2 m3 m4 m5 a -> IdentityT5 n1 n2 n3 n4 n5 b -> IdentityT5 p1 p2 p3 p4 p5 c
 lift2IdentityT5 f a b = IdentityT5 (f (runIdentityT5 a) (runIdentityT5 b))
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
 # deepcontrol
 
-A Haskell library that enables more deeper level style programming than the usual Control.xxx modules express, especially for Applicative and Monad.
+A Haskell library that provides more deeper level style of programming than the usual Control.Applicative and Control.Monad modules express.
 
 ## Examples
 
-### [Applicative](https://hackage.haskell.org/package/deepcontrol-0.5.3.0/docs/DeepControl-Applicative.html)
+### [Applicative](https://hackage.haskell.org/package/deepcontrol-0.5.4.0/docs/DeepControl-Applicative.html)
 
 This module enables you to program in applicative style for more deeper level than the usual Applicative module expresses.
 You would soon realize exactly what more deeper level means by reading the example codes below in order.
@@ -182,7 +182,7 @@
 
 Work well likewise.
 
-### [Monad](https://hackage.haskell.org/package/deepcontrol-0.5.3.0/docs/DeepControl-Monad.html)
+### [Monad](https://hackage.haskell.org/package/deepcontrol-0.5.4.0/docs/DeepControl-Monad.html)
 
 This module enables you to program in Monad for more deeper level than the usual Monad module expresses.
 You would soon realize exactly what more deeper level means by reading the example codes below in order.
@@ -202,7 +202,7 @@
 -- 7
 ```
 
-#### [Traversable](https://hackage.haskell.org/package/deepcontrol-0.5.3.0/docs/DeepControl-Traversable.html)
+#### [Traversable](https://hackage.haskell.org/package/deepcontrol-0.5.4.0/docs/DeepControl-Traversable.html)
 
 Identity, List, Maybe, Either, Except and Writer monads are sinkable monads.
 
@@ -286,7 +286,7 @@
 
 Work well likewise.
 
-### [Monad-Transformer](https://hackage.haskell.org/package/deepcontrol-0.5.3.0/docs/DeepControl-Monad-Trans.html)
+### [Monad-Transformer](https://hackage.haskell.org/package/deepcontrol-0.5.4.0/docs/DeepControl-Monad-Trans.html)
 
 #### Level-2
 
@@ -297,7 +297,7 @@
 import DeepControl.Traversable (sink)
 import DeepControl.Monad ((>-))
 import DeepControl.Monad.Morph ((|*|), (|>|))
-import DeepControl.Monad.Trans (transroll2, untransroll2)
+import DeepControl.Monad.Trans (transfold2, untransfold2)
 import DeepControl.Monad.Trans.Identity (Identity(..), IdentityT(..), IdentityT2(..))
 import Control.Monad.Reader
 import Control.Monad.Trans.Maybe
@@ -331,44 +331,44 @@
 
 ackermann' :: Int -> Int -> 
               ReaderT TimeLimit (MaybeT IO) Int                 -- ReaderT-MaybeT-IO monad
-ackermann' x y = (transroll2 . runIdentityT2) |>| ackermann x y -- You can get usual ReaderT-MaybeT-IO function from ReaderT-IdentityT2-IO-Maybe function
+ackermann' x y = (transfold2 . runIdentityT2) |>| ackermann x y -- You can get usual ReaderT-MaybeT-IO function from ReaderT-IdentityT2-IO-Maybe function
                                                                 -- (|>|) is the level-1 trans-map function, analogous to (|$>)
 
 ackermann'' :: Int -> Int -> 
                ReaderT TimeLimit (IdentityT2 IO Maybe) Int       -- ReaderT-IdentityT2-IO-Maybe monad
-ackermann'' x y = (IdentityT2 . untransroll2) |>| ackermann' x y -- You can get ReaderT-IdentityT2-IO-Maybe function from usual ReaderT-MaybeT-IO function
+ackermann'' x y = (IdentityT2 . untransfold2) |>| ackermann' x y -- You can get ReaderT-IdentityT2-IO-Maybe function from usual ReaderT-MaybeT-IO function
 ```
 #### Level-3, Level-4 and Level-5
 
 Work well likewise.
 
-transroll and untransroll:
+transfold and untransfold:
 
     Prelude> :m DeepControl.Monad.Trans 
     > :m + Control.Monad.Trans.List Control.Monad.Trans.Maybe
     > :m + DeepControl.Monad.Trans.Identity DeepControl.Monad.Trans.Except DeepControl.Monad.Trans.Writer
 
-    > transroll3 $ ExceptT (Identity (Right [Just 1]))    -- note: type Except e = ExceptT e Identity
+    > transfold3 $ ExceptT (Identity (Right [Just 1]))    -- note: type Except e = ExceptT e Identity
     MaybeT (ListT (ExceptT (Identity (Right [Just 1]))))
 
     > :t ExceptT (Identity (Right [Just 1]))
     ExceptT (Identity (Right [Just 1]))
       :: Num a => ExceptT e Identity [Maybe a]
-    > :t transroll3 $ ExceptT (Identity (Right [Just 1]))
-    transroll3 $ ExceptT (Identity (Right [Just 1]))
+    > :t transfold3 $ ExceptT (Identity (Right [Just 1]))
+    transfold3 $ ExceptT (Identity (Right [Just 1]))
       :: Num a => MaybeT (ListT (ExceptT e Identity)) a
 
-    > untransroll3 $ MaybeT (ListT (ExceptT (Identity (Right [Just 1]))))
+    > untransfold3 $ MaybeT (ListT (ExceptT (Identity (Right [Just 1]))))
     ExceptT (Identity (Right [Just 1]))
 
     > :t MaybeT (ListT (ExceptT (Identity (Right [Just 1]))))
     MaybeT (ListT (ExceptT (Identity (Right [Just 1]))))
       :: Num a => MaybeT (ListT (ExceptT e Identity)) a
-    > :t untransroll3 $ MaybeT (ListT (ExceptT (Identity (Right [Just 1]))))
-    untransroll3 $ MaybeT (ListT (ExceptT (Identity (Right [Just 1]))))
+    > :t untransfold3 $ MaybeT (ListT (ExceptT (Identity (Right [Just 1]))))
+    untransfold3 $ MaybeT (ListT (ExceptT (Identity (Right [Just 1]))))
       :: Num a => ExceptT e Identity [Maybe a]
 
-### [Monad-Morph](https://hackage.haskell.org/package/deepcontrol-0.5.3.0/docs/DeepControl-Monad-Morph.html)
+### [Monad-Morph](https://hackage.haskell.org/package/deepcontrol-0.5.4.0/docs/DeepControl-Monad-Morph.html)
 
 #### SinkT
 
@@ -497,4 +497,4 @@
 
 Work well likewise.
 
-### [Arrow](https://hackage.haskell.org/package/deepcontrol-0.5.3.0/docs/DeepControl-Arrow.html)
+### [Arrow](https://hackage.haskell.org/package/deepcontrol-0.5.4.0/docs/DeepControl-Arrow.html)
diff --git a/deepcontrol.cabal b/deepcontrol.cabal
--- a/deepcontrol.cabal
+++ b/deepcontrol.cabal
@@ -1,7 +1,7 @@
 name:                deepcontrol
-version:             0.5.3.0
-synopsis:            Provide more deeper level style of programming than the usual Control.xxx modules express
-description:         This module provides more deeper level style of programming than the usual Control.xxx modules express, especially for Applicative and Monad.
+version:             0.5.4.0
+synopsis:            Provide deep level programming style for Applicative and Monad
+description:         This module provides more deeper level style of programming than the usual Applicative and Monad modules express.
 license:             BSD3
 license-file:        LICENSE
 author:              KONISHI Yohsuke
diff --git a/test/unit_Monad-Level2.hs b/test/unit_Monad-Level2.hs
--- a/test/unit_Monad-Level2.hs
+++ b/test/unit_Monad-Level2.hs
@@ -255,10 +255,10 @@
 -- StateT-IdentityT-MaybeT-IO
 
 popSIM :: StateT [a] (MaybeT IO) a
-popSIM = (transroll2 . runIdentityT2) |>| popSI2
+popSIM = (transfold2 . runIdentityT2) |>| popSI2
 
 polandSIM :: String -> StateT [Double] (MaybeT IO) Double
-polandSIM s = (transroll2 . runIdentityT2) |>| polandSI2 s
+polandSIM s = (transfold2 . runIdentityT2) |>| polandSI2 s
 
 poland_calcSIM :: [String] -> IO (Maybe (Double, [Double]))
 poland_calcSIM xs = (sinkmap polandSIM xs >> popSIM) >- \x -> runStateT x []
@@ -328,11 +328,11 @@
 -- StateT-IdentityT3-IO-Except-Maybe
 
 pushSI3 :: a -> StateT [a] (IdentityT3 IO (Except ()) Maybe) a
-pushSI3 x = (IdentityT3 . untransroll3 . runIdentityT) |>| pushSIME x
+pushSI3 x = (IdentityT3 . untransfold3 . runIdentityT) |>| pushSIME x
 popSI3 :: StateT [a] (IdentityT3 IO (Except ()) Maybe) a
-popSI3 = (IdentityT3 . untransroll3 . runIdentityT) |>| popSIME
+popSI3 = (IdentityT3 . untransfold3 . runIdentityT) |>| popSIME
 polandSI3 :: String -> StateT [Double] (IdentityT3 IO (Except ()) Maybe) Double
-polandSI3 x = (IdentityT3 . untransroll3 . runIdentityT) |>| polandSIME x
+polandSI3 x = (IdentityT3 . untransfold3 . runIdentityT) |>| polandSIME x
 
 poland_calcSI3 :: [String] -> IO (Either () (Maybe (Double, [Double])))
 poland_calcSI3 xs = (sinkmap polandSI3 xs >> popSI3) >- \x -> runStateT x []
diff --git a/test/unit_MonadTrans-ackermann.hs b/test/unit_MonadTrans-ackermann.hs
--- a/test/unit_MonadTrans-ackermann.hs
+++ b/test/unit_MonadTrans-ackermann.hs
@@ -4,7 +4,7 @@
 import DeepControl.Traversable (sink)
 import DeepControl.Monad ((>-))
 import DeepControl.Monad.Morph ((|*|), (|>|))
-import DeepControl.Monad.Trans (transroll2, untransroll2)
+import DeepControl.Monad.Trans (transfold2, untransfold2)
 import DeepControl.Monad.Trans.Identity (Identity(..), IdentityT(..), IdentityT2(..))
 import Control.Monad.Reader
 import Control.Monad.Trans.Maybe
@@ -37,7 +37,7 @@
 
 ackermann' :: Int -> Int -> 
               ReaderT TimeLimit (MaybeT IO) Int                 -- ReaderT-MaybeT-IO monad
-ackermann' x y = (transroll2 . runIdentityT2) |>| ackermann x y -- You can get usual ReaderT-MaybeT-IO function from ReaderT-IdentityT2-IO-Maybe function
+ackermann' x y = (transfold2 . runIdentityT2) |>| ackermann x y -- You can get usual ReaderT-MaybeT-IO function from ReaderT-IdentityT2-IO-Maybe function
 
 calc_ackermann' :: TimeLimit -> Int -> Int -> IO (Maybe Int)
 calc_ackermann' timelimit x y = ackermann' x y >- \r -> runReaderT r timelimit
@@ -45,7 +45,7 @@
 
 ackermann'' :: Int -> Int -> 
                ReaderT TimeLimit (IdentityT2 IO Maybe) Int       -- ReaderT-IdentityT2-IO-Maybe monad
-ackermann'' x y = (IdentityT2 . untransroll2) |>| ackermann' x y -- You can get ReaderT-IdentityT2-IO-Maybe function from usual ReaderT-MaybeT-IO function
+ackermann'' x y = (IdentityT2 . untransfold2) |>| ackermann' x y -- You can get ReaderT-IdentityT2-IO-Maybe function from usual ReaderT-MaybeT-IO function
 
 calc_ackermann'' :: TimeLimit -> Int -> Int -> IO (Maybe Int)
 calc_ackermann'' timelimit x y = ackermann'' x y >- \r -> runReaderT r timelimit