diff --git a/Control/Lens/Readers.hs b/Control/Lens/Readers.hs
new file mode 100644
--- /dev/null
+++ b/Control/Lens/Readers.hs
@@ -0,0 +1,60 @@
+-- | Versions of the lens operators for MonadStates instead of MonadState.
+module Control.Lens.Readers
+    ( module Control.Monad.Readers
+    , asks
+    , views
+    , iview
+    , iviews
+    , review
+    , view
+    , reviews
+    , preview
+    , ipreview
+    , previews
+    ) where
+
+import Control.Lens hiding (views, iview, iviews, review, view, reviews, preview, ipreview, previews)
+import Control.Monad.Readers
+import Control.Monad.Writer (First(First, getFirst))
+import Data.Monoid -- for base < 4.8
+import Data.Profunctor.Unsafe ((#.), (.#))
+import Data.Tagged (Tagged(Tagged, unTagged))
+
+asks :: MonadReaders r m => (r -> a) -> m a
+asks = readerPoly
+
+views :: MonadReaders s m => LensLike' (Const r) s a -> (a -> r) -> m r
+views l f = asks (getConst #. l (Const #. f))
+{-# INLINE views #-}
+
+iview :: MonadReaders s m => IndexedGetting i (i,a) s a -> m (i,a)
+iview l = asks (getConst #. l (Indexed $ \i -> Const #. (,) i))
+{-# INLINE iview #-}
+
+iviews :: MonadReaders s m => IndexedGetting i r s a -> (i -> a -> r) -> m r
+iviews l f = asks (getConst #. l (Const #. Indexed f))
+{-# INLINE iviews #-}
+
+review :: MonadReaders b m => AReview t b -> m t
+review p = asks (runIdentity #. unTagged #. p .# Tagged .# Identity)
+{-# INLINE review #-}
+
+view :: MonadReaders r m => Getting a r a -> m a
+view = viewPoly
+{-# INLINE view #-}
+
+reviews :: MonadReaders b m => AReview t b -> (t -> r) -> m r
+reviews p tr = asks (tr . runIdentity #. unTagged #. p .# Tagged .# Identity)
+{-# INLINE reviews #-}
+
+preview :: MonadReaders s m => Getting (First a) s a -> m (Maybe a)
+preview l = asks (getFirst #. foldMapOf l (First #. Just))
+{-# INLINE preview #-}
+
+ipreview :: MonadReaders s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
+ipreview l = asks (getFirst #. ifoldMapOf l (\i a -> First (Just (i, a))))
+{-# INLINE ipreview #-}
+
+previews :: MonadReaders s m => Getting (First r) s a -> (a -> r) -> m (Maybe r)
+previews l f = asks (getFirst . foldMapOf l (First #. Just . f))
+{-# INLINE previews #-}
diff --git a/Control/Lens/States.hs b/Control/Lens/States.hs
new file mode 100644
--- /dev/null
+++ b/Control/Lens/States.hs
@@ -0,0 +1,60 @@
+-- | Versions of the lens operators for MonadStates instead of MonadState.
+module Control.Lens.States
+    ( module Control.Monad.States
+    , use
+    , get
+    , put
+    , (.=)
+    , (%=)
+    , (?=)
+    , (<~)
+    , (<.=)
+    , (<?=)
+    , (<>~)
+    ) where
+
+import Control.Applicative -- for base < 4.8
+import Control.Lens hiding (use, (.=), (%=), (?=), (<~), (<.=), (<?=), (<>~))
+import Control.Monad.States
+import Data.Monoid -- for base < 4.8
+
+use :: MonadStates s m => Getting a s a -> m a
+use = usePoly
+
+get :: MonadStates s m => m s
+get = getPoly
+
+put :: MonadStates s m => s -> m ()
+put = putPoly
+
+(.=) :: MonadStates s m => ASetter s s a b -> b -> m ()
+l .= b = modifyPoly (l .~ b)
+{-# INLINE (.=) #-}
+
+(%=) :: MonadStates s m => ASetter s s a b -> (a -> b) -> m ()
+l %= f = modifyPoly (l %~ f)
+{-# INLINE (%=) #-}
+
+(?=) :: MonadStates s m => ASetter s s a (Maybe b) -> b -> m ()
+l ?= b = modifyPoly (l ?~ b)
+{-# INLINE (?=) #-}
+
+(<~) :: MonadStates s m => ASetter s s a b -> m b -> m ()
+l <~ mb = mb >>= (l .=)
+{-# INLINE (<~) #-}
+
+(<.=) :: MonadStates s m => ASetter s s a b -> b -> m b
+l <.= b = do
+  l .= b
+  return b
+{-# INLINE (<.=) #-}
+
+(<?=) :: MonadStates s m => ASetter s s a (Maybe b) -> b -> m b
+l <?= b = do
+  l ?= b
+  return b
+{-# INLINE (<?=) #-}
+
+(<>~) :: Monoid a => ASetter s t a a -> a -> s -> t
+l <>~ n = over l (`mappend` n)
+{-# INLINE (<>~) #-}
diff --git a/Control/Monad/Readers.hs b/Control/Monad/Readers.hs
--- a/Control/Monad/Readers.hs
+++ b/Control/Monad/Readers.hs
@@ -6,7 +6,7 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 module Control.Monad.Readers
     ( module Control.Monad.Trans.Reader
-    , MonadReaders(askPoly, localPoly)
+    , MonadReaders(askPoly, localPoly, readerPoly)
     , viewPoly
     ) where
 
@@ -33,7 +33,7 @@
 
 import Control.Monad.Trans.Class (lift)
 -- import Control.Monad
--- import Data.Monoid
+import Data.Monoid
 
 class Monad m => MonadReaders r m where
   askPoly :: m r
diff --git a/Tests/Main.hs b/Tests/Main.hs
--- a/Tests/Main.hs
+++ b/Tests/Main.hs
@@ -7,11 +7,11 @@
 module Main where
 
 import Control.Applicative
-import Control.Lens as Lens
-import Control.Monad.Reader (ReaderT, runReader, runReaderT)
-import Control.Monad.Readers as Readers
+import qualified Control.Lens as Lens
+import Control.Lens.Readers as Readers
+import Control.Lens.States as States
+import Control.Monad.Reader as Reader (ask, local, ReaderT, runReader, runReaderT, withReaderT)
 import Control.Monad.State (evalState, lift)
-import Control.Monad.States as States
 import Test.Hspec hiding (runIO)
 import Test.Hspec.Core.Spec (SpecM)
 
@@ -30,9 +30,9 @@
     , _t :: T
     }
 
-$(makeLenses ''S)
-$(makeLenses ''T)
-$(makeLenses ''R)
+$(Lens.makeLenses ''S)
+$(Lens.makeLenses ''T)
+$(Lens.makeLenses ''R)
 
 runBoth action = runReader (runReaderT action (T 5 'x')) (S 2.5 True)
 
@@ -41,13 +41,13 @@
 -- Custom instances to direct us through stacked/nested reader monads -
 -- how to get an S from an R
 instance Monad m => MonadReaders S (ReaderT R m) where
-    askPoly = Lens.magnify s askPoly
-    localPoly f action = askPoly >>= \(r :: R) -> runReaderT (lift action) (set s (f (Lens.view s r)) r)
+    askPoly = Lens.view s
+    localPoly f action = withReaderT (Lens.over s f) action
 
 -- how to get a T from an R
 instance Monad m => MonadReaders T (ReaderT R m) where
-    askPoly = Lens.magnify t askPoly
-    localPoly f action = askPoly >>= \(r :: R) -> runReaderT (lift action) (set t (f (Lens.view t r)) r)
+    askPoly = Lens.view t
+    localPoly f action = withReaderT (Lens.over t f) action
 
 -- how to get an S from a T (it doesn't have one, we have
 -- to get it from m.)
diff --git a/mtl-unleashed.cabal b/mtl-unleashed.cabal
--- a/mtl-unleashed.cabal
+++ b/mtl-unleashed.cabal
@@ -1,5 +1,5 @@
 name:               mtl-unleashed
-version:            0.5
+version:            0.6
 cabal-version:      >= 1.10
 build-type:         Simple
 license:            BSD3
@@ -19,11 +19,13 @@
   extra type signatures.
 
 library
-  build-depends: base < 5, lens >= 4.13, mtl, contravariant, profunctors, tagged, transformers
+  build-depends: base < 5, lens >= 4.13, mtl, contravariant, profunctors, tagged, transformers, transformers-compat
   ghc-options: -Wall -O2
   exposed-modules:
     Control.Monad.Readers
     Control.Monad.States
+    Control.Lens.Readers
+    Control.Lens.States
   default-language: Haskell2010
 
 test-suite mtl-unleashed-tests