diff --git a/THEff.cabal b/THEff.cabal
--- a/THEff.cabal
+++ b/THEff.cabal
@@ -1,81 +1,85 @@
-name:                THEff
-version:             0.1.0.1
-synopsis:            TH implementation of effects. 
-license:             BSD3
-license-file:        LICENSE
-author:              Kolodezny Diver
-maintainer:          kolodeznydiver@gmail.com
-category:            Control, Effect, TH 
-build-type:          Simple
-cabal-version:       >=1.10
-description:    
-  This package implements effects, as alternative to monad
-  transformers. Actually, the effects themselves are created without 
-  the use of TH, but the binding of nested effects described by 
-  mkEff splice. For example.
-  .
-  > mkEff "MyReader"    ''Reader    ''Int       ''Lift
-  > mkEff "SomeState"   ''State     ''Bool      ''MyReader
-  > mkEff "OtherRdr"    ''Reader    ''Float     ''SomeState
-  > 
-  > main:: IO ()
-  > main = do
-  >     r <- runMyReader  100 
-  >        $ runSomeState False
-  >        $ runOtherRdr  pi  $ do
-  >             i :: Int   <- ask                    -- MyReader 
-  >             f :: Float <- ask                    -- OtherRdr
-  >             b <- get                             -- SomeState
-  >             put $ not b                          -- SomeState 
-  >             lift $ putStrLn "print from effect!" -- Lift  
-  >             return $ show $ fromIntegral i * f 
-  >     print r
-  .
-  For more information about extensible effects , see the original paper at
-  <http://okmij.org/ftp/Haskell/extensible/exteff.pdf>.
-  But, this package is significantly different from the original.
-  It uses a chains of ordinary GADTs created by TH. 
-  No Typeable, unsafe... , ExistentialQuantification ...
-
-extra-source-files:    samples/*.hs
-  
-Source-repository head
-    type:               git
-    location:           https://github.com/KolodeznyDiver/THEff.git
-    
-library
-  ghc-options:         -Wall 
-  exposed-modules:     Control.THEff
-                       Control.THEff.Reader
-                       Control.THEff.State
-                       Control.THEff.Exception
-                       Control.THEff.Catch
-                       Control.THEff.Writer
-                       Control.THEff.Fresh
-                       Control.THEff.Validator
-  
-  -- Modules included in this library but not exported.
-  other-modules:       Control.THEff.TH.Internal
-  
-  -- LANGUAGE extensions used by modules in this package.
-  other-extensions:    KindSignatures
-                       , FlexibleInstances
-                       , FlexibleContexts
-                       , MultiParamTypeClasses
-                       , TemplateHaskell
-                       , ViewPatterns
-                       , RecordWildCards
-                       , ScopedTypeVariables
-                       , RankNTypes
-                       , GADTs
-  
-  -- Other library packages from which modules are imported.
-  build-depends:       base >=4.8 && <4.9
-                      ,template-haskell >=2.4 && <2.11
-  
-  -- Directories containing source files.
-  hs-source-dirs:      src
-  
-  -- Base language which the package is written in.
-  default-language:    Haskell2010
+name:                THEff
+version:             0.1.1.0
+synopsis:            TH implementation of effects. 
+license:             BSD3
+license-file:        LICENSE
+author:              Kolodezny Diver
+maintainer:          kolodeznydiver@gmail.com
+category:            Control, Effect, TH 
+build-type:          Simple
+cabal-version:       >=1.10
+description:    
+  This package implements effects, as alternative to monad
+  transformers. Actually, the effects themselves are created without 
+  the use of TH, but the binding of nested effects described by 
+  mkEff splice. For example.
+  .
+  > mkEff "MyReader"    ''Reader    ''Int       ''Lift
+  > mkEff "SomeState"   ''State     ''Bool      ''MyReader
+  > mkEff "OtherRdr"    ''Reader    ''Float     ''SomeState
+  > 
+  > main:: IO ()
+  > main = do
+  >     r <- runMyReader  100 
+  >        $ runSomeState False
+  >        $ runOtherRdr  pi  $ do
+  >             i :: Int   <- ask                    -- MyReader 
+  >             f :: Float <- ask                    -- OtherRdr
+  >             b <- get                             -- SomeState
+  >             put $ not b                          -- SomeState 
+  >             lift $ putStrLn "print from effect!" -- Lift  
+  >             return $ show $ fromIntegral i * f 
+  >     print r
+  .
+  For more information about extensible effects , see the original paper at
+  <http://okmij.org/ftp/Haskell/extensible/exteff.pdf>.
+  But, this package is significantly different from the original.
+  It uses a chains of ordinary GADTs created by TH. 
+  No Typeable, unsafe... , ExistentialQuantification ...
+
+extra-source-files:    samples/*.hs
+  
+Source-repository head
+    type:               git
+    location:           https://github.com/KolodeznyDiver/THEff.git
+    
+library
+  ghc-options:         -Wall 
+  exposed-modules:     Control.THEff
+                       Control.THEff.Reader
+                       Control.THEff.State
+                       Control.THEff.Exception
+                       Control.THEff.Catch
+                       Control.THEff.Writer
+                       Control.THEff.Fresh
+                       Control.THEff.Validator
+                       Control.THEff.Writer.Strict
+                       Control.THEff.Reader.Strict
+                       Control.THEff.State.Strict 
+  
+  -- Modules included in this library but not exported.
+  other-modules:       Control.THEff.TH.Internal
+  
+  -- LANGUAGE extensions used by modules in this package.
+  other-extensions:    KindSignatures
+                       , FlexibleInstances
+                       , FlexibleContexts
+                       , MultiParamTypeClasses
+                       , TemplateHaskell
+                       , ViewPatterns
+                       , RecordWildCards
+                       , ScopedTypeVariables
+                       , RankNTypes
+                       , GADTs
+                       , BangPatterns
+  
+  -- Other library packages from which modules are imported.
+  build-depends:       base >=4.8 && <4.9
+                      ,template-haskell >=2.4 && <2.11
+  
+  -- Directories containing source files.
+  hs-source-dirs:      src
+  
+  -- Base language which the package is written in.
+  default-language:    Haskell2010
   
diff --git a/samples/SampleAll.hs b/samples/SampleAll.hs
--- a/samples/SampleAll.hs
+++ b/samples/SampleAll.hs
@@ -21,8 +21,8 @@
 mkEff "MyReader"    ''Reader    ''Int       ''Lift
 mkEff "SomeState"   ''State     ''Bool      ''MyReader
 mkEff "OtherRdr"    ''Reader    ''Float     ''SomeState
-mkEff "MyWriter"     ''Writer   ''String    ''OtherRdr
-mkEff "MyException" ''Except    ''String   ''MyWriter
+mkEff "MyWriter"    ''Writer    ''String    ''OtherRdr
+mkEff "MyException" ''Except    ''String    ''MyWriter
 mkEff "MyCatch"     ''Catch     ''Int       ''MyException
 mkEff "UnicalChar"  ''Fresh     ''Char      ''MyCatch
 mkEff "MyVldtr"     ''Validator ''Float     ''UnicalChar
diff --git a/src/Control/THEff.hs b/src/Control/THEff.hs
--- a/src/Control/THEff.hs
+++ b/src/Control/THEff.hs
@@ -106,7 +106,7 @@
 newtype NoEff (m:: * -> *) a = NoEff { unNoEff :: a}
 
 -- | This function is used in the 'mkEff' generated runEEEE... functions. 
--- > @effNoEff _ = error "THEff: Attempting to call the effect NoEff that does not have any actions!"@
+-- @effNoEff _ = error "THEff: Attempting to call the effect NoEff that does not have any actions!"@
 effNoEff :: a -> b
 effNoEff _ = error "THEff: Attempting to call the effect NoEff that does not have any actions!"
 
diff --git a/src/Control/THEff/Reader.hs b/src/Control/THEff/Reader.hs
--- a/src/Control/THEff/Reader.hs
+++ b/src/Control/THEff/Reader.hs
@@ -7,6 +7,9 @@
 module Control.THEff.Reader (
                       -- * Overview 
 -- |
+-- This version builds its output lazily; for a strict version with
+-- the same interface, see "Control.THEff.Reader.Strict".
+--
 -- > {-# LANGUAGE KindSignatures #-}
 -- > {-# LANGUAGE FlexibleInstances #-}
 -- > {-# LANGUAGE MultiParamTypeClasses #-}
diff --git a/src/Control/THEff/Reader/Strict.hs b/src/Control/THEff/Reader/Strict.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/THEff/Reader/Strict.hs
@@ -0,0 +1,96 @@
+{-# OPTIONS_HADDOCK show-extensions #-}
+
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE BangPatterns #-}
+
+module Control.THEff.Reader.Strict (
+                      -- * Overview 
+-- |
+-- This version builds its output strictly; for a lazy version with
+-- the same interface, see "Control.THEff.Reader".
+--
+-- > {-# LANGUAGE KindSignatures #-}
+-- > {-# LANGUAGE FlexibleInstances #-}
+-- > {-# LANGUAGE MultiParamTypeClasses #-}
+-- > {-# LANGUAGE TemplateHaskell #-}
+-- > 
+-- > import Control.THEff
+-- > import Control.THEff.Reader.Strict
+-- > 
+-- > mkEff "CharReader"   ''Reader    ''Char       ''NoEff
+-- > mkEff "StrReader"    ''Reader    ''String     ''CharReader
+-- > 
+-- > main:: IO ()
+-- > main = putStrLn $ runCharReader 'T' $ runStrReader "est" $ do
+-- >             c <- ask
+-- >             s <- ask
+-- >             return $ c:s
+-- 
+-- __/Output :/__ "Test"
+
+                      -- * Types and functions used in mkEff
+                              Reader' 
+                            , Reader(..)
+                            , ReaderArgT
+                            , ReaderResT
+                            , effReader
+                            , runEffReader
+                      -- * Functions that use this effect                         
+                            , ask
+                            , asks
+                            ) where
+
+import Control.THEff
+
+-- | Actually, the effect type
+--  - __/v/__ - Type - the parameter of the effect.
+--  - __/e/__ - mkEff generated type.
+newtype Reader' v e = Reader' (v -> e)
+
+-- | Type implements link in the chain of effects.
+--   Constructors must be named __/{EffectName}{Outer|WriterAction|WriterResult}/__
+--   and have a specified types of fields.
+-- - __/m/__ - Or Monad (if use the 'Lift') or phantom type - stub (if used 'NoEff').
+-- - __/o/__ - Type of outer effect.
+-- - __/a/__ - The result of mkEff generated runEEEE... function.
+data Reader (m:: * -> *) e o v a = ReaderOuter (o m e)
+                                 | ReaderAction (Reader' v e)
+                                 | ReaderResult a 
+
+-- | Type of fourth argument of runEffReader and first argument of runEEEE. 
+type ReaderArgT v = v
+
+-- | Result type of runEEEE.  
+type ReaderResT r = r
+
+-- | This function is used in the 'mkEff' generated runEEEE functions and typically 
+-- in effect action functions. Calling the effect action.
+effReader:: EffClass Reader' v e => Reader' v r -> Eff e r
+effReader (Reader' g) = effAction $ \k -> Reader' (k . g)
+
+-- | The main function of the effect implementing. 
+-- This function is used in the 'mkEff' generated runEEEE functions. 
+runEffReader :: forall (t :: * -> *) (u :: (* -> *) -> * -> *) (m :: * -> *) a v 
+            (m1 :: * -> *) e (o :: (* -> *) -> * -> *) w a1 r. Monad m =>
+    (u t r -> (r -> m (ReaderResT a)) -> m (ReaderResT a)) -- ^ The outer effect function
+ -> (Reader m1 e o w a1 -> r) -- ^ The chain of effects link wrapper.
+ -> (r -> Reader t r u v a)  -- ^ The chain of effects link unwrapper.
+ -> ReaderArgT v -- ^ The initial value of argument of effect.
+ -> Eff r a1
+ -> m (ReaderResT a)
+runEffReader outer to un !v m = loop $ runEff m (to . ReaderResult)
+    where
+        loop = select . un
+        select (ReaderOuter f)  = outer f loop
+        select (ReaderAction (Reader' g)) = loop $ g v
+        select (ReaderResult r) = return r
+
+-- | Get reader value
+ask :: EffClass Reader' v e => Eff e v
+ask = effReader $ Reader' id
+
+-- | Get and convert the value of the reader
+asks :: EffClass Reader' r e => (r -> v) -> Eff e v
+asks f = effReader $ Reader' f
diff --git a/src/Control/THEff/State.hs b/src/Control/THEff/State.hs
--- a/src/Control/THEff/State.hs
+++ b/src/Control/THEff/State.hs
@@ -7,6 +7,9 @@
 module Control.THEff.State (
                       -- * Overview 
 -- |
+-- This version builds its output lazily; for a strict version with
+-- the same interface, see "Control.THEff.State.Strict".
+--
 -- > {-# LANGUAGE KindSignatures #-}
 -- > {-# LANGUAGE FlexibleInstances #-}
 -- > {-# LANGUAGE MultiParamTypeClasses #-}
diff --git a/src/Control/THEff/State/Strict.hs b/src/Control/THEff/State/Strict.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/THEff/State/Strict.hs
@@ -0,0 +1,122 @@
+{-# OPTIONS_HADDOCK show-extensions #-}
+
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE BangPatterns #-}
+
+module Control.THEff.State.Strict (
+                      -- * Overview 
+-- |
+-- This version builds its output strictly; for a lazy version with
+-- the same interface, see "Control.THEff.State".
+--
+-- > {-# LANGUAGE KindSignatures #-}
+-- > {-# LANGUAGE FlexibleInstances #-}
+-- > {-# LANGUAGE MultiParamTypeClasses #-}
+-- > {-# LANGUAGE TemplateHaskell #-}
+-- > 
+-- > import Control.THEff
+-- > import Control.THEff.State.Strict
+-- > 
+-- > mkEff "Example1"   ''State     ''Int      ''NoEff
+-- > mkEff "Example2"   ''State     ''Float    ''Example1
+-- > 
+-- > main:: IO ()
+-- > main = print $ runExample1 123 
+-- >              $ runExample2 pi $ do
+-- >                     i <- get
+-- >                     modify ((1 :: Int) +)
+-- >                     put $ i * (2 :: Float)
+-- >                     return  $ show i 
+-- 
+-- __/Output :/__ (("3.1415927",6.2831855),124)
+
+                      -- * Types and functions used in mkEff
+                            State'
+                          , State(..) 
+                          , StateArgT
+                          , StateResT
+                          , effState
+                          , runEffState 
+                      -- * Functions that use this effect                         
+                          , get
+                          , put
+                          , modify
+                      -- * Helper functions
+                          , stateOnly
+                          , withoutState
+                          ) where
+
+import Control.THEff
+
+-- | Actually, the effect type
+--  - __/v/__ - Type - the parameter of the effect.
+--  - __/e/__ - mkEff generated type.
+data State' v e = State' (v -> v) (v -> e)  
+
+-- | Type implements link in the chain of effects.
+--   Constructors must be named __/{EffectName}{Outer|WriterAction|WriterResult}/__
+--   and have a specified types of fields.
+-- - __/m/__ - Or Monad (if use the 'Lift') or phantom type - stub (if used 'NoEff').
+-- - __/o/__ - Type of outer effect.
+-- - __/a/__ - The result of mkEff generated runEEEE... function.
+data State (m:: * -> *) e o v a = StateOuter (o m e)
+                                | StateAction (State' v e)    
+                                | StateResult a
+
+-- | Type of fourth argument of runEffState and first argument of runEEEE. 
+type StateArgT v = v
+
+-- | Result type of runEEEE.  
+type StateResT r v = (r, v)
+
+-- | This function is used in the 'mkEff' generated runEEEE functions and typically 
+-- in effect action functions. Calling the effect action.
+effState:: EffClass State' v e => State' v r -> Eff e r
+effState (State' f g) = effAction $ \k -> State' f (k . g)
+
+-- | The main function of the effect implementing. 
+-- This function is used in the 'mkEff' generated runEEEE functions. 
+runEffState :: forall (t :: * -> *) (u :: (* -> *) -> * -> *) (m :: * -> *) 
+             z v (m1 :: * -> *) e (o :: (* -> *) -> * -> *) w a r. Monad m =>
+    (u t r -> (r -> m (StateResT z v)) -> m (StateResT z v)) -- ^ The outer effect function
+ -> (State m1 e o w a -> r) -- ^ The chain of effects link wrapper.
+ -> (r -> State t r u v z)  -- ^ The chain of effects link unwrapper.
+ -> StateArgT v -- ^ The initial value of argument of effect.
+ -> Eff r a
+ -> m  (StateResT z v)
+runEffState outer to un v m = loop v $ runEff m (to . StateResult)
+  where 
+    loop !s = select . un where
+        select (StateOuter f)  = outer f (loop s)
+        select (StateAction (State' t k)) = let s' = t s in loop s' (k s')
+        select (StateResult r) = return (r,s)
+
+-- | Get state value
+get :: EffClass State' v e => Eff e v
+get = effState $ State' id id
+    
+-- | Put state value
+put :: EffClass State' v e => v -> Eff e ()
+put !s = modify $ const s
+    
+-- | Modify state value
+modify :: EffClass State' v e => (v -> v) -> Eff e ()
+modify f = effState $ State' f (const ())
+ 
+-- | @ stateOnly runExample1 123 === snd (runExample1 123) @
+stateOnly :: forall v e r t. 
+    (t -> e -> (r, v)) -- ^ State effect runEEEE function
+ -> t -- ^ The initial value of argument of effect. 
+ -> e -- ^ Eff (MyState m ...) ... 
+ -> v
+stateOnly f v = snd . (f v)
+
+-- | @ withoutState runExample1 123 === fst (runExample1 123) @
+withoutState :: forall v e r t. 
+    (t -> e -> (r, v)) -- ^ State effect runEEEE function
+ -> t -- ^ The initial value of argument of effect. 
+ -> e -- ^ Eff (MyState m ...) ... 
+ -> r
+withoutState f v = fst . (f v)
diff --git a/src/Control/THEff/TH/Internal.hs b/src/Control/THEff/TH/Internal.hs
--- a/src/Control/THEff/TH/Internal.hs
+++ b/src/Control/THEff/TH/Internal.hs
@@ -1,7 +1,5 @@
 {-# OPTIONS_HADDOCK show-extensions #-}
 
-{-# OPTIONS_HADDOCK show-extensions #-}
-
 {-# LANGUAGE  TemplateHaskell, ViewPatterns, RecordWildCards #-}
 module Control.THEff.TH.Internal(mkEff) where
 
diff --git a/src/Control/THEff/Writer.hs b/src/Control/THEff/Writer.hs
--- a/src/Control/THEff/Writer.hs
+++ b/src/Control/THEff/Writer.hs
@@ -7,6 +7,9 @@
 module Control.THEff.Writer (
                       -- * Overview 
 -- |
+-- This version builds its output lazily; for a strict version with
+-- the same interface, see "Control.THEff.Writer.Strict".
+--
 -- > {-# LANGUAGE KindSignatures #-}
 -- > {-# LANGUAGE FlexibleInstances #-}
 -- > {-# LANGUAGE MultiParamTypeClasses #-}
diff --git a/src/Control/THEff/Writer/Strict.hs b/src/Control/THEff/Writer/Strict.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/THEff/Writer/Strict.hs
@@ -0,0 +1,101 @@
+{-# OPTIONS_HADDOCK show-extensions #-}
+
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE BangPatterns #-}
+
+module Control.THEff.Writer.Strict (
+                      -- * Overview 
+-- |
+-- This version builds its output strictly; for a lazy version with
+-- the same interface, see "Control.THEff.Writer".
+--
+-- > {-# LANGUAGE KindSignatures #-}
+-- > {-# LANGUAGE FlexibleInstances #-}
+-- > {-# LANGUAGE MultiParamTypeClasses #-}
+-- > {-# LANGUAGE TemplateHaskell #-}
+-- > 
+-- > import Control.THEff
+-- > import Control.THEff.Writer.Strict
+-- > import Control.Monad(forM_) 
+-- > import Data.Monoid
+-- > 
+-- > type IntAccum = Sum Int
+-- > 
+-- > mkEff "StrWriter"   ''Writer   ''String    ''NoEff
+-- > mkEff "IntWriter"   ''Writer   ''IntAccum  ''StrWriter
+-- > 
+-- > main:: IO ()
+-- > main = putStrLn $ uncurry (flip (++)) $ runStrWriter $ do
+-- >             tell "Result"
+-- >             (r, Sum v) <- runIntWriter $ do
+-- >                 tell "="
+-- >                 forM_ [1::Int .. 10]
+-- >                     (tell . Sum)
+-- >                 return (pi :: Float)
+-- >             return $ show $ r * fromIntegral v
+-- 
+-- __/Output :/__ Result=172.7876
+--
+-- Note that for the effect `Writer' `mkEff' generates unary function runEEEE. `mkEff' chooses 
+-- generation unary or binary function runEEEE based on number of arguments of  effect function. 
+-- E.g. runEffWriter.
+
+                      -- * Types and functions used in mkEff
+                            Writer'
+                          , Writer(..) 
+                          , WriterResT
+                          , effWriter
+                          , runEffWriter 
+                      -- * Functions that use this effect                         
+                          , tell
+                          ) where
+
+import Control.THEff
+import Data.Monoid
+
+-- | Actually, the effect type
+--  - __/v/__ - Type - the parameter of the effect.
+--  - __/e/__ - mkEff generated type.
+data Writer' v e = Writer' !v (() -> e)  
+
+-- | Type implements link in the chain of effects.
+--   Constructors must be named __/{EffectName}{Outer|WriterAction|WriterResult}/__
+--   and have a specified types of fields.
+-- - __/m/__ - Or Monad (if use the 'Lift') or phantom type - stub (if used 'NoEff').
+-- - __/o/__ - Type of outer effect.
+-- - __/a/__ - The result of mkEff generated runEEEE... function.
+data Writer (m:: * -> *) e o v a = WriterOuter (o m e)
+                                 | WriterAction (Writer' v e)    
+                                 | WriterResult a
+
+-- | Result type of runEEEE.  
+type WriterResT r v = (r, v)
+
+-- | This function is used in the 'mkEff' generated runEEEE functions and typically 
+-- in effect action functions. Calling the effect action.
+effWriter:: EffClass Writer' v e => Writer' v r -> Eff e r
+effWriter (Writer' v g) = effAction $ \k -> Writer' v (k . g)
+ 
+-- | The main function of the effect implementing. 
+-- This function is used in the 'mkEff' generated runEEEE functions. 
+runEffWriter :: forall (t :: * -> *) (u :: (* -> *) -> * -> *) (m :: * -> *) 
+             z v (m1 :: * -> *) e (o :: (* -> *) -> * -> *) w a r. (Monad m, Monoid v) =>
+    (u t r -> (r -> m (WriterResT z v)) -> m (WriterResT z v)) -- ^ The outer effect function
+ -> (Writer m1 e o w a -> r) -- ^ The chain of effects link wrapper.
+ -> (r -> Writer t r u v z)  -- ^ The chain of effects link unwrapper.
+--             -> WriterArgT v  -- unused argument!
+ -> Eff r a
+ -> m  (WriterResT z v)
+runEffWriter outer to un m = loop mempty $ runEff m (to . WriterResult)
+  where 
+    loop !s = select . un where
+        select (WriterOuter g)  = outer g (loop s)
+        select (WriterAction (Writer' v k)) = let s' = s `mappend` v -- (f v)
+                                              in loop s' (k ())
+        select (WriterResult r) = return (r,s)
+
+-- | Add value to monoid. 
+tell :: EffClass Writer' v e => v -> Eff e ()
+tell !v = effWriter $ Writer' v (const ())