diff --git a/DeepControl/Applicative.hs b/DeepControl/Applicative.hs
--- a/DeepControl/Applicative.hs
+++ b/DeepControl/Applicative.hs
@@ -9,7 +9,7 @@
 Portability : portable
 
 This module enables you to program in applicative style for __much deeper level__ than the usual 'Control.Applicative' module expresses.
-You would soon realize exactly what __/much deeper level/__ means by reading the example codes in order, which are attached on the functions below.
+You would soon realize exactly what __/much deeper level/__ means by reading the example example codes attached on the functions below.
 -}
 module DeepControl.Applicative (
     module Control.Applicative,
diff --git a/DeepControl/Monad.hs b/DeepControl/Monad.hs
--- a/DeepControl/Monad.hs
+++ b/DeepControl/Monad.hs
@@ -9,16 +9,15 @@
 Portability : ---
 
 This module enables you to program in Monad for __much deeper level__ than the usual 'Control.Monad' module expresses.
-You would soon realize exactly what __/much deeper level/__ means by reading the example codes in order, which are attached on the Monadx(Monad, Monad, etc) classes below.
+You would soon realize exactly what __/much deeper level/__ means by reading the example codes attached on some functions below.
 
 Note: 
 
     * This module never makes mtl(monad-transformer-library) unnessasary at all. 
-      The range of monad for which this module is effective is confined to the range that the instances of @'Traversable'@ are defined.
+      The range of monad, for which this module is effective,  is confined to the range that the instances of @'Traversable'@ are defined.
       This means disappointingly that this module is not effective for not-Traversable monads such as 'Reader' and 'State'.
-
-    * In my opinion this imperfection is hard-wired with the ability of GHC on lambda expression; GHC is unable to parse @(r->)@ or @((->) r)@　yet.
-      Therefore some fundamental expressions such as @(r->)|$>@ or @fmap (r->)@ are useless, it might be theoretically impossible though.
+    * In my opinion this imperfection is hard-wired with the ability of GHC on lambda expression; GHC is unable to parse "@(r->)@" or "@((->) r)@" yet.
+      Therefore some fundamental expressions such as "@(r->)|$>@" or "@fmap (r->)@" are useless, though such calculations might theoretically or mathematically be impossible.
 
 -}
 {-# LANGUAGE TypeSynonymInstances #-}
@@ -230,7 +229,7 @@
 -- ("b",2)
 -- [["a0","b0"],["a0","b1","b2"],["a1","a2","b0"],["a1","a2","b1","b2"]]
 --
--- This messy code above can be neatly rewritten to the code below by grace of the cover functions.
+-- Any messy code like this can be neatly rewritten to a code below by grace of some cover functions.
 --
 -- >>> :{
 --  -- IO-List-List monad
diff --git a/DeepControl/Monad/Morph.hs b/DeepControl/Monad/Morph.hs
--- a/DeepControl/Monad/Morph.hs
+++ b/DeepControl/Monad/Morph.hs
@@ -2,28 +2,28 @@
 Module      : DeepControl.Monad.Morph
 Description : Deepened the usual Control.Monad.Morph module.
 Copyright   : 2013 Gabriel Gonzalez,
-              (c) 2015 KONISHI Yohsuke 
+              (c) 2015 KONISHI Yohsuke
 License     : BSD-style (see the LICENSE file in the distribution)
 Maintainer  : ocean0yohsuke@gmail.com
 Stability   : experimental
 Portability : ---
 
-This module enables you to program in Monad-Morphic style for more __deeper__ level than the usual @Control.Monad.Morph@ module expresses.
-You would realize exactly what __/more deeper level/__ means by reading the example codes, which are attached on the page bottom.
+This module enables you to program in Monad-Morphic style for much __deeper__ level than the usual @Control.Monad.Morph@ module expresses.
+You would realize exactly what __/much deeper level/__ means by reading the example codes, which are attached on the page bottom.
 -}
-{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE FlexibleInstances     #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeSynonymInstances #-}
-{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE RankNTypes            #-}
+{-# LANGUAGE TypeSynonymInstances  #-}
 module DeepControl.Monad.Morph (
     module Control.Monad.Morph,
 
     -- * SinkT
-    SinkT(..), sinkT2, sinkT3, sinkT4, 
+    SinkT(..), sinkT2, sinkT3, sinkT4,
 
     -- * Level-1
     -- ** trans-map
-    (|>|), (|<|), 
+    (|>|), (|<|),
     -- ** trans-sequence
     (|>~),
     -- ** trans-cover
@@ -40,9 +40,9 @@
     (|>>=>),
     -- ** trans-map
     (|>>|), (|<<|),
-    -- ** trans-cover  
+    -- ** trans-cover
     (|**|),
-    (|-*|), 
+    (|-*|),
 
     -- * Level-3
     -- ** trans-bind
@@ -53,10 +53,10 @@
     (|>>>=>),
      -- ** trans-map
     (|>>>|), (|<<<|),
-    -- ** trans-cover  
+    -- ** trans-cover
     (|***|),
-    (|--*|), 
-    (|-**|), (|*-*|), 
+    (|--*|),
+    (|-**|), (|*-*|),
 
     -- * Level-4
     -- ** trans-bind
@@ -69,7 +69,7 @@
     (|****|),
     (|---*|),
     (|--**|), (|-*-*|), (|*--*|),
-    (|-***|), (|*-**|), (|**-*|), 
+    (|-***|), (|*-**|), (|**-*|),
 
     -- * Level-5
     -- ** trans-bind
@@ -80,38 +80,39 @@
     (|>>>>>|), (|<<<<<|),
     -- ** trans-cover
     (|*****|),
-    (|----*|), 
-    (|---**|), (|--*-*|), (|-*--*|), (|*---*|), 
+    (|----*|),
+    (|---**|), (|--*-*|), (|-*--*|), (|*---*|),
     (|--***|), (|-*-**|), (|*--**|), (|*-*-*|), (|-**-*|), (|**--*|),
-    (|-****|), (|*-***|), (|**-**|), (|***-*|), 
+    (|-****|), (|*-***|), (|**-**|), (|***-*|),
 
     -- * Level-2 example: trans-map
     -- $Example
 
-    -- * Level-2 example: trans-cover and trans-bind 
+    -- * Level-2 example: trans-cover and trans-bind
     -- $Example-2
 
-    ) where 
+    ) where
 
-import DeepControl.Applicative
-import DeepControl.Traversable
-import DeepControl.Monad.Trans
+import           DeepControl.Applicative
+import           DeepControl.Monad.Trans
+import           DeepControl.Traversable
 
-import Control.Monad.Morph
-import Control.Monad.Identity (Identity(..))
-import Control.Monad.Trans.Identity (IdentityT(..))
-import Control.Monad.Trans.Maybe (MaybeT(..))
-import Control.Monad.List (ListT(..))
-import Control.Monad.Except (Except, ExceptT(..), runExcept, runExceptT)
-import Control.Monad.Writer (Writer, WriterT(..), runWriter)
-import Data.Monoid 
+import           Control.Monad.Except         (Except, ExceptT (..), runExcept,
+                                               runExceptT)
+import           Control.Monad.Identity       (Identity (..))
+import           Control.Monad.List           (ListT (..))
+import           Control.Monad.Morph
+import           Control.Monad.Trans.Identity (IdentityT (..))
+import           Control.Monad.Trans.Maybe    (MaybeT (..))
+import           Control.Monad.Writer         (Writer, WriterT (..), runWriter)
+import           Data.Monoid
 
 -------------------------------------------------------------------------------
 -- SinkT
 
 class (MonadTrans s) => SinkT s where
     -- | Alalog to @'DeepControl.Traversable.sink'@.
-    -- 
+    --
     -- >>> sinkT $ MaybeT (ListT (Right [Just 1]))
     -- ListT (MaybeT (Right (Just [1])))
     --
@@ -119,7 +120,7 @@
     -- ListT (MaybeT (ExceptT (Identity (Right (Just [1])))))
     --
     sinkT :: (Monad m, MMonad t,
-              MonadTrans_ x t, Traversable x) => 
+              MonadTrans_ x t, Traversable x) =>
              s (t m) a -> t (s m) a
 
 instance SinkT IdentityT where
@@ -138,26 +139,26 @@
         flipTuple (x,y) = (y,x)
 
 -- | Alalog to @'DeepControl.Traversable.sink2'@.
--- 
+--
 -- >>> sinkT2 $ MaybeT (ListT (ExceptT (Identity (Right [Just 1]))))
 -- ListT (ExceptT (MaybeT (Identity (Just (Right [1])))))
 --
-sinkT2 :: (Monad m, Monad (s (t2 m)), Monad (t2 m), 
-           MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, 
+sinkT2 :: (Monad m, Monad (s (t2 m)), Monad (t2 m),
+           MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2,
            SinkT s, MMonad t1, MMonad t2) =>
           s (t1 (t2 m)) a -> t1 (t2 (s m)) a
 sinkT2 = (sinkT|>|) . sinkT
 
-sinkT3 
-  :: (Monad m, Monad (s (t2 (t3 m))), Monad (s (t3 m)), Monad (t2 (t3 m)), Monad (t3 m), 
-      MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, MonadTrans_ x3 t3, Traversable x3, 
+sinkT3
+  :: (Monad m, Monad (s (t2 (t3 m))), Monad (s (t3 m)), Monad (t2 (t3 m)), Monad (t3 m),
+      MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, MonadTrans_ x3 t3, Traversable x3,
       SinkT s, MMonad t1, MMonad t2, MMonad t3) =>
      s (t1 (t2 (t3 m))) a -> t1 (t2 (t3 (s m))) a
 sinkT3 = (sinkT2|>|) . sinkT
 
 sinkT4
-  :: (Monad m, Monad (s (t2 (t3 (t4 m)))), Monad (s (t3 (t4 m))), Monad (s (t4 m)), Monad (t2 (t3 (t4 m))), Monad (t3 (t4 m)), Monad (t4 m), 
-      MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, MonadTrans_ x3 t3, Traversable x3, MonadTrans_ x4 t4, Traversable x4, 
+  :: (Monad m, Monad (s (t2 (t3 (t4 m)))), Monad (s (t3 (t4 m))), Monad (s (t4 m)), Monad (t2 (t3 (t4 m))), Monad (t3 (t4 m)), Monad (t4 m),
+      MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, MonadTrans_ x3 t3, Traversable x3, MonadTrans_ x4 t4, Traversable x4,
       MMonad t1, MMonad t2, MMonad t3, MMonad t4, SinkT s) =>
      s (t1 (t2 (t3 (t4 m)))) a -> t1 (t2 (t3 (t4 (s m)))) a
 sinkT4 = (sinkT3|>|) . sinkT
@@ -177,7 +178,7 @@
 
 infixl 5 |*|
 -- | Alias to @'lift'@
-(|*|) :: (Monad m, MonadTrans t) => m a -> t m a 
+(|*|) :: (Monad m, MonadTrans t) => m a -> t m a
 (|*|) = lift
 
 infixr 3  |>=>
@@ -194,37 +195,37 @@
 infixr 3  |>>=
 -- | The level-2 trans-bind function, analogous to ('>>=')
 (|>>=) :: (Monad n, Monad m, Monad (t2 n), Monad (t2 (t2 n)),
-           MonadTrans_ x t1, Traversable x, 
-           MMonad t1, MMonad t2, SinkT t2) => 
+           MonadTrans_ x t1, Traversable x,
+           MMonad t1, MMonad t2, SinkT t2) =>
           t1 (t2 m) b -> (forall a. m a -> t1 (t2 n) a) -> t1 (t2 n) b
 m |>>= f = m |>= \x -> squash |>| (sinkT $ f |>| x)
 
 infixr 3  |>>~
 (|>>~) :: (Monad n, Monad m, Monad (t2 n), Monad (t2 (t2 n)),
-           MonadTrans_ x t1, Traversable x, 
-           MMonad t1, MMonad t2, SinkT t2) => 
+           MonadTrans_ x t1, Traversable x,
+           MMonad t1, MMonad t2, SinkT t2) =>
           t1 (t2 m) b -> (forall a. t1 (t2 n) a) -> t1 (t2 n) b
 m |>>~ k = m |>>= \_ -> k
 
 infixr 3  |>>=>
-(|>>=>) :: (Monad m3, Monad m2, Monad (t2 m3), Monad (t2 (t2 m3)), 
-            MonadTrans_ x t1, Traversable x, 
-            MMonad t1, MMonad t2, SinkT t2) => 
+(|>>=>) :: (Monad m3, Monad m2, Monad (t2 m3), Monad (t2 (t2 m3)),
+            MonadTrans_ x t1, Traversable x,
+            MMonad t1, MMonad t2, SinkT t2) =>
            (forall a. m1 a -> t1 (t2 m2) a) -> (forall b. m2 b -> t1 (t2 m3) b) -> m1 c -> t1 (t2 m3) c
 f |>>=> g = \x -> f x |>>= g
 
 infixl 4  |>>|
-(|>>|) :: (Monad m, Monad (t2 m), MFunctor t1, MFunctor t2) => 
+(|>>|) :: (Monad m, Monad (t2 m), MFunctor t1, MFunctor t2) =>
           (forall a . m a -> n a) -> t1 (t2 m) b -> t1 (t2 n) b
 (|>>|) f g = (f |>|) |>| g
 
 infixl 4  |<<|
-(|<<|) :: (Monad m, Monad (t2 m), MFunctor t1, MFunctor t2) => 
+(|<<|) :: (Monad m, Monad (t2 m), MFunctor t1, MFunctor t2) =>
            t1 (t2 m) b -> (forall a . m a -> n a) -> t1 (t2 n) b
 (|<<|) f g = (g |>|) |>| f
 
 infixl 5 |**|
-(|**|) :: (Monad m, MonadTrans t1, MonadTrans t2, Monad (t2 m)) => m a -> t1 (t2 m) a 
+(|**|) :: (Monad m, MonadTrans t1, MonadTrans t2, Monad (t2 m)) => m a -> t1 (t2 m) a
 (|**|) = (|*|) . (|*|)
 
 infixl 5  |-*|
@@ -235,65 +236,65 @@
 -- Level-3 functions
 
 infixr 3  |>>>=
-(|>>>=) :: 
-   (Monad n, Monad (t3 n), Monad m, Monad (t3 m), 
-    Monad (t2 (t3 n)), Monad (t2 (t3 (t3 n))), Monad (t3 (t3 n)), Monad (t3 (t2 (t3 n))), Monad (t2 (t2 (t3 n))), 
-    MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, 
-    SinkT t2, SinkT t3, 
-    MMonad t1, MMonad t2, MMonad t3) => 
+(|>>>=) ::
+   (Monad n, Monad (t3 n), Monad m, Monad (t3 m),
+    Monad (t2 (t3 n)), Monad (t2 (t3 (t3 n))), Monad (t3 (t3 n)), Monad (t3 (t2 (t3 n))), Monad (t2 (t2 (t3 n))),
+    MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2,
+    SinkT t2, SinkT t3,
+    MMonad t1, MMonad t2, MMonad t3) =>
    t1 (t2 (t3 m)) b -> (forall a. m a -> t1 (t2 (t3 n)) a) -> t1 (t2 (t3 n)) b
 m |>>>= f = m |>>= \x -> squash |>>| (sinkT2 $ f |>| x)
 
 infixr 3  |>>>~
-(|>>>~) :: 
-   (Monad n, Monad (t3 n), Monad m, Monad (t3 m), 
-    Monad (t2 (t3 n)), Monad (t2 (t3 (t3 n))), Monad (t3 (t3 n)), Monad (t3 (t2 (t3 n))), Monad (t2 (t2 (t3 n))), 
-    MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, 
-    SinkT t2, SinkT t3, 
-    MMonad t1, MMonad t2, MMonad t3) => 
+(|>>>~) ::
+   (Monad n, Monad (t3 n), Monad m, Monad (t3 m),
+    Monad (t2 (t3 n)), Monad (t2 (t3 (t3 n))), Monad (t3 (t3 n)), Monad (t3 (t2 (t3 n))), Monad (t2 (t2 (t3 n))),
+    MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2,
+    SinkT t2, SinkT t3,
+    MMonad t1, MMonad t2, MMonad t3) =>
    t1 (t2 (t3 m)) b -> (forall a. t1 (t2 (t3 n)) a) -> t1 (t2 (t3 n)) b
 m |>>>~ k = m |>>>= \_ -> k
 
 infixr 3  |>>>=>
-(|>>>=>) :: (Monad m3, Monad m2, Monad (t2 m3), Monad (t2 (t2 m3)), Monad (t2 (t2 (t3 m3))), Monad (t2 (t3 m3)), Monad (t2 (t3 (t3 m3))), 
-             Monad (t3 m3), Monad (t3 m2), Monad (t3 (t2 (t3 m3))), Monad (t3 (t3 m3)), 
-             MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, 
-             MMonad t1, MMonad t2, MMonad t3, SinkT t2, SinkT t3) => 
+(|>>>=>) :: (Monad m3, Monad m2, Monad (t2 m3), Monad (t2 (t2 m3)), Monad (t2 (t2 (t3 m3))), Monad (t2 (t3 m3)), Monad (t2 (t3 (t3 m3))),
+             Monad (t3 m3), Monad (t3 m2), Monad (t3 (t2 (t3 m3))), Monad (t3 (t3 m3)),
+             MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2,
+             MMonad t1, MMonad t2, MMonad t3, SinkT t2, SinkT t3) =>
             (forall a. m1 a -> t1 (t2 (t3 m2)) a) -> (forall b. m2 b -> t1 (t2 (t3 m3)) b) -> m1 c -> t1 (t2 (t3 m3)) c
 f |>>>=> g = \x -> f x |>>>= g
 
 infixl 4  |>>>|
-(|>>>|) :: (Monad m, Monad (t3 m), Monad (t2 (t3 m)), MFunctor t1, MFunctor t2, MFunctor t3) => 
+(|>>>|) :: (Monad m, Monad (t3 m), Monad (t2 (t3 m)), MFunctor t1, MFunctor t2, MFunctor t3) =>
            (forall a . m a -> n a) -> t1 (t2 (t3 m)) b -> t1 (t2 (t3 n)) b
 (|>>>|) f g = (f |>|) |>>| g
 
 infixl 4  |<<<|
-(|<<<|) :: (Monad m, Monad (t3 m), Monad (t2 (t3 m)), MFunctor t1, MFunctor t2, MFunctor t3) => 
+(|<<<|) :: (Monad m, Monad (t3 m), Monad (t2 (t3 m)), MFunctor t1, MFunctor t2, MFunctor t3) =>
            t1 (t2 (t3 m)) b -> (forall a . m a -> n a) -> t1 (t2 (t3 n)) b
 (|<<<|) f g = (g |>|) |>>| f
 
 infixl 5 |***|
 (|***|) :: (Monad m, Monad (t2 (t3 m)), Monad (t3 m),
-            MonadTrans t1, MonadTrans t2, MonadTrans t3) => 
-            m a -> t1 (t2 (t3 m)) a 
+            MonadTrans t1, MonadTrans t2, MonadTrans t3) =>
+            m a -> t1 (t2 (t3 m)) a
 (|***|) = (|*|) . (|**|)
 
 infixl 5  |--*|
 (|--*|) :: (Monad m, Monad (t2 m),
-            MonadTrans t1, MonadTrans t2, MonadTrans t3, 
-            MFunctor t1, MFunctor t2) => 
+            MonadTrans t1, MonadTrans t2, MonadTrans t3,
+            MFunctor t1, MFunctor t2) =>
             t1 (t2 m) a -> t1 (t2 (t3 m)) a
 (|--*|) = ((|*|) |>>|)
 
 infixl 5  |-**|, |*-*|
 (|-**|) :: (Monad m, Monad (t2 (t3 m)), Monad (t3 m),
-            MonadTrans t1, MonadTrans t2, MonadTrans t3, 
-            MFunctor t1) => 
+            MonadTrans t1, MonadTrans t2, MonadTrans t3,
+            MFunctor t1) =>
             t1 m a -> t1 (t2 (t3 m)) a
 (|-**|) = ((|**|) |>|)
 (|*-*|) :: (Monad m, Monad (t3 m), Monad (t2 (t3 m)),
             MonadTrans t1, MonadTrans t2, MonadTrans t3,
-            MFunctor t2) => 
+            MFunctor t2) =>
             t2 m a -> t1 (t2 (t3 m)) a
 (|*-*|) = (|*|) . ((|*|) |>|)
 
@@ -301,81 +302,81 @@
 -- Level-4 functions
 
 infixr 4  |>>>>=
-(|>>>>=) :: 
+(|>>>>=) ::
    (Monad n, Monad (t4 n), Monad (t4 m), Monad m,
-    Monad (t2 (t3 (t4 n))), Monad (t2 (t3 (t4 (t4 n)))), Monad (t2 (t2 (t3 (t4 n)))), 
+    Monad (t2 (t3 (t4 n))), Monad (t2 (t3 (t4 (t4 n)))), Monad (t2 (t2 (t3 (t4 n)))),
     Monad (t3 (t4 n)), Monad (t3 (t4 (t4 n))), Monad (t4 (t4 n)), Monad (t4 (t2 (t3 (t4 n)))), Monad (t2 (t3 (t3 (t4 n)))), Monad (t4 (t3 (t4 n))),
-    Monad (t2 (t4 n)), Monad (t3 (t2 (t3 (t4 n)))), Monad (t3 (t3 (t4 n))), Monad (t3 (t4 m)), 
+    Monad (t2 (t4 n)), Monad (t3 (t2 (t3 (t4 n)))), Monad (t3 (t3 (t4 n))), Monad (t3 (t4 m)),
     MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, MonadTrans_ x3 t3, Traversable x3,
-    SinkT t2, SinkT t3, SinkT t4, 
-    MMonad t1, MMonad t2, MMonad t3, MMonad t4) => 
+    SinkT t2, SinkT t3, SinkT t4,
+    MMonad t1, MMonad t2, MMonad t3, MMonad t4) =>
    t1 (t2 (t3 (t4 m))) b -> (forall a. m a -> t1 (t2 (t3 (t4 n))) a) -> t1 (t2 (t3 (t4 n))) b
 m |>>>>= f = m |>>>= \x -> squash |>>>| (sinkT3 $ f |>| x)
 
 infixr 3  |>>>>~
-(|>>>>~) :: 
+(|>>>>~) ::
    (Monad n, Monad (t4 n), Monad (t4 m), Monad m,
-    Monad (t2 (t3 (t4 n))), Monad (t2 (t3 (t4 (t4 n)))), Monad (t2 (t2 (t3 (t4 n)))), 
+    Monad (t2 (t3 (t4 n))), Monad (t2 (t3 (t4 (t4 n)))), Monad (t2 (t2 (t3 (t4 n)))),
     Monad (t3 (t4 n)), Monad (t3 (t4 (t4 n))), Monad (t4 (t4 n)), Monad (t4 (t2 (t3 (t4 n)))), Monad (t2 (t3 (t3 (t4 n)))), Monad (t4 (t3 (t4 n))),
-    Monad (t2 (t4 n)), Monad (t3 (t2 (t3 (t4 n)))), Monad (t3 (t3 (t4 n))), Monad (t3 (t4 m)), 
+    Monad (t2 (t4 n)), Monad (t3 (t2 (t3 (t4 n)))), Monad (t3 (t3 (t4 n))), Monad (t3 (t4 m)),
     MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, MonadTrans_ x3 t3, Traversable x3,
-    SinkT t2, SinkT t3, SinkT t4, 
-    MMonad t1, MMonad t2, MMonad t3, MMonad t4) => 
+    SinkT t2, SinkT t3, SinkT t4,
+    MMonad t1, MMonad t2, MMonad t3, MMonad t4) =>
    t1 (t2 (t3 (t4 m))) b -> (forall a. t1 (t2 (t3 (t4 n))) a) -> t1 (t2 (t3 (t4 n))) b
 m |>>>>~ k = m |>>>>= \_ -> k
 
 infixl 4  |>>>>|
-(|>>>>|) :: (Monad m, Monad (t4 m), Monad (t3 (t4 m)), Monad (t2 (t3 (t4 m))), MFunctor t1, MFunctor t2, MFunctor t3, MFunctor t4) => 
+(|>>>>|) :: (Monad m, Monad (t4 m), Monad (t3 (t4 m)), Monad (t2 (t3 (t4 m))), MFunctor t1, MFunctor t2, MFunctor t3, MFunctor t4) =>
             (forall a . m a -> n a) -> t1 (t2 (t3 (t4 m))) b -> t1 (t2 (t3 (t4 n))) b
 (|>>>>|) f g = (f |>|) |>>>| g
 
 infixl 4  |<<<<|
-(|<<<<|) :: (Monad m, Monad (t4 m), Monad (t3 (t4 m)), Monad (t2 (t3 (t4 m))), MFunctor t1, MFunctor t2, MFunctor t3, MFunctor t4) => 
+(|<<<<|) :: (Monad m, Monad (t4 m), Monad (t3 (t4 m)), Monad (t2 (t3 (t4 m))), MFunctor t1, MFunctor t2, MFunctor t3, MFunctor t4) =>
             t1 (t2 (t3 (t4 m))) b -> (forall a . m a -> n a) -> t1 (t2 (t3 (t4 n))) b
 (|<<<<|) f g = (g |>|) |>>>| f
 
 infixl 5 |****|
 (|****|) :: (Monad m, Monad (t2 (t3 (t4 m))), Monad (t3 (t4 m)), Monad (t4 m),
-            MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => 
-            m a -> t1 (t2 (t3 (t4 m))) a 
+            MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) =>
+            m a -> t1 (t2 (t3 (t4 m))) a
 (|****|) = (|*|) . (|***|)
 
 infixl 5  |---*|
-(|---*|) :: (Monad m, Monad (t2 (t3 m)), Monad (t3 m), 
+(|---*|) :: (Monad m, Monad (t2 (t3 m)), Monad (t3 m),
             MFunctor t1, MFunctor t2, MFunctor t3,
-            MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => 
+            MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) =>
             t1 (t2 (t3 m)) a -> t1 (t2 (t3 (t4 m))) a
 (|---*|) = ((|*|) |>>>|)
 infixl 5  |--**|, |-*-*|
-(|--**|) :: (Monad m, Monad (t2 m), Monad (t4 m), 
+(|--**|) :: (Monad m, Monad (t2 m), Monad (t4 m),
             MFunctor t1, MFunctor t2,
-            MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => 
+            MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) =>
             t1 (t2 m) a -> t1 (t2 (t3 (t4 m))) a
 (|--**|) = ((|**|) |>>|)
 (|-*-*|) :: (Monad m, Monad (t3 m), Monad (t3 (t4 m)), Monad (t4 m),
             MFunctor t1, MFunctor t3,
-            MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => 
+            MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) =>
             t1 (t3 m) a -> t1 (t2 (t3 (t4 m))) a
 (|-*-*|) = ((|*-*|) |>|)
 (|*--*|) :: (Monad m, Monad (t3 m), Monad (t2 (t3 (t4 m))), Monad (t2 (t3 m)),
             MFunctor t2, MFunctor t3,
-            MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => 
+            MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) =>
             t2 (t3 m) a -> t1 (t2 (t3 (t4 m))) a
 (|*--*|) = (|*|) . (|--*|)
 infixl 5  |-***|, |*-**|, |**-*|
 (|-***|) :: (Monad m, Monad (t3 (t4 m)), Monad (t4 m),
-            MFunctor t1, 
-            MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => 
+            MFunctor t1,
+            MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) =>
             t1 m a -> t1 (t2 (t3 (t4 m))) a
 (|-***|) = ((|***|) |>|)
 (|*-**|) :: (Monad m, Monad (t2 (t3 (t4 m))), Monad (t3 (t4 m)), Monad (t4 m),
-            MFunctor t2, 
-            MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => 
+            MFunctor t2,
+            MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) =>
             t2 m a -> t1 (t2 (t3 (t4 m))) a
 (|*-**|) = (|*|) . (|-**|)
-(|**-*|) :: (Monad m, Monad (t2 (t3 (t4 m))), Monad (t3 (t4 m)), 
-            MFunctor t3, 
-            MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => 
+(|**-*|) :: (Monad m, Monad (t2 (t3 (t4 m))), Monad (t3 (t4 m)),
+            MFunctor t3,
+            MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) =>
             t3 m a -> t1 (t2 (t3 (t4 m))) a
 (|**-*|) = (|**|) . (|-*|)
 
@@ -383,129 +384,129 @@
 -- Level-5 functions
 
 infixr 4  |>>>>>=
-(|>>>>>=) :: 
+(|>>>>>=) ::
    (Monad n, Monad m, Monad (t5 n), Monad (t5 m),
-    Monad (t2 (t3 (t4 (t5 n)))), Monad (t2 (t3 (t4 (t5 (t5 n))))), Monad (t3 (t4 (t5 n))), Monad (t3 (t4 (t5 (t5 n)))), 
-    Monad (t4 (t5 n)), Monad (t4 (t5 (t5 n))), Monad (t5 (t2 (t3 (t4 (t5 n))))), Monad (t5 (t5 n)), Monad (t5 (t3 (t4 (t5 n)))), 
-    Monad (t2 (t2 (t3 (t4 (t5 n))))), Monad (t5 (t4 (t5 n))), Monad (t2 (t3 (t3 (t4 (t5 n))))), Monad (t2 (t3 (t4 (t4 (t5 n))))), 
-    Monad (t2 (t4 (t5 n))), Monad (t3 (t2 (t3 (t4 (t5 n))))), Monad (t3 (t3 (t4 (t5 n)))), Monad (t3 (t4 (t4 (t5 n)))), 
-    Monad (t3 (t4 (t5 m))), Monad (t4 (t2 (t3 (t4 (t5 n))))), Monad (t4 (t3 (t4 (t5 n)))), Monad (t4 (t4 (t5 n))), Monad (t4 (t5 m)), 
+    Monad (t2 (t3 (t4 (t5 n)))), Monad (t2 (t3 (t4 (t5 (t5 n))))), Monad (t3 (t4 (t5 n))), Monad (t3 (t4 (t5 (t5 n)))),
+    Monad (t4 (t5 n)), Monad (t4 (t5 (t5 n))), Monad (t5 (t2 (t3 (t4 (t5 n))))), Monad (t5 (t5 n)), Monad (t5 (t3 (t4 (t5 n)))),
+    Monad (t2 (t2 (t3 (t4 (t5 n))))), Monad (t5 (t4 (t5 n))), Monad (t2 (t3 (t3 (t4 (t5 n))))), Monad (t2 (t3 (t4 (t4 (t5 n))))),
+    Monad (t2 (t4 (t5 n))), Monad (t3 (t2 (t3 (t4 (t5 n))))), Monad (t3 (t3 (t4 (t5 n)))), Monad (t3 (t4 (t4 (t5 n)))),
+    Monad (t3 (t4 (t5 m))), Monad (t4 (t2 (t3 (t4 (t5 n))))), Monad (t4 (t3 (t4 (t5 n)))), Monad (t4 (t4 (t5 n))), Monad (t4 (t5 m)),
     MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, MonadTrans_ x3 t3, Traversable x3, MonadTrans_ x4 t4, Traversable x4,
-    SinkT t2, SinkT t3, SinkT t4, SinkT t5, 
-    MMonad t1, MMonad t2, MMonad t3, MMonad t4, MMonad t5) => 
+    SinkT t2, SinkT t3, SinkT t4, SinkT t5,
+    MMonad t1, MMonad t2, MMonad t3, MMonad t4, MMonad t5) =>
    t1 (t2 (t3 (t4 (t5 m)))) b -> (forall a. m a -> t1 (t2 (t3 (t4 (t5 n)))) a) -> t1 (t2 (t3 (t4 (t5 n)))) b
 m |>>>>>= f = m |>>>>= \x -> squash |>>>>| (sinkT4 $ f |>| x)
 
 infixr 3  |>>>>>~
-(|>>>>>~) :: 
+(|>>>>>~) ::
    (Monad n, Monad m, Monad (t5 n), Monad (t5 m),
-    Monad (t2 (t3 (t4 (t5 n)))), Monad (t2 (t3 (t4 (t5 (t5 n))))), Monad (t3 (t4 (t5 n))), Monad (t3 (t4 (t5 (t5 n)))), 
-    Monad (t4 (t5 n)), Monad (t4 (t5 (t5 n))), Monad (t5 (t2 (t3 (t4 (t5 n))))), Monad (t5 (t5 n)), Monad (t5 (t3 (t4 (t5 n)))), 
-    Monad (t2 (t2 (t3 (t4 (t5 n))))), Monad (t5 (t4 (t5 n))), Monad (t2 (t3 (t3 (t4 (t5 n))))), Monad (t2 (t3 (t4 (t4 (t5 n))))), 
-    Monad (t2 (t4 (t5 n))), Monad (t3 (t2 (t3 (t4 (t5 n))))), Monad (t3 (t3 (t4 (t5 n)))), Monad (t3 (t4 (t4 (t5 n)))), 
-    Monad (t3 (t4 (t5 m))), Monad (t4 (t2 (t3 (t4 (t5 n))))), Monad (t4 (t3 (t4 (t5 n)))), Monad (t4 (t4 (t5 n))), Monad (t4 (t5 m)), 
+    Monad (t2 (t3 (t4 (t5 n)))), Monad (t2 (t3 (t4 (t5 (t5 n))))), Monad (t3 (t4 (t5 n))), Monad (t3 (t4 (t5 (t5 n)))),
+    Monad (t4 (t5 n)), Monad (t4 (t5 (t5 n))), Monad (t5 (t2 (t3 (t4 (t5 n))))), Monad (t5 (t5 n)), Monad (t5 (t3 (t4 (t5 n)))),
+    Monad (t2 (t2 (t3 (t4 (t5 n))))), Monad (t5 (t4 (t5 n))), Monad (t2 (t3 (t3 (t4 (t5 n))))), Monad (t2 (t3 (t4 (t4 (t5 n))))),
+    Monad (t2 (t4 (t5 n))), Monad (t3 (t2 (t3 (t4 (t5 n))))), Monad (t3 (t3 (t4 (t5 n)))), Monad (t3 (t4 (t4 (t5 n)))),
+    Monad (t3 (t4 (t5 m))), Monad (t4 (t2 (t3 (t4 (t5 n))))), Monad (t4 (t3 (t4 (t5 n)))), Monad (t4 (t4 (t5 n))), Monad (t4 (t5 m)),
     MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, MonadTrans_ x3 t3, Traversable x3, MonadTrans_ x4 t4, Traversable x4,
-    SinkT t2, SinkT t3, SinkT t4, SinkT t5, 
-    MMonad t1, MMonad t2, MMonad t3, MMonad t4, MMonad t5) => 
+    SinkT t2, SinkT t3, SinkT t4, SinkT t5,
+    MMonad t1, MMonad t2, MMonad t3, MMonad t4, MMonad t5) =>
    t1 (t2 (t3 (t4 (t5 m)))) b -> (forall a. t1 (t2 (t3 (t4 (t5 n)))) a) -> t1 (t2 (t3 (t4 (t5 n)))) b
 m |>>>>>~ k = m |>>>>>= \_ -> k
 
 infixl 4  |>>>>>|
-(|>>>>>|) :: (Monad m, Monad (t5 m), Monad (t4 (t5 m)), Monad (t3 (t4 (t5 m))), Monad (t2 (t3 (t4 (t5 m)))), MFunctor t1, MFunctor t2, MFunctor t3, MFunctor t4, MFunctor t5) => 
+(|>>>>>|) :: (Monad m, Monad (t5 m), Monad (t4 (t5 m)), Monad (t3 (t4 (t5 m))), Monad (t2 (t3 (t4 (t5 m)))), MFunctor t1, MFunctor t2, MFunctor t3, MFunctor t4, MFunctor t5) =>
              (forall a . m a -> n a) -> t1 (t2 (t3 (t4 (t5 m)))) b -> t1 (t2 (t3 (t4 (t5 n)))) b
 (|>>>>>|) f g = (f |>|) |>>>>| g
 
 infixl 4  |<<<<<|
-(|<<<<<|) :: (Monad m, Monad (t5 m), Monad (t4 (t5 m)), Monad (t3 (t4 (t5 m))), Monad (t2 (t3 (t4 (t5 m)))), MFunctor t1, MFunctor t2, MFunctor t3, MFunctor t4, MFunctor t5) => 
+(|<<<<<|) :: (Monad m, Monad (t5 m), Monad (t4 (t5 m)), Monad (t3 (t4 (t5 m))), Monad (t2 (t3 (t4 (t5 m)))), MFunctor t1, MFunctor t2, MFunctor t3, MFunctor t4, MFunctor t5) =>
              t1 (t2 (t3 (t4 (t5 m)))) b -> (forall a . m a -> n a) -> t1 (t2 (t3 (t4 (t5 n)))) b
 (|<<<<<|) f g = (g |>|) |>>>>| f
 
 infixl 5 |*****|
-(|*****|) :: (Monad m, Monad (t2 (t3 (t4 (t5 m)))), Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)), Monad (t5 m), 
-              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => 
-              m a -> t1 (t2 (t3 (t4 (t5 m)))) a 
+(|*****|) :: (Monad m, Monad (t2 (t3 (t4 (t5 m)))), Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)), Monad (t5 m),
+              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) =>
+              m a -> t1 (t2 (t3 (t4 (t5 m)))) a
 (|*****|) = (|*|) . (|****|)
 
 infixl 5  |----*|
-(|----*|) :: (Monad m, Monad (t2 (t3 (t4 m))), Monad (t3 (t4 m)), Monad (t4 m), 
-              MFunctor t1, MFunctor t2, MFunctor t3, MFunctor t4, 
-              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => 
+(|----*|) :: (Monad m, Monad (t2 (t3 (t4 m))), Monad (t3 (t4 m)), Monad (t4 m),
+              MFunctor t1, MFunctor t2, MFunctor t3, MFunctor t4,
+              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) =>
               t1 (t2 (t3 (t4 m))) a -> t1 (t2 (t3 (t4 (t5 m)))) a
 (|----*|) = ((|*|) |>>>>|)
 
 infixl 5  |---**|, |--*-*|, |-*--*|, |*---*|
-(|---**|) :: (Monad m, Monad (t2 (t3 m)), Monad (t3 m), Monad (t5 m), 
+(|---**|) :: (Monad m, Monad (t2 (t3 m)), Monad (t3 m), Monad (t5 m),
               MFunctor t1, MFunctor t2, MFunctor t3,
-              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => 
+              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) =>
               t1 (t2 (t3 m)) a -> t1 (t2 (t3 (t4 (t5 m)))) a
 (|---**|) = ((|**|) |>>>|)
-(|--*-*|) :: (Monad m, Monad (t2 (t4 m)), Monad (t4 m), Monad (t4 (t5 m)), Monad (t5 m), 
-              MFunctor t1, MFunctor t2, MFunctor t4, 
-              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => 
+(|--*-*|) :: (Monad m, Monad (t2 (t4 m)), Monad (t4 m), Monad (t4 (t5 m)), Monad (t5 m),
+              MFunctor t1, MFunctor t2, MFunctor t4,
+              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) =>
               t1 (t2 (t4 m)) a -> t1 (t2 (t3 (t4 (t5 m)))) a
 (|--*-*|) = ((|*-*|) |>>|)
 (|-*--*|) :: (Monad m, Monad (t3 (t4 m)), Monad (t4 m), Monad (t3 (t4 (t5 m))),
-              MFunctor t1, MFunctor t3, MFunctor t4, 
-              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => 
+              MFunctor t1, MFunctor t3, MFunctor t4,
+              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) =>
               t1 (t3 (t4 m)) a -> t1 (t2 (t3 (t4 (t5 m)))) a
 (|-*--*|) = ((|*--*|) |>|)
-(|*---*|) :: (Monad m, Monad (t3 (t4 m)), Monad (t4 m), Monad (t2 (t3 (t4 (t5 m)))), 
-              MFunctor t2, MFunctor t3, MFunctor t4, 
-              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => 
+(|*---*|) :: (Monad m, Monad (t3 (t4 m)), Monad (t4 m), Monad (t2 (t3 (t4 (t5 m)))),
+              MFunctor t2, MFunctor t3, MFunctor t4,
+              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) =>
               t2 (t3 (t4 m)) a -> t1 (t2 (t3 (t4 (t5 m)))) a
 (|*---*|) = (|*|) . (|---*|)
 
 infixl 5  |--***|, |-*-**|, |*--**|, |*-*-*|, |-**-*|, |**--*|
 (|--***|) :: (Monad m, Monad (t2 m), Monad (t4 (t5 m)), Monad (t5 m),
-              MFunctor t1, MFunctor t2, 
-              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => 
+              MFunctor t1, MFunctor t2,
+              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) =>
               t1 (t2 m) a -> t1 (t2 (t3 (t4 (t5 m)))) a
 (|--***|) = ((|***|) |>>|)
 (|-*-**|) :: (Monad m, Monad (t3 m), Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)), Monad (t5 m),
-              MFunctor t1, MFunctor t3, 
-              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => 
+              MFunctor t1, MFunctor t3,
+              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) =>
               t1 (t3 m) a -> t1 (t2 (t3 (t4 (t5 m)))) a
 (|-*-**|) = ((|*-**|) |>|)
-(|*--**|) :: (Monad m, Monad (t3 m), Monad (t2 (t3 (t4 (t5 m)))), Monad (t5 m), 
-              MFunctor t2, MFunctor t3, 
-              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => 
+(|*--**|) :: (Monad m, Monad (t3 m), Monad (t2 (t3 (t4 (t5 m)))), Monad (t5 m),
+              MFunctor t2, MFunctor t3,
+              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) =>
               t2 (t3 m) a -> t1 (t2 (t3 (t4 (t5 m)))) a
 (|*--**|) = (|*|) . (|--**|)
-(|*-*-*|) :: (Monad m, Monad (t4 m), Monad (t2 (t3 (t4 (t5 m)))), Monad (t4 (t5 m)), Monad (t5 m), 
-              MFunctor t2, MFunctor t4, 
-              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => 
+(|*-*-*|) :: (Monad m, Monad (t4 m), Monad (t2 (t3 (t4 (t5 m)))), Monad (t4 (t5 m)), Monad (t5 m),
+              MFunctor t2, MFunctor t4,
+              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) =>
               t2 (t4 m) a -> t1 (t2 (t3 (t4 (t5 m)))) a
 (|*-*-*|) = (|*|) . (|-*-*|)
-(|-**-*|) :: (Monad m, Monad (t4 m), Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)), Monad (t5 m), 
-              MFunctor t1, MFunctor t4, 
-              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => 
+(|-**-*|) :: (Monad m, Monad (t4 m), Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)), Monad (t5 m),
+              MFunctor t1, MFunctor t4,
+              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) =>
               t1 (t4 m) a -> t1 (t2 (t3 (t4 (t5 m)))) a
 (|-**-*|) = (|-*|) . (|-*-*|)
-(|**--*|) :: (Monad m, Monad (t4 m), Monad (t2 (t3 (t4 (t5 m)))), Monad (t3 (t4 (t5 m))), Monad (t3 (t4 m)), 
-              MFunctor t3, MFunctor t4, 
-              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => 
+(|**--*|) :: (Monad m, Monad (t4 m), Monad (t2 (t3 (t4 (t5 m)))), Monad (t3 (t4 (t5 m))), Monad (t3 (t4 m)),
+              MFunctor t3, MFunctor t4,
+              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) =>
               t3 (t4 m) a -> t1 (t2 (t3 (t4 (t5 m)))) a
 (|**--*|) = (|*|) . (|*--*|)
 
 infixl 5  |-****|, |*-***|, |**-**|, |***-*|
-(|-****|) :: (Monad m, Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)), Monad (t5 m), 
-              MFunctor t1, 
-              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => 
+(|-****|) :: (Monad m, Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)), Monad (t5 m),
+              MFunctor t1,
+              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) =>
               t1 m a -> t1 (t2 (t3 (t4 (t5 m)))) a
 (|-****|) = ((|****|) |>|)
 (|*-***|) :: (Monad m, Monad (t2 (t3 (t4 (t5 m)))), Monad (t4 (t5 m)), Monad (t5 m),
-              MFunctor t2, 
-              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => 
+              MFunctor t2,
+              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) =>
               t2 m a -> t1 (t2 (t3 (t4 (t5 m)))) a
 (|*-***|) = (|*|) . (|-***|)
-(|**-**|) :: (Monad m, Monad (t2 (t3 (t4 (t5 m)))), Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)), Monad (t5 m), 
-              MFunctor t3, 
-              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => 
+(|**-**|) :: (Monad m, Monad (t2 (t3 (t4 (t5 m)))), Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)), Monad (t5 m),
+              MFunctor t3,
+              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) =>
               t3 m a -> t1 (t2 (t3 (t4 (t5 m)))) a
 (|**-**|) = (|**|) . (|-**|)
-(|***-*|) :: (Monad m, Monad (t2 (t3 (t4 (t5 m)))), Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)), 
-              MFunctor t4, 
-              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => 
+(|***-*|) :: (Monad m, Monad (t2 (t3 (t4 (t5 m)))), Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)),
+              MFunctor t4,
+              MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) =>
               t4 m a -> t1 (t2 (t3 (t4 (t5 m)))) a
 (|***-*|) = (|***|) . (|-*|)
 
@@ -525,7 +526,7 @@
 >
 >tock                         ::                   StateT Int IO ()
 >tock = do
->    generalize |>| tick      :: (Monad      m) => StateT Int m  ()  -- (|>|) is the level-1 trans-map function, analogous to (|$>) 
+>    generalize |>| tick      :: (Monad      m) => StateT Int m  ()  -- (|>|) is the level-1 trans-map function, analogous to (|$>)
 >    (|*|) $ putStrLn "Tock!" :: (MonadTrans t) => t          IO ()
 >
 >-- λ> runStateT tock 0
@@ -564,15 +565,15 @@
 >import Control.Monad.Trans.Maybe
 >
 >-----------------------------------------------
->-- Level-1 
+>-- Level-1
 >
->check :: IO a -> 
+>check :: IO a ->
 >                ExceptT IOException IO a   -- ExceptT-IO monad
 >check io = ExceptT $ (try io)
 >
 >viewFile :: IO ()                          -- IO monad
 >viewFile = do
->    str <- readFile "test.txt"        
+>    str <- readFile "test.txt"
 >    putStr str
 >
 >program :: ExceptT IOException IO ()       -- ExceptT-IO monad
@@ -580,7 +581,7 @@
 >                                           -- (|>=) is the level-1 trans-bind function, analogous to (>>=)
 >
 >calc_program :: IO (Either IOException ())
->calc_program = runExceptT $ program        
+>calc_program = runExceptT $ program
 >
 >-- > calc_program
 >-- Left test.txt: openFile: does not exist (No such file or directory)
@@ -588,20 +589,20 @@
 >-----------------------------------------------
 >-- Level-2
 >
->viewFile2 :: String -> 
+>viewFile2 :: String ->
 >             MaybeT IO ()                        -- MaybeT-IO monad
 >viewFile2 filename = do
 >    guard (filename /= "")
->    str <- (|*|) $ readFile filename        
+>    str <- (|*|) $ readFile filename
 >    (|*|) $ putStr str
 >
->program2 :: String -> 
+>program2 :: String ->
 >            (ExceptT IOException (MaybeT IO)) () -- ExceptT-MaybeT-IO monad
->program2 filename = 
+>program2 filename =
 >    (|*|) (viewFile2 filename) |>>= \x ->        -- (|>>=) is the level-2 trans-bind function, analogous to (>>=)
 >    (|-*|) $ check x                             -- (|-*|) is a level-2 trans-cover function, analogous to (-*)
 >
->calc_program2 :: String -> IO (Maybe (Either IOException ())) 
+>calc_program2 :: String -> IO (Maybe (Either IOException ()))
 >calc_program2 filename = runMaybeT . runExceptT $ program2 filename
 >
 >-- > calc_program2 "test.txt"
diff --git a/DeepControl/Monad/Signatures.hs b/DeepControl/Monad/Signatures.hs
--- a/DeepControl/Monad/Signatures.hs
+++ b/DeepControl/Monad/Signatures.hs
@@ -1,18 +1,16 @@
------------------------------------------------------------------------------
--- | Deepened the usual Control.Monad.Signatures module.
--- Module      :  DeepControl.Monad.Signatures
--- Copyright   :  (c) Ross Paterson 2012,
---                (c) 2015 KONISHI Yohsuke
--- License     :  BSD-style (see the file LICENSE)
---
--- Maintainer  :  KONISHI Yohsuke
--- Stability   :  experimental
--- Portability :  portable
---
--- Signatures for monad operations that require specialized lifting.
--- Each signature has a uniformity property that the lifting should satisfy.
------------------------------------------------------------------------------
+{-|
+Module      : DeepControl.Monad.Signatures
+Description : Deepend the usual Control.Monad.Signatures.
+Copyright   : (c) Ross Paterson 2012, 
+              (c) 2015 KONISHI Yohsuke
+License     : BSD-style (see the file LICENSE)
+Maintainer  : KONISHI Yohsuke
+Stability   : experimental
+Portability : portable
 
+Signatures for monad operations that require specialized lifting.
+Each signature has a uniformity property that the lifting should satisfy.
+-}
 module DeepControl.Monad.Signatures (
     -- * Level-1
     module Control.Monad.Signatures,
diff --git a/DeepControl/Monad/Trans.hs b/DeepControl/Monad/Trans.hs
--- a/DeepControl/Monad/Trans.hs
+++ b/DeepControl/Monad/Trans.hs
@@ -10,7 +10,7 @@
 Portability : ---
 
 This module enables you to program in Monad-Transformer style for more __deeper__ level than the usual @Control.Monad.Trans@ module expresses.
-You would realize exactly what __/more deeper level/__ means by reading the example codes, which are attached on the page bottom.
+You would realize exactly what __/much deeper level/__ means by reading the example codes, which are attached on the page bottom.
 -}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE TypeSynonymInstances #-}
@@ -195,11 +195,11 @@
 >
 >ackermann' :: Int -> Int -> 
 >              ReaderT TimeLimit (MaybeT IO) Int                 -- ReaderT-MaybeT-IO monad
->ackermann' x y = (transfold2 . 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 make 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 . untransfold2) |>| 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 make ReaderT-IdentityT2-IO-Maybe function from usual ReaderT-MaybeT-IO function
 -}
 
 
diff --git a/DeepControl/Monad/Trans/Except.hs b/DeepControl/Monad/Trans/Except.hs
--- a/DeepControl/Monad/Trans/Except.hs
+++ b/DeepControl/Monad/Trans/Except.hs
@@ -7,7 +7,7 @@
 Stability   : experimental
 Portability : ---
 
-This module extended Except monad of mtl(monad-transformer-library).
+This module extended mtl(monad-transformer-library)'s Except monad.
 -}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE RankNTypes #-}
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
@@ -8,7 +8,7 @@
 Stability   : experimental
 Portability : ---
 
-This module enables you to deal with deep monads in any monad-transformer.
+This module enables you to embed any deep monad into monad-transformer.
 -}
 {-# LANGUAGE DeriveFunctor, DeriveFoldable, DeriveTraversable #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
@@ -427,7 +427,7 @@
 (****-:) = (---*-:) . (***-:)
 
 {- $Example
-Here is an example showing how to use identity-cover functions
+Here is an example showing how to use level-2 identity-cover functions.
 
 >import DeepControl.Applicative ((|$>))
 >import DeepControl.Monad (Monad)
@@ -453,7 +453,7 @@
 >    n <- get
 >    (|*|) $ tell [n]
 >
->program ::                             StateT Int (IdentityT2 IO (Writer [Int])) () -- StateT-IdentityT2-IO-Writer monad, a level-2 monad-transform
+>program ::                             StateT Int (IdentityT2 IO (Writer [Int])) () -- StateT-IdentityT2-IO-Writer monad, a level-2 monad-transformation
 >program = replicateM_ 4 $ do
 >    ((-*:) . IdentityT) |>| tock                                                    -- (-*:) is a level-2 identity-cover function, analogous to (-*)
 >        :: (Monad m, Traversable m) => StateT Int (IdentityT2 IO m             ) ()
diff --git a/DeepControl/Monad/Trans/Writer.hs b/DeepControl/Monad/Trans/Writer.hs
--- a/DeepControl/Monad/Trans/Writer.hs
+++ b/DeepControl/Monad/Trans/Writer.hs
@@ -9,7 +9,7 @@
 Stability   : experimental
 Portability : ---
 
-This module extended Writer monad of mtl(monad-transformer-library).
+This module extended mtl(monad-transformer-library)'s Writer monad.
 -}
 module DeepControl.Monad.Trans.Writer (
     module Control.Monad.Writer,
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
 
 ## Examples
 
-### [Applicative](https://hackage.haskell.org/package/deepcontrol-0.5.4.2/docs/DeepControl-Applicative.html)
+### [Applicative](https://hackage.haskell.org/package/deepcontrol-0.5.4.3/docs/DeepControl-Applicative.html)
 
 This module enables you to program in applicative style for much deeper level than the usual Control.Applicative module expresses.
 You would soon realize exactly what "much deeper level" means by reading the example codes below in order.
@@ -117,7 +117,7 @@
     [Just (1,2)]
 
     > [[1]] <<$|(+)|*>> [[2]] <<$|(^)|*>> [[3]]
-    [[0]]
+    [[27]]
 
 cover notation:
 
@@ -182,7 +182,7 @@
 
 Work well likewise.
 
-### [Monad](https://hackage.haskell.org/package/deepcontrol-0.5.4.2/docs/DeepControl-Monad.html)
+### [Monad](https://hackage.haskell.org/package/deepcontrol-0.5.4.3/docs/DeepControl-Monad.html)
 
 This module enables you to program in Monad for much deeper level than the usual Control.Monad module expresses.
 You would soon realize exactly what "much 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.4.2/docs/DeepControl-Traversable.html)
+#### [Traversable](https://hackage.haskell.org/package/deepcontrol-0.5.4.3/docs/DeepControl-Traversable.html)
 
 Identity, List, Maybe, Either, Except and Writer monads are sinkable monads.
 
@@ -220,7 +220,7 @@
     > sink2 $ Right [Just 1]
     [Just (Right 1)]
 
-So within these monads, deep level(layered) bind functions can be made.
+So within these monads, deep-level bind functions can be made.
 
 #### Level-2
 
@@ -286,11 +286,11 @@
 
 Work well likewise.
 
-### [Monad-Morph](https://hackage.haskell.org/package/deepcontrol-0.5.4.2/docs/DeepControl-Monad-Morph.html)
+### [Monad-Morph](https://hackage.haskell.org/package/deepcontrol-0.5.4.3/docs/DeepControl-Monad-Morph.html)
 
 #### SinkT
 
-IdentityT, ListT, MaybeT, ExceptT and WriterT monadtrans' are sinkable.
+IdentityT, ListT, MaybeT, ExceptT and WriterT monadtranses are sinkable.
 
     Prelude> :m DeepControl.Monad.Morph
     > :t sinkT
@@ -310,7 +310,7 @@
     > sinkT2 $ MaybeT (ListT (ExceptT (Identity (Right [Just 1]))))
     ListT (ExceptT (MaybeT (Identity (Just (Right [1])))))
 
-So within these monadtrans', deep level(layered) trans-bind functions can be made.
+So within these monadtranses, deep-level trans-bind functions can be made.
 
 #### Level-2
 
@@ -415,7 +415,7 @@
 
 Work well likewise.
 
-### [Monad-Transformer](https://hackage.haskell.org/package/deepcontrol-0.5.4.2/docs/DeepControl-Monad-Trans.html)
+### [Monad-Transformer](https://hackage.haskell.org/package/deepcontrol-0.5.4.3/docs/DeepControl-Monad-Trans.html)
 
 #### Level-2
 
@@ -459,14 +459,14 @@
 
 ackermann' :: Int -> Int -> 
               ReaderT TimeLimit (MaybeT IO) Int                 -- ReaderT-MaybeT-IO monad
-ackermann' x y = (transfold2 . runIdentityT2) |>| ackermann x y -- You can get the ordinary monad-transformed function from the natural one.
+ackermann' x y = (transfold2 . runIdentityT2) |>| ackermann x y -- You can make the ordinary monad-transformed function from the natural one.
 
 ackermann'' :: Int -> Int -> 
                ReaderT TimeLimit (IdentityT2 IO Maybe) Int       -- ReaderT-IdentityT2-IO-Maybe monad
-ackermann'' x y = (IdentityT2 . untransfold2) |>| ackermann' x y -- You can get the natural monad-transformed function from the ordinary one.
+ackermann'' x y = (IdentityT2 . untransfold2) |>| ackermann' x y -- You can make the natural monad-transformed function from the ordinary one.
 ```
 #### Level-3, Level-4 and Level-5
 
 Work well likewise.
 
-### [Arrow](https://hackage.haskell.org/package/deepcontrol-0.5.4.2/docs/DeepControl-Arrow.html)
+### [Arrow](https://hackage.haskell.org/package/deepcontrol-0.5.4.3/docs/DeepControl-Arrow.html)
diff --git a/deepcontrol.cabal b/deepcontrol.cabal
--- a/deepcontrol.cabal
+++ b/deepcontrol.cabal
@@ -1,6 +1,6 @@
 name:                deepcontrol
-version:             0.5.4.2
-synopsis:            A library that provides deep-level programming style or notation on Applicative and Monad
+version:             0.5.4.3
+synopsis:            A library that provides deep-level programming style and(or) notation on Applicative and Monad
 description:         This module provides much deeper level style of programming than the usual Applicative and Monad modules express.
 license:             BSD3
 license-file:        LICENSE