diff --git a/lens-family-core.cabal b/lens-family-core.cabal
--- a/lens-family-core.cabal
+++ b/lens-family-core.cabal
@@ -1,13 +1,13 @@
 name:               lens-family-core
 category:           Data, Lenses
-version:            1.2.1
+version:            1.2.2
 license:            BSD3
 cabal-version:      >= 1.6
 license-file:       LICENSE
 author:             Russell O'Connor
 maintainer:         Russell O'Connor <roconnor@theorem.ca>
 stability:          experimental
-copyright:          Copyright (C) 2012,2013,2014 Russell O'Connor
+copyright:          Copyright (C) 2012,2013,2014,2017 Russell O'Connor
 synopsis:           Haskell 98 Lens Families
 description:        Haskell 98 Lens Families
 build-type:         Simple
@@ -34,8 +34,8 @@
 
 library
   build-depends:
-    base                 >= 4       && < 5,
-    containers           >= 0.3     && < 0.6,
+    base                 >= 4.8     && < 5,
+    containers           >= 0.5.8   && < 0.6,
     transformers         >= 0.2.0   && < 0.6
 
   exposed-modules:
diff --git a/src/Lens/Family/Identical.hs b/src/Lens/Family/Identical.hs
--- a/src/Lens/Family/Identical.hs
+++ b/src/Lens/Family/Identical.hs
@@ -1,6 +1,5 @@
 module Lens.Family.Identical where
 
-import Control.Applicative
 import Control.Applicative.Backwards (Backwards(..))
 import Data.Functor.Identity (Identity(..))
 import Data.Functor.Compose (Compose(..))
diff --git a/src/Lens/Family/State/Lazy.hs b/src/Lens/Family/State/Lazy.hs
--- a/src/Lens/Family/State/Lazy.hs
+++ b/src/Lens/Family/State/Lazy.hs
@@ -13,6 +13,12 @@
   , (//=)
   , (&&=), (||=)
   , (<>=)
+-- * Strict Assignments
+  , (%!=)
+  , (+!=), (-!=), (*!=)
+  , (//!=)
+  , (&&!=), (||!=)
+  , (<>!=)
 -- * Types
   , Zooming
 -- * Re-exports
@@ -27,7 +33,7 @@
 import Data.Tuple (swap)
 import Control.Monad (liftM)
 import Control.Monad.Trans.Writer.Lazy (Writer, writer, runWriter)
-import Control.Monad.Trans.State.Lazy (StateT(..), state, get, modify)
+import Control.Monad.Trans.State.Lazy (StateT(..), state, get, modify, modify')
 import Lens.Family ( LensLike, LensLike'
                    , FoldLike, Constant
                    , ASetter, ASetter', Identity
@@ -149,3 +155,32 @@
 -- | Monoidally append a value to all referenced fields of the state.
 (<>=) :: (Monoid o, Monad m) => ASetter' a o -> o -> StateT a m ()
 f <>= b = f %= (`mappend` b)
+
+infix 4 %!=
+
+-- | Strictly modify a field of the state.
+(%!=) :: Monad m => ASetter a a b b' -> (b -> b') -> StateT a m ()
+l %!= f = modify' (l %~ f)
+
+infixr 4 +!=, -!=, *!=
+
+(+!=), (-!=), (*!=) :: (Monad m, Num b) => ASetter' a b -> b -> StateT a m ()
+f +!= b = f %!= (+ b)
+f -!= b = f %!= subtract b
+f *!= b = f %!= (* b)
+
+infixr 4 //!=
+
+(//!=) :: (Monad m, Fractional b) => ASetter' a b -> b -> StateT a m ()
+f //!= b = f %!= (/ b)
+
+infixr 4 &&!=, ||!=
+
+(&&!=), (||!=) :: Monad m => ASetter' a Bool -> Bool -> StateT a m ()
+f &&!= b = f %!= (&& b)
+f ||!= b = f %!= (|| b)
+
+infixr 4 <>!=
+
+(<>!=) :: (Monoid o, Monad m) => ASetter' a o -> o -> StateT a m ()
+f <>!= b = f %!= (`mappend` b)
diff --git a/src/Lens/Family/State/Strict.hs b/src/Lens/Family/State/Strict.hs
--- a/src/Lens/Family/State/Strict.hs
+++ b/src/Lens/Family/State/Strict.hs
@@ -13,6 +13,12 @@
   , (//=)
   , (&&=), (||=)
   , (<>=)
+-- * Strict Assignments
+  , (%!=)
+  , (+!=), (-!=), (*!=)
+  , (//!=)
+  , (&&!=), (||!=)
+  , (<>!=)
 -- * Types
   , Zooming
 -- * Re-exports
@@ -27,7 +33,7 @@
 import Data.Tuple (swap)
 import Control.Monad (liftM)
 import Control.Monad.Trans.Writer.Lazy (Writer, writer, runWriter)
-import Control.Monad.Trans.State.Strict (StateT(..), state, get, modify)
+import Control.Monad.Trans.State.Strict (StateT(..), state, get, modify, modify')
 import Lens.Family ( LensLike, LensLike'
                    , FoldLike, Constant
                    , ASetter, ASetter', Identity
@@ -149,3 +155,32 @@
 -- | Monoidally append a value to all referenced fields of the state.
 (<>=) :: (Monoid o, Monad m) => ASetter' a o -> o -> StateT a m ()
 f <>= b = f %= (`mappend` b)
+
+infix 4 %!=
+
+-- | Strictly modify a field of the state.
+(%!=) :: Monad m => ASetter a a b b' -> (b -> b') -> StateT a m ()
+l %!= f = modify' (l %~ f)
+
+infixr 4 +!=, -!=, *!=
+
+(+!=), (-!=), (*!=) :: (Monad m, Num b) => ASetter' a b -> b -> StateT a m ()
+f +!= b = f %!= (+ b)
+f -!= b = f %!= subtract b
+f *!= b = f %!= (* b)
+
+infixr 4 //!=
+
+(//!=) :: (Monad m, Fractional b) => ASetter' a b -> b -> StateT a m ()
+f //!= b = f %!= (/ b)
+
+infixr 4 &&!=, ||!=
+
+(&&!=), (||!=) :: Monad m => ASetter' a Bool -> Bool -> StateT a m ()
+f &&!= b = f %!= (&& b)
+f ||!= b = f %!= (|| b)
+
+infixr 4 <>!=
+
+(<>!=) :: (Monoid o, Monad m) => ASetter' a o -> o -> StateT a m ()
+f <>!= b = f %!= (`mappend` b)
diff --git a/src/Lens/Family/Stock.hs b/src/Lens/Family/Stock.hs
--- a/src/Lens/Family/Stock.hs
+++ b/src/Lens/Family/Stock.hs
@@ -10,6 +10,7 @@
   , chosen
   , ix
   , at, intAt
+  , at', intAt'
   , contains, intContains
 -- * Stock Traversals
   , both
@@ -32,6 +33,8 @@
 import Lens.Family.Phantom (Phantom, coerce)
 import qualified Data.Map as Map
 import qualified Data.IntMap as IntMap
+import qualified Data.Map.Strict as Map'
+import qualified Data.IntMap.Strict as IntMap'
 import qualified Data.Set as Set
 import qualified Data.IntSet as IntSet
 
@@ -98,7 +101,7 @@
 -- @
 --
 -- Lens on a given point of a 'Map.Map'.
-at k = lens (Map.lookup k) (\m -> maybe (Map.delete k m) (\v' -> Map.insert k v' m))
+at = flip Map.alterF
 
 intAt :: Functor f => Int -> LensLike' f (IntMap.IntMap v) (Maybe v)
 -- ^ @
@@ -106,7 +109,23 @@
 -- @
 --
 -- Lens on a given point of a 'IntMap.IntMap'.
-intAt k = lens (IntMap.lookup k) (\m -> maybe (IntMap.delete k m) (\v' -> IntMap.insert k v' m))
+intAt = flip IntMap.alterF
+
+at' :: (Ord k, Functor f) => k -> LensLike' f (Map.Map k v) (Maybe v)
+-- ^ @
+-- at :: Ord k => k -> Lens' (Map.Map k v) (Maybe v)
+-- @
+--
+-- Lens providing strict access to a given point of a 'Map.Map'.
+at' = flip Map'.alterF
+
+intAt' :: Functor f => Int -> LensLike' f (IntMap.IntMap v) (Maybe v)
+-- ^ @
+-- intAt :: Int -> Lens (IntMap.IntMap v) (Maybe v)
+-- @
+--
+-- Lens providing strict access to a given point of a 'IntMap.IntMap'.
+intAt' = flip IntMap'.alterF
 
 contains :: (Ord k, Functor f) => k -> LensLike' f (Set.Set k) Bool
 -- ^ @