diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## 1.1.0
+### Added
+* instances of `MonadHReader` for `MaybeT` and `IdentityT`
+* method 'hlocal' in `MonadHReader`
+
 ## 1.0.2
 ### Added
 * added forgotten `MonadMask` instance
diff --git a/hreader.cabal b/hreader.cabal
--- a/hreader.cabal
+++ b/hreader.cabal
@@ -1,5 +1,5 @@
 name:                hreader
-version:             1.0.2
+version:             1.1.0
 synopsis:            Generalization of MonadReader and ReaderT using hset
 license:             BSD3
 license-file:        LICENSE
@@ -41,6 +41,7 @@
                      , monad-control
                      , mtl
                      , tagged
+                     , transformers
                      , transformers-base
 
   exposed-modules:     Control.Monad.HReader
diff --git a/src/Control/Monad/HReader.hs b/src/Control/Monad/HReader.hs
--- a/src/Control/Monad/HReader.hs
+++ b/src/Control/Monad/HReader.hs
@@ -19,6 +19,8 @@
 import Data.Typeable
 import GHC.Generics
 
+import qualified Control.Monad.Trans.Reader as Reader
+
 #if MIN_VERSION_mtl(2, 2, 1)
 import Control.Monad.Except
 #else
@@ -78,6 +80,7 @@
 instance (Monad m, Applicative m) => MonadHReader (HReaderT els m) where
   type MHRElements (HReaderT els m) = els
   askHSet = HReaderT ask
+  hlocal f (HReaderT r) = HReaderT $ Reader.local f r
 
 deriving instance MFunctor (HReaderT els)
 deriving instance MMonad (HReaderT els)
diff --git a/src/Control/Monad/HReader/Class.hs b/src/Control/Monad/HReader/Class.hs
--- a/src/Control/Monad/HReader/Class.hs
+++ b/src/Control/Monad/HReader/Class.hs
@@ -9,6 +9,9 @@
 import Control.Monad.Cont
 import Control.Monad.List
 import Control.Monad.Reader
+import Control.Monad.Trans.Control
+import Control.Monad.Trans.Identity
+import Control.Monad.Trans.Maybe
 import Data.HSet
 import Data.Tagged
 import GHC.Exts
@@ -22,12 +25,13 @@
 import Data.Monoid
 #endif
 
-import qualified Control.Monad.RWS.Lazy       as RWSL
-import qualified Control.Monad.RWS.Strict     as RWSS
-import qualified Control.Monad.State.Lazy     as SL
-import qualified Control.Monad.State.Strict   as SS
-import qualified Control.Monad.Writer.Lazy    as WL
-import qualified Control.Monad.Writer.Strict  as WS
+import qualified Control.Monad.RWS.Lazy      as RWSL
+import qualified Control.Monad.RWS.Strict    as RWSS
+import qualified Control.Monad.State.Lazy    as SL
+import qualified Control.Monad.State.Strict  as SS
+import qualified Control.Monad.Trans.Cont    as Cont
+import qualified Control.Monad.Writer.Lazy   as WL
+import qualified Control.Monad.Writer.Strict as WS
 
 -- | Easy generate constraint like
 -- __(HGettable (MHRElements m) Int, HGettable (MHRElements m) Bool)__
@@ -41,27 +45,25 @@
 class (Monad m, Applicative m) => MonadHReader m where
   type MHRElements m :: [*]
   askHSet :: m (HSet (MHRElements m))
+  hlocal :: (HSet (MHRElements m) -> HSet (MHRElements m)) -> m a -> m a
 
--- | Ask arbitrary element of hset inside HReader
-hask :: (MonadHReader m, HGettable (MHRElements m) e)
-      => m e
-hask = hget <$> askHSet
 
--- | Ask arbitrary labeled element of hset in HReader
-haskTagged :: (MonadHReader m, HGettable (MHRElements m) (Tagged tag e))
-           => proxy tag
-           -> m e
-haskTagged p = hgetTagged p <$> askHSet
+instance (MonadHReader m) => MonadHReader (ContT r m) where
+  type MHRElements (ContT r m) = MHRElements m
+  askHSet = lift askHSet
+  hlocal = Cont.liftLocal askHSet hlocal
 
 #define MHR(MONAD)                                        \
 instance (MonadHReader m) => MonadHReader (MONAD) where { \
   type MHRElements (MONAD) = MHRElements m ;            \
   askHSet = lift askHSet ;                                \
+  hlocal f ma = liftThrough (hlocal f) ma  ; \
   }
 
+MHR(IdentityT m)
 MHR(ReaderT r m)
-MHR(ContT r m)
 MHR(ListT m)
+MHR(MaybeT m)
 
 #if MIN_VERSION_mtl(2, 2, 1)
 MHR(ExceptT e m)
@@ -70,18 +72,26 @@
 MHR(SL.StateT s m)
 MHR(SS.StateT s m)
 
-instance (MonadHReader m, Monoid w) => MonadHReader (WL.WriterT w m) where
-  type MHRElements (WL.WriterT w m) = MHRElements m
-  askHSet = lift askHSet
 
-instance (MonadHReader m, Monoid w) => MonadHReader (WS.WriterT w m) where
-  type MHRElements (WS.WriterT w m) = MHRElements m
-  askHSet = lift askHSet
+#define MHRWRITER(MONAD)                                        \
+instance (MonadHReader m, Monoid w) => MonadHReader (MONAD) where { \
+  type MHRElements (MONAD) = MHRElements m ;            \
+  askHSet = lift askHSet ;                                \
+  hlocal f ma = liftThrough (hlocal f) ma  ; \
+  }
 
-instance (MonadHReader m, Monoid w) => MonadHReader (RWSL.RWST r w s m) where
-  type MHRElements (RWSL.RWST r w s m) = MHRElements m
-  askHSet = lift askHSet
+MHRWRITER(WL.WriterT w m)
+MHRWRITER(WS.WriterT w m)
+MHRWRITER(RWSL.RWST r w s m)
+MHRWRITER(RWSS.RWST r w s m)
 
-instance (MonadHReader m, Monoid w) => MonadHReader (RWSS.RWST r w s m) where
-  type MHRElements (RWSS.RWST r w s m) = MHRElements m
-  askHSet = lift askHSet
+-- | Ask arbitrary element of hset inside HReader
+hask :: (MonadHReader m, HGettable (MHRElements m) e)
+      => m e
+hask = hget <$> askHSet
+
+-- | Ask arbitrary labeled element of hset in HReader
+haskTagged :: (MonadHReader m, HGettable (MHRElements m) (Tagged tag e))
+           => proxy tag
+           -> m e
+haskTagged p = hgetTagged p <$> askHSet