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.ArrayT, module Control.Monad.Array.MArray, module Control.Monad.Array.IntMap) where
+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
 
 import Control.Monad.Array.Class
-import Control.Monad.Array.ArrayT
+import Control.Monad.Array.ArrayM
 import Control.Monad.Array.MArray
 import Control.Monad.Array.IntMap
diff --git a/Control/Monad/Array/ArrayM.hs b/Control/Monad/Array/ArrayM.hs
new file mode 100644
--- /dev/null
+++ b/Control/Monad/Array/ArrayM.hs
@@ -0,0 +1,55 @@
+{-# 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
deleted file mode 100644
--- a/Control/Monad/Array/ArrayT.hs
+++ /dev/null
@@ -1,125 +0,0 @@
-{-# LANGUAGE UnboxedTuples, MagicHash, RankNTypes, FlexibleInstances, MultiParamTypeClasses, UndecidableInstances #-}
-
--- | A monad transformer 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.ArrayT (ArrayT, ArrayM, runArrayT, runArrayT_, runArrayM, runArrayM_) where
-
-import GHC.Exts
-import GHC.ST(ST(..))
-
-import Prelude hiding (getContents)
-import Control.Monad.ST.Trans
-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
-
-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 ArrayT e m a = ArrayT {runArrT :: forall s . StateT (MArr s e) (STT s m) a}
-newtype ArrayM e a = ArrayM {runArrM :: forall s . StateT (MArr s e) (ST s) a}
-
--- | Safely performs a monadic computation that statefully modifies a one-dimensional array with the specified default element.
-runArrayT :: Monad m => Int		-- ^ Initial array size.
-			-> e		-- ^ Default array element.
-			-> ArrayT e m a -- ^ Array transformer.
-			-> m a		-- ^ Monadically bound output.
-runArrayT n d m = runSTT $ liftST (newMArr n d) >>= evalStateT (runArrT m)
-
-runArrayT_ :: Monad m => Int -> ArrayT e m a -> m a
-runArrayT_ n = runArrayT n emptyElement
-
-runArrayM :: Int -> e -> ArrayM e a -> a
-runArrayM n d m = runST $ newMArr n d >>= evalStateT (runArrM m)
-
-runArrayM_ :: Int -> ArrayM e a -> a
-runArrayM_ n = runArrayM n emptyElement
-
-emptyElement = error "Undefined array element"
-
-instance Monad m => Monad (ArrayT e m) where
-	return x = ArrayT (return x)
-	m >>= k = ArrayT (runArrT m >>= runArrT . k)
-	fail s = ArrayT (lift (fail s))
-
-instance Monad (ArrayM e) where
-	return x = ArrayM (lift (return x))
-	m >>= k = ArrayM (runArrM m >>= runArrM . k)
-	fail s = ArrayM (fail s)
-	m >> k = ArrayM (runArrM m >> runArrM k)
-
-instance MonadFix (ArrayM e) where
-	mfix f = ArrayM (mfix (runArrM . f))
-
-instance MonadTrans (ArrayT e) where
-	lift m = ArrayT (lift (lift m))
-
-instance Monad m => MonadArray e (ArrayT 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'
-
-instance MonadArray e (ArrayM 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'
-
-instance MonadState s m => MonadState s (ArrayT e m) where
-	get = lift get
-	put = lift . put
-
-instance MonadReader r m => MonadReader r (ArrayT e m) where
-	ask = lift ask
-	local f = (lift . local f . return =<<)
-
-instance MonadWriter w m => MonadWriter w (ArrayT e m) where
-	tell = lift . tell
-	listen = (lift . listen . return =<<)
-	pass = (lift . pass . return =<<)
-
-instance MonadPlus m => MonadPlus (ArrayT e m) where
-	mzero = lift mzero
-	ArrayT m1 `mplus` ArrayT m2 = ArrayT (m1 `mplus` m2)
-
-instance MonadFix m => MonadFix (ArrayT e m) where
-	mfix f = ArrayT (mfix (runArrT . f))
-
-instance MonadIO m => MonadIO (ArrayT e m) where
-	liftIO = lift . liftIO
-
-instance MonadST s m => MonadST s (ArrayT e m) where
-	liftST = lift . liftST
-
-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/ST/Trans.hs b/Control/Monad/ST/Trans.hs
deleted file mode 100644
--- a/Control/Monad/ST/Trans.hs
+++ /dev/null
@@ -1,55 +0,0 @@
-{-# LANGUAGE RecursiveDo, UndecidableInstances, FlexibleInstances, FunctionalDependencies, MultiParamTypeClasses, RankNTypes, MagicHash #-}
-module Control.Monad.ST.Trans (STT, runSTT, module Control.Monad.ST.Class) where
-
-import GHC.ST hiding (liftST)
-import qualified GHC.ST as ST
-import Control.Monad.ST.Class
-import GHC.Prim
-import Control.Monad
-import Control.Monad.Trans
-import Control.Monad.Fix
-import Control.Monad.State.Class
-import Control.Monad.Reader.Class
-
--- | 'ST' monad transformer.
-newtype STT s m a = STT {execSTT :: State# s -> m (STret s a)}
-
-instance Monad m => Monad (STT s m) where
-	return x = STT (\ s -> return (STret s x))
-	m >>= k = STT (\ s -> do	STret s' x <- execSTT m s
-					execSTT (k x) s')
-	fail err = STT (\ s -> fail err)
-
-instance MonadTrans (STT s) where
-	lift m = STT (\ s -> liftM (STret s) m)
-
-instance Monad m => MonadST s (STT s m) where
-	liftST m = STT (\ s -> return (ST.liftST m s))
-
-instance MonadState s m => MonadState s (STT s' m) where
-	get = lift get
-	put = lift . put
-
-instance MonadReader r m => MonadReader r (STT s m) where
-	ask = lift ask
-	local f = (lift . local f . return =<<)
-
-instance MonadPlus m => MonadPlus (STT s m) where
-	mzero = lift mzero
-	m `mplus` k = STT $ \ s -> execSTT m s `mplus` execSTT k s
-
-instance MonadFix m => MonadFix (STT s m) where
-	mfix f = STT $ \ s -> mdo	STret s' a <- execSTT (f a) s
-					return (STret s' a)
-
-instance MonadIO m => MonadIO (STT s m) where
-	liftIO = lift . liftIO
-
-{-# NOINLINE runSTTRep #-}
-runSTTRep :: Monad m => (forall s . State# s -> m (STret s a)) -> m a
-runSTTRep f = do	STret s' x <- f realWorld#
-			return x
-
--- | Safely executes the state-transformer part of a monadic computation in the 'STT' monad transformer.
-runSTT :: Monad m => (forall s . STT s m a) -> m a
-runSTT m = runSTTRep (execSTT m)
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
+version:	1.0.1
 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.ArrayT, Control.Monad.Array.IntMap, Control.Monad.Array.MArray, Control.Monad.Array.Class, Control.Monad.ST.Class, Control.Monad.ST.Trans, Control.Monad.Trans.Operations
+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
 ghc-options: