diff --git a/Control/Monad/Ref.hs b/Control/Monad/Ref.hs
--- a/Control/Monad/Ref.hs
+++ b/Control/Monad/Ref.hs
@@ -1,20 +1,20 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE UndecidableInstances #-}
+{-# OPTIONS_GHC -fno-warn-warnings-deprecations #-}
+
 -- |
 -- Module      :  Control.Monad.Ref
 -- Copyright   :  (c) Harvard University 2006-2011
---                (c) Geoffrey Mainland 2011-2012
+--                (c) Geoffrey Mainland 2011-2014
 -- License     :  BSD-style
--- Maintainer  :  mainland@eecs.harvard.edu
+-- Maintainer  :  Geoffrey Mainland <mainland@cs.drexel.edu>
 --
 -- Stability   :  experimental
 -- Portability :  non-portable
---
---------------------------------------------------------------------------------
 
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE UndecidableInstances #-}
-
 module Control.Monad.Ref (
     MonadRef(..),
     MonadAtomicRef(..)
@@ -28,6 +28,9 @@
 import Control.Monad.ST (ST)
 import Control.Monad.Trans.Cont (ContT)
 import Control.Monad.Trans.Error (ErrorT, Error)
+#if MIN_VERSION_transformers(0,4,0)
+import Control.Monad.Trans.Except (ExceptT)
+#endif /* MIN_VERSION_transformers(0,4,0) */
 import Control.Monad.Trans.Identity (IdentityT)
 import Control.Monad.Trans.List (ListT)
 import Control.Monad.Trans.Maybe (MaybeT)
@@ -38,6 +41,10 @@
 import Control.Monad.Trans.Writer.Strict as Strict (WriterT)
 import Control.Monad.Trans.Class (lift)
 import Data.IORef (IORef,
+#if MIN_VERSION_base(4,6,0)
+                   atomicModifyIORef',
+                   modifyIORef',
+#endif /* MIN_VERSION_base(4,6,0) */
                    atomicModifyIORef,
                    modifyIORef,
                    newIORef,
@@ -45,6 +52,9 @@
                    writeIORef)
 import Data.Monoid (Monoid)
 import Data.STRef (STRef,
+#if MIN_VERSION_base(4,6,0)
+                   modifySTRef',
+#endif /* MIN_VERSION_base(4,6,0) */
                    modifySTRef,
                    newSTRef,
                    readSTRef,
@@ -64,22 +74,39 @@
     -- |Mutate the contents of a reference
     modifyRef :: r a -> (a -> a) -> m ()
     modifyRef r f = readRef r >>= writeRef r . f
+    -- |Strict version of 'modifyRef'
+    modifyRef' :: r a -> (a -> a) -> m ()
+    modifyRef' r f = readRef r >>= \x -> let x' = f x in x' `seq` writeRef r x'
 
 class (MonadRef r m) => MonadAtomicRef r m | m -> r where
     -- |Atomically mutate the contents of a reference
     atomicModifyRef :: r a -> (a -> (a, b)) -> m b
+    -- |Strict version of atomicModifyRef. This forces both the value stored in
+    -- the reference as well as the value returned.
+    atomicModifyRef' :: r a -> (a -> (a, b)) -> m b
+    atomicModifyRef' r f = do
+        b <- atomicModifyRef r
+                (\x -> let (a, b) = f x
+                        in (a, a `seq` b))
+        b `seq` return b
 
 instance MonadRef (STRef s) (ST s) where
-    newRef    = newSTRef
-    readRef   = readSTRef
-    writeRef  = writeSTRef
-    modifyRef = modifySTRef
+    newRef     = newSTRef
+    readRef    = readSTRef
+    writeRef   = writeSTRef
+    modifyRef  = modifySTRef
+#if MIN_VERSION_base(4,6,0)
+    modifyRef' = modifySTRef'
+#endif /* MIN_VERSION_base(4,6,0) */
 
 instance MonadRef IORef IO where
-    newRef    = newIORef
-    readRef   = readIORef
-    writeRef  = writeIORef
-    modifyRef = modifyIORef
+    newRef     = newIORef
+    readRef    = readIORef
+    writeRef   = writeIORef
+    modifyRef  = modifyIORef
+#if MIN_VERSION_base(4,6,0)
+    modifyRef' = modifyIORef'
+#endif /* MIN_VERSION_base(4,6,0) */
 
 instance MonadRef TVar STM where
     newRef    = newTVar
@@ -87,67 +114,89 @@
     writeRef  = writeTVar
 
 instance MonadRef r m => MonadRef r (ContT r' m) where
-    newRef    r   = lift $ newRef    r
-    readRef   r   = lift $ readRef   r
-    writeRef  r x = lift $ writeRef  r x
-    modifyRef r f = lift $ modifyRef r f
+    newRef     r   = lift $ newRef     r
+    readRef    r   = lift $ readRef    r
+    writeRef   r x = lift $ writeRef   r x
+    modifyRef  r f = lift $ modifyRef  r f
+    modifyRef' r f = lift $ modifyRef' r f
 
 instance (Error e, MonadRef r m) => MonadRef r (ErrorT e m) where
-    newRef    r   = lift $ newRef    r
-    readRef   r   = lift $ readRef   r
-    writeRef  r x = lift $ writeRef  r x
-    modifyRef r f = lift $ modifyRef r f
+    newRef     r   = lift $ newRef     r
+    readRef    r   = lift $ readRef    r
+    writeRef   r x = lift $ writeRef   r x
+    modifyRef  r f = lift $ modifyRef  r f
+    modifyRef' r f = lift $ modifyRef' r f
 
+#if MIN_VERSION_transformers(0,4,0)
+instance (MonadRef r m) => MonadRef r (ExceptT e m) where
+    newRef     r   = lift $ newRef     r
+    readRef    r   = lift $ readRef    r
+    writeRef   r x = lift $ writeRef   r x
+    modifyRef  r f = lift $ modifyRef  r f
+    modifyRef' r f = lift $ modifyRef' r f
+#endif /* MIN_VERSION_transformers(0,4,0) */
+
 instance MonadRef r m => MonadRef r (IdentityT m) where
-    newRef    r   = lift $ newRef    r
-    readRef   r   = lift $ readRef   r
-    writeRef  r x = lift $ writeRef  r x
-    modifyRef r f = lift $ modifyRef r f
+    newRef     r   = lift $ newRef     r
+    readRef    r   = lift $ readRef    r
+    writeRef   r x = lift $ writeRef   r x
+    modifyRef  r f = lift $ modifyRef  r f
+    modifyRef' r f = lift $ modifyRef' r f
 
 instance MonadRef r m => MonadRef r (ListT m) where
-    newRef    r   = lift $ newRef    r
-    readRef   r   = lift $ readRef   r
-    writeRef  r x = lift $ writeRef  r x
-    modifyRef r f = lift $ modifyRef r f
+    newRef     r   = lift $ newRef     r
+    readRef    r   = lift $ readRef    r
+    writeRef   r x = lift $ writeRef   r x
+    modifyRef  r f = lift $ modifyRef  r f
+    modifyRef' r f = lift $ modifyRef' r f
 
 instance MonadRef r m => MonadRef r (MaybeT m) where
-    newRef    r   = lift $ newRef    r
-    readRef   r   = lift $ readRef   r
-    writeRef  r x = lift $ writeRef  r x
-    modifyRef r f = lift $ modifyRef r f
+    newRef     r   = lift $ newRef     r
+    readRef    r   = lift $ readRef    r
+    writeRef   r x = lift $ writeRef   r x
+    modifyRef  r f = lift $ modifyRef  r f
+    modifyRef' r f = lift $ modifyRef' r f
 
 instance MonadRef r m => MonadRef r (ReaderT r' m) where
-    newRef    r   = lift $ newRef    r
-    readRef   r   = lift $ readRef   r
-    writeRef  r x = lift $ writeRef  r x
-    modifyRef r f = lift $ modifyRef r f
+    newRef     r   = lift $ newRef     r
+    readRef    r   = lift $ readRef    r
+    writeRef   r x = lift $ writeRef   r x
+    modifyRef  r f = lift $ modifyRef  r f
+    modifyRef' r f = lift $ modifyRef' r f
 
 instance MonadRef r m => MonadRef r (Lazy.StateT s m) where
-    newRef    r   = lift $ newRef    r
-    readRef   r   = lift $ readRef   r
-    writeRef  r x = lift $ writeRef  r x
-    modifyRef r f = lift $ modifyRef r f
+    newRef     r   = lift $ newRef     r
+    readRef    r   = lift $ readRef    r
+    writeRef   r x = lift $ writeRef   r x
+    modifyRef  r f = lift $ modifyRef  r f
+    modifyRef' r f = lift $ modifyRef' r f
 
 instance MonadRef r m => MonadRef r (Strict.StateT s m) where
-    newRef    r   = lift $ newRef    r
-    readRef   r   = lift $ readRef   r
-    writeRef  r x = lift $ writeRef  r x
-    modifyRef r f = lift $ modifyRef r f
+    newRef     r   = lift $ newRef     r
+    readRef    r   = lift $ readRef    r
+    writeRef   r x = lift $ writeRef   r x
+    modifyRef  r f = lift $ modifyRef  r f
+    modifyRef' r f = lift $ modifyRef' r f
 
 instance (Monoid w, MonadRef r m) => MonadRef r (Lazy.WriterT w m) where
-    newRef    r   = lift $ newRef    r
-    readRef   r   = lift $ readRef   r
-    writeRef  r x = lift $ writeRef  r x
-    modifyRef r f = lift $ modifyRef r f
+    newRef     r   = lift $ newRef     r
+    readRef    r   = lift $ readRef    r
+    writeRef   r x = lift $ writeRef   r x
+    modifyRef  r f = lift $ modifyRef  r f
+    modifyRef' r f = lift $ modifyRef' r f
 
 instance (Monoid w, MonadRef r m) => MonadRef r (Strict.WriterT w m) where
-    newRef    r   = lift $ newRef    r
-    readRef   r   = lift $ readRef   r
-    writeRef  r x = lift $ writeRef  r x
-    modifyRef r f = lift $ modifyRef r f
+    newRef     r   = lift $ newRef     r
+    readRef    r   = lift $ readRef    r
+    writeRef   r x = lift $ writeRef   r x
+    modifyRef  r f = lift $ modifyRef  r f
+    modifyRef' r f = lift $ modifyRef' r f
 
 instance MonadAtomicRef IORef IO where
     atomicModifyRef = atomicModifyIORef
+#if MIN_VERSION_base(4,6,0)
+    atomicModifyRef' = atomicModifyIORef'
+#endif /* MIN_VERSION_base(4,6,0) */
 
 instance MonadAtomicRef TVar STM where
     atomicModifyRef r f = do x <- readRef r
@@ -156,31 +205,41 @@
                              return y
 
 instance MonadAtomicRef r m => MonadAtomicRef r (ContT r' m) where
-    atomicModifyRef r f = lift $ atomicModifyRef r f
+    atomicModifyRef  r f = lift $ atomicModifyRef  r f
+    atomicModifyRef' r f = lift $ atomicModifyRef' r f
 
 instance (Error e, MonadAtomicRef r m) => MonadAtomicRef r (ErrorT e m) where
-    atomicModifyRef r f = lift $ atomicModifyRef r f
+    atomicModifyRef  r f = lift $ atomicModifyRef  r f
+    atomicModifyRef' r f = lift $ atomicModifyRef' r f
 
 instance MonadAtomicRef r m => MonadAtomicRef r (IdentityT m) where
-    atomicModifyRef r f = lift $ atomicModifyRef r f
+    atomicModifyRef  r f = lift $ atomicModifyRef  r f
+    atomicModifyRef' r f = lift $ atomicModifyRef' r f
 
 instance MonadAtomicRef r m => MonadAtomicRef r (ListT m) where
-    atomicModifyRef r f = lift $ atomicModifyRef r f
+    atomicModifyRef  r f = lift $ atomicModifyRef  r f
+    atomicModifyRef' r f = lift $ atomicModifyRef' r f
 
 instance MonadAtomicRef r m => MonadAtomicRef r (MaybeT m) where
-    atomicModifyRef r f = lift $ atomicModifyRef r f
+    atomicModifyRef  r f = lift $ atomicModifyRef  r f
+    atomicModifyRef' r f = lift $ atomicModifyRef' r f
 
 instance MonadAtomicRef r m => MonadAtomicRef r (ReaderT r' m) where
-    atomicModifyRef r f = lift $ atomicModifyRef r f
+    atomicModifyRef  r f = lift $ atomicModifyRef  r f
+    atomicModifyRef' r f = lift $ atomicModifyRef' r f
 
 instance MonadAtomicRef r m => MonadAtomicRef r (Lazy.StateT s m) where
-    atomicModifyRef r f = lift $ atomicModifyRef r f
+    atomicModifyRef  r f = lift $ atomicModifyRef  r f
+    atomicModifyRef' r f = lift $ atomicModifyRef' r f
 
 instance MonadAtomicRef r m => MonadAtomicRef r (Strict.StateT s m) where
-    atomicModifyRef r f = lift $ atomicModifyRef r f
+    atomicModifyRef  r f = lift $ atomicModifyRef  r f
+    atomicModifyRef' r f = lift $ atomicModifyRef' r f
 
 instance (Monoid w, MonadAtomicRef r m) => MonadAtomicRef r (Lazy.WriterT w m) where
-    atomicModifyRef r f = lift $ atomicModifyRef r f
+    atomicModifyRef  r f = lift $ atomicModifyRef  r f
+    atomicModifyRef' r f = lift $ atomicModifyRef' r f
 
 instance (Monoid w, MonadAtomicRef r m) => MonadAtomicRef r (Strict.WriterT w m) where
-    atomicModifyRef r f = lift $ atomicModifyRef r f
+    atomicModifyRef  r f = lift $ atomicModifyRef  r f
+    atomicModifyRef' r f = lift $ atomicModifyRef' r f
diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -25,7 +25,7 @@
 OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 SUCH DAMAGE.
 
-Copyright (c) 2011-2012, Geoffrey Mainland
+Copyright (c) 2011-2014, Geoffrey Mainland
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification,
diff --git a/Setup.hs b/Setup.hs
--- a/Setup.hs
+++ b/Setup.hs
@@ -1,3 +1,2 @@
 import Distribution.Simple
-
 main = defaultMain
diff --git a/ref-fd.cabal b/ref-fd.cabal
--- a/ref-fd.cabal
+++ b/ref-fd.cabal
@@ -1,14 +1,14 @@
 name:           ref-fd
-version:        0.3.0.3
+version:        0.3.0.4
 cabal-version:  >= 1.6
 license:        BSD3
 license-file:   LICENSE
 copyright:      (c) 2006-2011 Harvard University
-		(c) 2011-2012 Geoffrey Mainland
-author:         Geoffrey Mainland <mainland@eecs.harvard.edu>
+		(c) 2011-2014 Geoffrey Mainland
+author:         Geoffrey Mainland <mainland@cs.drexel.edu>
 maintainer:     mainland@eecs.harvard.edu
 stability:      alpha
-homepage:       http://www.eecs.harvard.edu/~mainland/
+homepage:       http://www.cs.drexel.edu/~mainland/
 category:       Control
 synopsis:       A type class for monads with references using functional
                 dependencies.
@@ -25,7 +25,7 @@
   build-depends:
     base         >= 4   && < 5,
     stm          >= 2.1 && < 2.5,
-    transformers >= 0.2 && < 0.4
+    transformers >= 0.2 && < 0.5
 
 source-repository head
   type:     git