diff --git a/Control/Monad/Array.hs b/Control/Monad/Array.hs
--- a/Control/Monad/Array.hs
+++ b/Control/Monad/Array.hs
@@ -1,8 +1,8 @@
 {-# LANGUAGE StandaloneDeriving, UnboxedTuples, MagicHash, RankNTypes, FlexibleInstances, MultiParamTypeClasses, UndecidableInstances, GeneralizedNewtypeDeriving #-}
 
-module Control.Monad.Array (module Control.Monad.Array.Class, module Control.Monad.Array.ArrayM, module Control.Monad.Array.MArray, module Control.Monad.Array.IntMap) where
+module Control.Monad.Array (module Control.Monad.Array.Class, module Control.Monad.Array.ArrayT, module Control.Monad.Array.MArray, module Control.Monad.Array.IntMap) where
 
 import Control.Monad.Array.Class
-import Control.Monad.Array.ArrayM
+import Control.Monad.Array.ArrayT
 import Control.Monad.Array.MArray
 import Control.Monad.Array.IntMap
diff --git a/Control/Monad/Array/ArrayM.hs b/Control/Monad/Array/ArrayM.hs
deleted file mode 100644
--- a/Control/Monad/Array/ArrayM.hs
+++ /dev/null
@@ -1,55 +0,0 @@
-{-# LANGUAGE GeneralizedNewtypeDeriving, UnboxedTuples, MagicHash, RankNTypes, FlexibleInstances, MultiParamTypeClasses, UndecidableInstances #-}
-
--- | A monad that cleanly generalizes out implementation details of array manipulation in an array transformer.  In general, this is likely to be the most efficient array transformer implementation made available in this library, but if improperly used, elements of this implementation may lead to segfaults.
-module Control.Monad.Array.ArrayM (ArrayM, runArrayM, runArrayM_) where
-
-import GHC.Exts
-import GHC.ST(ST(..))
-
-import Prelude hiding (getContents)
-import Control.Monad.ST
-import Control.Monad.Fix
-import Control.Monad.Array.Class
-import Control.Monad
-import Control.Monad.Trans
-import Control.Monad.RWS.Class
-import Control.Monad.State
-import Control.Monad.ST.Class
-
-data MArr s e = MArr {-# UNPACK #-} !Int e (MutableArray# s e)
-
--- | Monad transformer that safely grants the underlying monad access to a mutable array.
-newtype ArrayM s e a = ArrayM {runArrM :: StateT (MArr s e) (ST s) a} deriving (MonadST s, Monad, MonadFix)
-
-runArrayM :: Int -> e -> (forall s . ArrayM s e a) -> a
-runArrayM n d m = runST $ newMArr n d >>= evalStateT (runArrM m)
-
-runArrayM_ :: Int -> (forall s . ArrayM s e a) -> a
-runArrayM_ n = runArrayM n emptyElement
-
-emptyElement = error "Undefined array element"
-
-instance MonadArray e (ArrayM s e) where
-	{-# INLINE unsafeReadAt #-}
-	{-# INLINE unsafeWriteAt #-}
-	{-# INLINE getSize #-}
-	{-# INLINE resize #-}
-	unsafeReadAt i = ArrayM $ 	do	arr <- get
-						lift $ readMArr arr i
-	unsafeWriteAt i x = ArrayM $ 	do	arr <- get
-						lift $ writeMArr arr i x
-	getSize = ArrayM $ 	do	MArr n _ _ <- get
-					return n
-	resize n' = ArrayM $ 	do	a@(MArr n d _) <- get
-					a' <- lift $ newMArr n' d
-					lift $ mapM_ (\ i -> readMArr a i >>= writeMArr a' i) [0..n-1]
-					put a'
-
-newMArr :: Int -> e -> ST s (MArr s e)
-newMArr (I# n) d = ST $ \ s -> case newArray# n d s of (# s', arr' #) -> (# s', MArr (I# n) d arr' #)
-
-readMArr :: MArr s e -> Int -> ST s e
-readMArr (MArr n _ arr) i@(I# i#) = ST $ readArray# arr i#
-
-writeMArr :: MArr s e -> Int -> e -> ST s ()
-writeMArr (MArr n _ arr) i@(I# i#) x = ST $ \ s -> (# writeArray# arr i# x s, () #)
diff --git a/Control/Monad/Array/ArrayT.hs b/Control/Monad/Array/ArrayT.hs
new file mode 100644
--- /dev/null
+++ b/Control/Monad/Array/ArrayT.hs
@@ -0,0 +1,73 @@
+{-# LANGUAGE GeneralizedNewtypeDeriving, UnboxedTuples, MagicHash, OverlappingInstances, RankNTypes, FlexibleInstances, MultiParamTypeClasses, UndecidableInstances #-}
+
+-- | A monad that cleanly generalizes out implementation details of array manipulation in a monad.  In general, this is likely to be the most efficient array transformer implementation made available in this library, but if improperly used, elements of this implementation may lead to segfaults.
+module Control.Monad.Array.ArrayT (ArrayM, ArrayT, runArrayM, runArrayMIO, runArrayM_, runArrayMIO_, runArrayT, runArrayT_) where
+
+import GHC.Exts
+import GHC.ST(ST(..))
+
+import Prelude hiding (getContents)
+import Control.Monad.ST
+import Control.Monad.Fix
+import Control.Monad.Array.Class
+import Control.Monad
+import Control.Monad.Trans
+import Control.Monad.RWS.Class
+import Control.Monad.State
+import Control.Monad.ST.Class
+
+data MArr s e = MArr {-# UNPACK #-} !Int e (MutableArray# s e)
+
+-- | Monad controlling safe access to an underlying array.
+type ArrayM s e = ArrayT s e (ST s)
+-- | Monad transformer that safely grants the underlying monad access to a mutable array.
+newtype ArrayT s e m a = ArrayT {runArrT :: StateT (MArr s e) m a} deriving (Monad, MonadTrans, MonadFix, MonadST s, MonadReader r, MonadWriter w)
+
+instance MonadState t m => MonadState t (ArrayT s e m) where
+	get = lift get
+	put = lift . put
+
+runArrayM :: Int -> e -> (forall s . ArrayM s e a) -> a
+runArrayM n d m = runST $ runArrayT n d m
+
+runArrayMIO :: Int -> e -> ArrayM RealWorld e a -> IO a
+runArrayMIO n d m = stToIO $ runArrayT n d m
+
+runArrayM_ :: Int -> (forall s . ArrayM s e a) -> a
+runArrayM_ n = runArrayM n emptyElement
+
+runArrayMIO_ :: Int -> ArrayM RealWorld e a -> IO a
+runArrayMIO_ n = runArrayMIO n emptyElement
+
+runArrayT :: (MonadST s m, Monad m) => Int -> e -> ArrayT s e m a -> m a
+runArrayT n d m = liftST (newMArr n d) >>= evalStateT (runArrT m)
+
+runArrayT_ :: (MonadST s m, Monad m) => Int -> ArrayT s e m a -> m a
+runArrayT_ n = runArrayT n emptyElement
+
+emptyElement = error "Undefined array element"
+
+instance (MonadST s m, Monad m) => MonadArray e (ArrayT s e m) where
+	{-# INLINE unsafeReadAt #-}
+	{-# INLINE unsafeWriteAt #-}
+	{-# INLINE getSize #-}
+	{-# INLINE resize #-}
+	unsafeReadAt i = ArrayT $ 	do	arr <- get
+						liftST $ readMArr arr i
+	unsafeWriteAt i x = ArrayT $ 	do	arr <- get
+						liftST $ writeMArr arr i x
+	getSize = ArrayT $ 	do	MArr n _ _ <- get
+					return n
+	resize n' = ArrayT $ 	do	a@(MArr n d _) <- get
+					a' <- liftST $ newMArr n' d
+					liftST $ mapM_ (\ i -> readMArr a i >>= writeMArr a' i) [0..n-1]
+					put a'
+
+newMArr :: Int -> e -> ST s (MArr s e)
+newMArr (I# n) d = ST $ \ s -> case newArray# n d s of (# s', arr' #) -> (# s', MArr (I# n) d arr' #)
+
+readMArr :: MArr s e -> Int -> ST s e
+readMArr (MArr n _ arr) i@(I# i#) = ST $ readArray# arr i#
+
+writeMArr :: MArr s e -> Int -> e -> ST s ()
+writeMArr (MArr n _ arr) i@(I# i#) x = ST $ \ s -> (# writeArray# arr i# x s, () #)
diff --git a/Control/Monad/Array/IntMap.hs b/Control/Monad/Array/IntMap.hs
--- a/Control/Monad/Array/IntMap.hs
+++ b/Control/Monad/Array/IntMap.hs
@@ -49,14 +49,14 @@
 	lift = IntMapT . lift . lift
 
 instance Monad m => MonadArray e (IntMapT e m) where
-	unsafeReadAt i = IntMapT $ gets (IM.lookup i) >>= maybe ask return
-	unsafeWriteAt i x = IntMapT $ modify (IM.insert i x)
+	readAt i = IntMapT $ gets (IM.lookup i) >>= maybe ask return
+	writeAt i x = IntMapT $ modify (IM.insert i x)
 	getSize = IntMapT $ gets IM.size
 	ensureSize _ = return ()
 
 instance MonadArray e (IntMapM e) where
-	unsafeReadAt i = IntMapM $ gets (IM.lookup i) >>= maybe ask return
-	unsafeWriteAt i x = IntMapM $ modify (IM.insert i x)
+	readAt i = IntMapM $ gets (IM.lookup i) >>= maybe ask return
+	writeAt i x = IntMapM $ modify (IM.insert i x)
 	getSize = IntMapM $ gets IM.size
 	ensureSize _ = return ()
 
diff --git a/Control/Monad/Array/MArray.hs b/Control/Monad/Array/MArray.hs
--- a/Control/Monad/Array/MArray.hs
+++ b/Control/Monad/Array/MArray.hs
@@ -47,6 +47,7 @@
 			def <- MArrayM ask
 			arr' <- liftMArray $ newListArray (0, n-1) (prevConts ++ replicate (n - prevSize) def)
 			MArrayM $ put arr'
+	getContents = MArrayM $ get >>= lift . lift . getElems
 
 -- | Lifts a computation in the underlying monad to an 'MArrayM' computation on an array in the same monad.
 liftMArray :: (Monad m, MArray a e m) => m x -> MArrayM a e m x
diff --git a/Control/Monad/ST/Class.hs b/Control/Monad/ST/Class.hs
--- a/Control/Monad/ST/Class.hs
+++ b/Control/Monad/ST/Class.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE FunctionalDependencies, MultiParamTypeClasses, FlexibleInstances, UndecidableInstances #-}
+{-# LANGUAGE OverlappingInstances, FunctionalDependencies, MultiParamTypeClasses, FlexibleInstances, UndecidableInstances #-}
 module Control.Monad.ST.Class where
 
 import GHC.IOBase(ioToST)
diff --git a/stateful-mtl.cabal b/stateful-mtl.cabal
--- a/stateful-mtl.cabal
+++ b/stateful-mtl.cabal
@@ -1,5 +1,5 @@
 name:		stateful-mtl
-version:	1.0.1
+version:	1.0.2
 synopsis:	Stateful monad transformers with pure evaluation semantics.
 description:	Stateful monad transformers with pure evaluation semantics, useful for monadically pulling out implementation details of array manipulation and operations in the ST monad.  This package remains in a state of flux, so please notify the author about features you like or dislike.
 tested-with:	GHC
@@ -10,5 +10,5 @@
 maintainer:	wasserman.louis@gmail.com
 build-Depends:	base, array, ghc-prim, mtl, containers, MaybeT
 build-type:	Simple
-Exposed-modules:Control.Monad.Array, Control.Monad.Array.ArrayM, Control.Monad.Array.IntMap, Control.Monad.Array.MArray, Control.Monad.Array.Class, Control.Monad.ST.Class, Control.Monad.Trans.Operations
+Exposed-modules:Control.Monad.Array, Control.Monad.Array.ArrayT, Control.Monad.Array.IntMap, Control.Monad.Array.MArray, Control.Monad.Array.Class, Control.Monad.ST.Class, Control.Monad.Trans.Operations
 ghc-options: