diff --git a/data-accessor.cabal b/data-accessor.cabal
--- a/data-accessor.cabal
+++ b/data-accessor.cabal
@@ -1,5 +1,5 @@
 Name:             data-accessor
-Version:          0.1.4
+Version:          0.2
 License:          BSD3
 License-File:     LICENSE
 Author:           Henning Thielemann <haskell@henning-thielemann.de>, Luke Palmer <lrpalmer@gmail.com>
@@ -9,7 +9,7 @@
 Category:         Data
 -- Portability:      Haskell98, not quite because of MTL dependency
 Build-Type:       Simple
-Build-Depends:    base>=1.0, array, containers, mtl
+Build-Depends:    base>=1.0, array >=0.1 && <0.2, containers >=0.1 && <0.2, transformers >=0.0.1 && <0.1
 Synopsis:         Utilities for accessing and manipulating fields of records
 Description:
   In Haskell 98 the name of a record field
diff --git a/src/Data/Accessor.hs b/src/Data/Accessor.hs
--- a/src/Data/Accessor.hs
+++ b/src/Data/Accessor.hs
@@ -14,7 +14,7 @@
 
 import qualified Data.Accessor.Basic as Accessor
 import qualified Data.Accessor.MonadState as State
-import Control.Monad.State (MonadState, )
+import Control.Monad.Trans.State (StateT, )
 
 -- |An @Accessor r a@ is an object that encodes how to
 -- get and put a subject of type @a@ out of/into an object
@@ -80,7 +80,7 @@
 
 > (=:) = putA
 -}
-(=:) :: MonadState r m => Accessor r a -> a -> m ()
+(=:) :: Monad m => Accessor r a -> a -> StateT r m ()
 (=:) = putA
 
 
@@ -92,24 +92,24 @@
 that provides more consistency with the infix operators for records
 (without State monad).
 -}
-(%=) :: MonadState r m => Accessor r a -> a -> m ()
+(%=) :: Monad m => Accessor r a -> a -> StateT r m ()
 (%=) = putA
 
 {- |
 Infix variant of 'modA'.
 -}
-(%:) :: MonadState r m => Accessor r a -> (a -> a) -> m ()
+(%:) :: Monad m => Accessor r a -> (a -> a) -> StateT r m ()
 (%:) = modA
 -}
 
 -- |A structural dereference function for state monads.
-getA :: MonadState r m => Accessor r a -> m a
+getA :: Monad m => Accessor r a -> StateT r m a
 getA = State.get
 
 -- |A structural assignment function for state monads.
-putA :: MonadState r m => Accessor r a -> a -> m ()
+putA :: Monad m => Accessor r a -> a -> StateT r m ()
 putA = State.set
 
 -- |A structural modification function for state monads.
-modA :: MonadState r m => Accessor r a -> (a -> a) -> m ()
+modA :: Monad m => Accessor r a -> (a -> a) -> StateT r m ()
 modA = State.modify
diff --git a/src/Data/Accessor/Basic.hs b/src/Data/Accessor/Basic.hs
--- a/src/Data/Accessor/Basic.hs
+++ b/src/Data/Accessor/Basic.hs
@@ -34,17 +34,28 @@
    Cons $ \ x r -> let (y,f) = lens r in (y, f x)
 
 
+-- Simple accessors
+
 {- |
-Simple accessor: Access the record itself
+Access the record itself
 -}
 self :: T r r
 self = fromSetGet const id
 
 {- |
-Simple accessor: Access a (non-existing) element of type @()@
+Access a (non-existing) element of type @()@
 -}
 null :: T r ()
 null = fromSetGet (flip const) (const ())
+
+{-
+{- |
+Access the result of a function.
+Cf. "http://conal.net/blog/posts/semantic-editor-combinators/"
+-}
+result :: a -> T (a -> r) r
+result = fromSetGet (flip const) (const ())
+-}
 
 
 -- * Apply accessors, similar to State methods
diff --git a/src/Data/Accessor/BinaryRead.hs b/src/Data/Accessor/BinaryRead.hs
--- a/src/Data/Accessor/BinaryRead.hs
+++ b/src/Data/Accessor/BinaryRead.hs
@@ -8,8 +8,10 @@
 
 import qualified Data.Accessor.Basic as Accessor
 
-import qualified Control.Monad.State as State
-import Control.Monad.State (MonadState, StateT, )
+import qualified Control.Monad.Trans.State as State
+import Control.Monad.Trans.State (StateT, )
+import Control.Monad.Trans (lift, )
+import Control.Monad (liftM, )
 import Data.Word (Word8, )
 import Data.Char (chr, )
 
@@ -42,7 +44,7 @@
 instance (ByteStream s, Monad m) => ByteSource (StateT s m) where
    readWord8 =
       do xs <- State.get
-         (c,cs) <- State.lift (getWord8 xs)
+         (c,cs) <- lift (getWord8 xs)
          State.put cs
          return c
 
@@ -51,7 +53,7 @@
 
 instance C Char where
    any =
-      State.liftM (chr . fromIntegral) readWord8
+      liftM (chr . fromIntegral) readWord8
 
 instance C Int where
    any =
diff --git a/src/Data/Accessor/Container.hs b/src/Data/Accessor/Container.hs
--- a/src/Data/Accessor/Container.hs
+++ b/src/Data/Accessor/Container.hs
@@ -5,12 +5,16 @@
 consisting of arrays, maps and records.
 -}
 module Data.Accessor.Container
-   (array, mapDefault, mapMaybe, ) where
+   (array,
+    mapDefault, mapMaybe,
+    intMapDefault, intMapMaybe,
+   ) where
 
 import qualified Data.Accessor.Basic as Accessor
 
-import qualified Data.Array as Array
-import qualified Data.Map   as Map
+import qualified Data.Array  as Array
+import qualified Data.Map    as Map
+import qualified Data.IntMap as IntMap
 
 import Prelude hiding (map)
 
@@ -36,3 +40,13 @@
    Accessor.fromSetGet
       (\e m -> maybe (Map.delete key m) (flip (Map.insert key) m) e)
       (Map.lookup key)
+
+intMapDefault :: elem -> Int -> Accessor.T (IntMap.IntMap elem) elem
+intMapDefault deflt key =
+   Accessor.fromSetGet (IntMap.insert key) (IntMap.findWithDefault deflt key)
+
+intMapMaybe :: Int -> Accessor.T (IntMap.IntMap elem) (Maybe elem)
+intMapMaybe key =
+   Accessor.fromSetGet
+      (\e m -> maybe (IntMap.delete key m) (flip (IntMap.insert key) m) e)
+      (IntMap.lookup key)
diff --git a/src/Data/Accessor/Example.hs b/src/Data/Accessor/Example.hs
--- a/src/Data/Accessor/Example.hs
+++ b/src/Data/Accessor/Example.hs
@@ -13,7 +13,7 @@
 
 import Data.Accessor.MonadState ((%=), (%:), )
 import qualified Data.Accessor.MonadState as AState
-import Control.Monad.State (State)
+import Control.Monad.Trans.State (State)
 import Data.Char (ord, toUpper, )
 
 import Prelude hiding (init)
@@ -43,6 +43,13 @@
       first.>first %= 'b'
       second %= '!' : str
       AState.get (first.>second)
+
+stateLift :: State (Int, (Bool, Char)) ()
+stateLift = do
+  first %= 42
+  AState.lift second $ do
+    first  %: not
+    second %= 'q'
 
 init :: (Char,Int)
 init =
diff --git a/src/Data/Accessor/MonadState.hs b/src/Data/Accessor/MonadState.hs
--- a/src/Data/Accessor/MonadState.hs
+++ b/src/Data/Accessor/MonadState.hs
@@ -2,22 +2,26 @@
 module Data.Accessor.MonadState where
 
 import qualified Data.Accessor.Basic as Accessor
-import qualified Control.Monad.State as State
-import Control.Monad.State (MonadState, )
+import qualified Control.Monad.Trans.State as State
+import qualified Control.Monad.Trans as Trans
+import Control.Monad.Trans.State (State, runState, StateT(runStateT), )
+import Control.Monad.Trans (MonadTrans)
 
-set :: MonadState r m => Accessor.T r a -> a -> m ()
+-- * accessors in the form of actions in the state monad
+
+set :: Monad m => Accessor.T r a -> a -> StateT r m ()
 set f x = State.modify (Accessor.set f x)
 
-get :: MonadState r m => Accessor.T r a -> m a
+get :: Monad m => Accessor.T r a -> StateT r m a
 get f = State.gets (Accessor.get f)
 
-modify :: MonadState r m => Accessor.T r a -> (a -> a) -> m ()
+modify :: Monad m => Accessor.T r a -> (a -> a) -> StateT r m ()
 modify f g = State.modify (Accessor.modify f g)
 
 {- |
 Modify a record element and return its old value.
 -}
-getAndModify :: MonadState r m => Accessor.T r a -> (a -> a) -> m a
+getAndModify :: Monad m => Accessor.T r a -> (a -> a) -> StateT r m a
 getAndModify f g =
    do x <- get f
       modify f g
@@ -26,7 +30,7 @@
 {- |
 Modify a record element and return its new value.
 -}
-modifyAndGet :: MonadState r m => Accessor.T r a -> (a -> a) -> m a
+modifyAndGet :: Monad m => Accessor.T r a -> (a -> a) -> StateT r m a
 modifyAndGet f g =
    do modify f g
       get f
@@ -38,11 +42,30 @@
 {- |
 Infix variant of 'set'.
 -}
-(%=) :: MonadState r m => Accessor.T r a -> a -> m ()
+(%=) :: Monad m => Accessor.T r a -> a -> StateT r m ()
 (%=) = set
 
 {- |
 Infix variant of 'modify'.
 -}
-(%:) :: MonadState r m => Accessor.T r a -> (a -> a) -> m ()
+(%:) :: Monad m => Accessor.T r a -> (a -> a) -> StateT r m ()
 (%:) = modify
+
+
+
+-- * lift a state monadic accessor to an accessor of a parent record
+
+lift :: Monad m => Accessor.T r s -> State s a -> StateT r m a
+lift f m =
+   do s0 <- get f
+      let (a,s1) = runState m s0
+      set f s1
+      return a
+
+liftT :: (Monad m) =>
+   Accessor.T r s -> StateT s m a -> StateT r m a
+liftT f m =
+   do s0 <- get f
+      (a,s1) <- Trans.lift $ runStateT m s0
+      set f s1
+      return a