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.1
+Version:          0.1.2
 License:          GPL
 License-File:     LICENSE
 Author:           Henning Thielemann <haskell@henning-thielemann.de>, Luke Palmer <lrpalmer@gmail.com>
diff --git a/src/Data/Accessor.hs b/src/Data/Accessor.hs
--- a/src/Data/Accessor.hs
+++ b/src/Data/Accessor.hs
@@ -5,8 +5,9 @@
 In contrast to "Data.Accessor.Basic" it is intended for unqualified import.
 -}
 module Data.Accessor
-    ( Accessor, accessor, setVal, getVal,
-      getA, putA, (=:), modA,
+    ( Accessor, accessor,
+      setVal, (Accessor.^=), getVal, (Accessor.^.), (Accessor.^:),
+      getA, putA, (=:), (State.%=), modA, (State.%:),
       (.>), (<.),
     )
 where
@@ -15,39 +16,39 @@
 import qualified Data.Accessor.MonadState as State
 import Control.Monad.State (MonadState, )
 
--- |An @Accessor s a@ is an object that encodes how to
+-- |An @Accessor r a@ is an object that encodes how to
 -- get and put a subject of type @a@ out of/into an object
 -- of type @s@.
 --
 -- In order for an instance of this data structure @a@ to be
 -- an 'Accessor', it must obey the following laws:
 --
--- > getVal a (setVal a x s) = x
--- > setVal a (getVal a s) s = s
-type Accessor s a = Accessor.T s a
+-- > getVal a (setVal a x r) = x
+-- > setVal a (getVal a r) r = r
+type Accessor r a = Accessor.T r a
 
 
 -- |Construct an 'Accessor' from a @get@ and a @set@ method.
 --
 accessor ::
-      (s -> a)       {- ^ get method -}
-   -> (a -> s -> s)  {- ^ set method -}
-   -> Accessor s a
+      (r -> a)       {- ^ get method -}
+   -> (a -> r -> r)  {- ^ set method -}
+   -> Accessor r a
 accessor = flip Accessor.fromSetGet
 
 -- |Get a value from a record field that is specified by an Accessor
 getVal ::
-      Accessor s a   {- ^ record field -}
-   -> s              {- ^ record -}
+      Accessor r a   {- ^ record field -}
+   -> r              {- ^ record -}
    -> a              {- ^ value of the field in the record -}
 getVal = Accessor.get
 
 -- |Set a value of a record field that is specified by an Accessor
 setVal ::
-      Accessor s a   {- ^ record field  @f@ -}
+      Accessor r a   {- ^ record field  @f@ -}
    -> a              {- ^ value @x@ to be set -}
-   -> s              {- ^ original record -}
-   -> s              {- ^ new record with field @f@ changed to @x@ -}
+   -> r              {- ^ original record -}
+   -> r              {- ^ new record with field @f@ changed to @x@ -}
 setVal = Accessor.set
 
 
@@ -74,20 +75,41 @@
 
 
 infix 1 =:
--- |An \"assignment operator\" for state monads.
---
--- > (=:) = putA
-(=:) :: MonadState s m => Accessor s a -> a -> m ()
+{- |
+An \"assignment operator\" for state monads.
+
+> (=:) = putA
+-}
+(=:) :: MonadState r m => Accessor r a -> a -> m ()
 (=:) = putA
 
+
+{-
+infix 1 %=, %:
+
+{- |
+Another infix variant of 'putA'
+that provides more consistency with the infix operators for records
+(without State monad).
+-}
+(%=) :: MonadState r m => Accessor r a -> a -> m ()
+(%=) = putA
+
+{- |
+Infix variant of 'modA'.
+-}
+(%:) :: MonadState r m => Accessor r a -> (a -> a) -> m ()
+(%:) = modA
+-}
+
 -- |A structural dereference function for state monads.
-getA :: MonadState s m => Accessor s a -> m a
+getA :: MonadState r m => Accessor r a -> m a
 getA = State.get
 
 -- |A structural assignment function for state monads.
-putA :: MonadState s m => Accessor s a -> a -> m ()
+putA :: MonadState r m => Accessor r a -> a -> m ()
 putA = State.set
 
 -- |A structural modification function for state monads.
-modA :: MonadState s m => Accessor s a -> (a -> a) -> m ()
+modA :: MonadState r m => Accessor r a -> (a -> a) -> 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
@@ -4,10 +4,11 @@
 -}
 module Data.Accessor.Basic (
    T, fromSetGet, fromLens,
-   set, setMany, compose, (^=),
+   set, (^=), compose,
    get, (^.),
    modify, (^:),
-   ($%), (<.), (.>),
+   (.>), (<.),
+   ($%),
    ) where
 
 {- |
@@ -45,6 +46,7 @@
 (^=) :: T r a -> a -> (r -> r)
 (^=) = set
 
+{-
 {- | Set many fields at once.
 
 This function could also be used for initialisation of record,
@@ -56,6 +58,7 @@
 -}
 setMany :: [r -> (a, r)] -> r -> r
 setMany = flip (foldl (\x f -> snd (f x)))
+-}
 
 {- |
 This is a general function,
@@ -72,7 +75,8 @@
 
 {- |
 'get' as infix operator.
-This lets us write @record^.field^.subfield@
+This lets us write @record^.field^.subfield@.
+This imitates Modula II syntax.
 -}
 (^.) :: r -> T r a -> a
 (^.) = flip get
@@ -87,7 +91,9 @@
 
 {- |
 'modify' as infix operator.
-This lets us write @record$%field^:subfield^:(1+)@
+This lets us write
+@field^:subfield^:(2*) $ record@,
+@record$%field^:subfield^:(2*)@
 or @record$%field^:subfield^:(const 1)@.
 -}
 (^:) :: T r a -> (a -> a) -> (r -> r)
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
@@ -7,6 +7,7 @@
 import qualified Data.Accessor.BinaryRead as Read
 import qualified Data.Accessor.Show as Show
 
+import Data.Accessor.MonadState ((%=), (%:), )
 import qualified Data.Accessor.MonadState as AState
 import Control.Monad.State (State)
 import Data.Char (ord, )
@@ -29,6 +30,15 @@
    do AState.set first 'a'
       AState.modify second succ
       AState.get second
+
+stateInfix :: State ((Char, Int), String) Int
+stateInfix =
+   do str <- AState.get second
+      first.>first %= 'a'
+      first.>second %: succ
+      first.>first %= 'b'
+      second %= '!' : str
+      AState.get (first.>second)
 
 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
@@ -13,3 +13,18 @@
 
 modify :: MonadState r m => Accessor.T r a -> (a -> a) -> m ()
 modify f g = State.modify (Accessor.modify f g)
+
+
+infix 1 %=, %:
+
+{- |
+Infix variant of 'set'.
+-}
+(%=) :: MonadState r m => Accessor.T r a -> a -> m ()
+(%=) = set
+
+{- |
+Infix variant of 'modify'.
+-}
+(%:) :: MonadState r m => Accessor.T r a -> (a -> a) -> m ()
+(%:) = modify
diff --git a/src/Data/Accessor/Show.hs b/src/Data/Accessor/Show.hs
--- a/src/Data/Accessor/Show.hs
+++ b/src/Data/Accessor/Show.hs
@@ -1,7 +1,7 @@
 {- |
 Support for creating Show instances using the accessors.
 -}
-module Data.Accessor.Show where
+module Data.Accessor.Show (field, showsPrec) where
 
 import qualified Data.Accessor.Basic as Accessor