diff --git a/Control/ContStuff/Classes.hs b/Control/ContStuff/Classes.hs
--- a/Control/ContStuff/Classes.hs
+++ b/Control/ContStuff/Classes.hs
@@ -24,8 +24,12 @@
       bracket, bracket_, catch, finally, forbid, handle, raiseUnless,
       raiseWhen, require,
       -- ** State
+      -- *** Reading
+      Readable(..),
+      getField,
+      -- *** Writing
       Stateful(..),
-      getField, modify, modifyField, modifyFieldLazy, modifyLazy,
+      modify, modifyField, modifyFieldLazy, modifyLazy,
       -- ** Logging support (writers)
       Writable(..)
     )
@@ -209,17 +213,27 @@
 -- State --
 -----------
 
--- | Stateful monads.
---
--- Minimal complete definition: 'StateOf', 'get' and 'putLazy'.
+-- | Monads with environment (reader monads).
 
-class Stateful m where
-    -- | State type of @m@.
+class Readable m where
+    -- | Environment type of @m@.
     type StateOf m
 
     -- | Get the current state.
     get :: m (StateOf m)
 
+
+-- | Get a certain field.
+
+getField :: (Functor m, Readable m) => (StateOf m -> a) -> m a
+getField = (<$> get)
+
+
+-- | Stateful monads, i.e. having a modifyable environment (stateful monads).
+--
+-- Minimal complete definition: 'putLazy'.
+
+class Stateful m where
     -- | Set the current state and force it.
     put :: StateOf m -> m ()
     put x = x `seq` putLazy x
@@ -228,35 +242,30 @@
     putLazy :: StateOf m -> m ()
 
 
--- | Get a certain field.
-
-getField :: (Functor m, Stateful m) => (StateOf m -> a) -> m a
-getField = (<$> get)
-
-
 -- | Apply a function to the current state.
 
-modify :: (Monad m, Stateful m) => (StateOf m -> StateOf m) -> m ()
+modify :: (Monad m, Readable m, Stateful m) => (StateOf m -> StateOf m) -> m ()
 modify f = liftM f get >>= put
 
 
 -- | Get a field and modify the state.
 
-modifyField :: (Monad m, Stateful m) =>
+modifyField :: (Monad m, Readable m, Stateful m) =>
                (StateOf m -> a) -> (a -> StateOf m) -> m ()
 modifyField accessor f = liftM (f . accessor) get >>= put
 
 
 -- | Get a field and modify the state.  Lazy version.
 
-modifyFieldLazy :: (Monad m, Stateful m) =>
+modifyFieldLazy :: (Monad m, Readable m, Stateful m) =>
                    (StateOf m -> a) -> (a -> StateOf m) -> m ()
 modifyFieldLazy accessor f = liftM (f . accessor) get >>= putLazy
 
 
 -- | Apply a function to the current state.  Lazy version.
 
-modifyLazy :: (Monad m, Stateful m) => (StateOf m -> StateOf m) -> m ()
+modifyLazy :: (Monad m, Readable m, Stateful m) =>
+              (StateOf m -> StateOf m) -> m ()
 modifyLazy f = liftM f get >>= putLazy
 
 
diff --git a/Control/ContStuff/Instances.hs b/Control/ContStuff/Instances.hs
--- a/Control/ContStuff/Instances.hs
+++ b/Control/ContStuff/Instances.hs
@@ -38,35 +38,50 @@
 
 
 --------------
--- Stateful --
+-- Readable --
 --------------
 
-instance (Monad m, Stateful m) => Stateful (ChoiceT r i m) where
+instance (Monad m, Readable m) => Readable (ChoiceT r i m) where
     type StateOf (ChoiceT r i m) = StateOf m
     get = lift get
+
+instance (Monad m, Readable m) => Readable (ContT r m) where
+    type StateOf (ContT r m) = StateOf m
+    get = lift get
+
+instance (Monad m, Readable m) => Readable (EitherT r e m) where
+    type StateOf (EitherT r e m) = StateOf m
+    get = lift get
+
+instance (Monad m, Readable m) => Readable (IdentityT m) where
+    type StateOf (IdentityT m) = StateOf m
+    get = lift get
+
+instance (Monad m, Readable m) => Readable (MaybeT r m) where
+    type StateOf (MaybeT r m) = StateOf m
+    get = lift get
+
+
+--------------
+-- Stateful --
+--------------
+
+instance (Monad m, Stateful m) => Stateful (ChoiceT r i m) where
     put = lift . put
     putLazy = lift . putLazy
 
 instance (Monad m, Stateful m) => Stateful (ContT r m) where
-    type StateOf (ContT r m) = StateOf m
-    get = lift get
     put = lift . put
     putLazy = lift . putLazy
 
 instance (Monad m, Stateful m) => Stateful (EitherT r e m) where
-    type StateOf (EitherT r e m) = StateOf m
-    get = lift get
     put = lift . put
     putLazy = lift . putLazy
 
 instance (Monad m, Stateful m) => Stateful (IdentityT m) where
-    type StateOf (IdentityT m) = StateOf m
-    get = lift get
     put = lift . put
     putLazy = lift . putLazy
 
 instance (Monad m, Stateful m) => Stateful (MaybeT r m) where
-    type StateOf (MaybeT r m) = StateOf m
-    get = lift get
     put = lift . put
     putLazy = lift . putLazy
diff --git a/Control/ContStuff/Monads.hs b/Control/ContStuff/Monads.hs
--- a/Control/ContStuff/Monads.hs
+++ b/Control/ContStuff/Monads.hs
@@ -14,6 +14,8 @@
       Choice, listChoice, maybeChoice,
       -- ** Cont
       Cont, runCont, evalCont, modifyCont,
+      -- ** Reader
+      Reader, runReader,
       -- ** State
       State, runState, evalState, execState,
       -- ** Writer
@@ -100,6 +102,21 @@
 
 execOldWriter :: Monoid w => OldWriter r w r -> w
 execOldWriter = snd . runIdentity . runOldWriterT
+
+
+------------
+-- Reader --
+------------
+
+-- | Pure computation with environment.
+
+type Reader e a = ReaderT e Identity a
+
+
+-- | Run a pure computation with environment.
+
+runReader :: e -> Reader e a -> a
+runReader env = runIdentity . runReaderT env
 
 
 -----------
diff --git a/Control/ContStuff/Simple.hs b/Control/ContStuff/Simple.hs
--- a/Control/ContStuff/Simple.hs
+++ b/Control/ContStuff/Simple.hs
@@ -24,6 +24,10 @@
       MaybeT,
       evalMaybeT, testMaybeT,
 
+      -- * Reader
+      ReaderT,
+      runReaderT,
+
       -- * State
       StateT,
       evalStateT, execStateT,
@@ -43,6 +47,7 @@
 import Control.Applicative
 import Control.ContStuff.Classes
 import Control.ContStuff.Instances ()
+import Control.ContStuff.Trans (ReaderT, runReaderT)
 import Control.Monad
 import Data.Monoid
 
diff --git a/Control/ContStuff/Trans.hs b/Control/ContStuff/Trans.hs
--- a/Control/ContStuff/Trans.hs
+++ b/Control/ContStuff/Trans.hs
@@ -8,7 +8,11 @@
 -- This module implements a number of monad transformers using a CPS
 -- approach internally.
 
-{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, TypeFamilies #-}
+{-# LANGUAGE
+  FlexibleInstances,
+  MultiParamTypeClasses,
+  RankNTypes,
+  TypeFamilies #-}
 
 module Control.ContStuff.Trans
     ( -- * Monad transformers
@@ -32,6 +36,9 @@
       runMaybeT, evalMaybeT, modifyMaybeT, testMaybeT,
 
       -- ** State
+      ReaderT,
+      runReaderT,
+
       StateT(..),
       runStateT, evalStateT, execStateT,
 
@@ -469,6 +476,51 @@
 execOldWriterT = fmap snd . runOldWriterT
 
 
+-------------
+-- ReaderT --
+-------------
+
+-- | Monad transformer for computations with readable environment.
+-- Unlike the other monad transformers this one allows no CPS effects,
+-- which makes it commutative.
+--
+-- If you need CPS effects, consider using 'StateT'.
+
+newtype ReaderT e m a =
+    ReaderT { getReaderT :: forall r. StateT r e m a }
+
+instance Applicative (ReaderT e m) where
+    pure = return
+    ReaderT cf <*> ReaderT cx = ReaderT (cf <*> cx)
+
+instance Forkable m => Forkable (ReaderT e m) where
+    forkIO (ReaderT c) = ReaderT (forkIO c)
+
+instance Functor (ReaderT e m) where
+    fmap f (ReaderT c) = ReaderT (fmap f c)
+
+instance Monad (ReaderT e m) where
+    return x = ReaderT (return x)
+    ReaderT c >>= f =
+        ReaderT (c >>= getReaderT . f)
+
+instance MonadIO m => MonadIO (ReaderT e m) where
+    liftIO c = ReaderT (liftIO c)
+
+instance Readable (ReaderT e m) where
+    type StateOf (ReaderT e m) = e
+    get = ReaderT get
+
+instance MonadTrans (ReaderT e) where
+    lift c = ReaderT (lift c)
+
+
+-- | Run a computation with environment.
+
+runReaderT :: Applicative m => e -> ReaderT e m a -> m a
+runReaderT x (ReaderT s) = evalStateT x s
+
+
 ------------
 -- StateT --
 ------------
@@ -519,9 +571,11 @@
     mzero = empty
     mplus = (<|>)
 
-instance Stateful (StateT r s m) where
+instance Readable (StateT r s m) where
     type StateOf (StateT r s m) = s
     get = StateT $ \s0 k -> k s0 s0
+
+instance Stateful (StateT r s m) where
     put s1 = s1 `seq` StateT $ \_ k -> k s1 ()
     putLazy s1 = StateT $ \_ k -> k s1 ()
 
diff --git a/contstuff.cabal b/contstuff.cabal
--- a/contstuff.cabal
+++ b/contstuff.cabal
@@ -1,5 +1,5 @@
 Name:          contstuff
-Version:       1.1.0
+Version:       1.2.0
 Category:      Control, Monads
 Synopsis:      Fast, easy to use CPS-based monad transformers
 Maintainer:    Ertugrul Söylemez <es@ertes.de>