diff --git a/Control/Monad/Array.hs b/Control/Monad/Array.hs
deleted file mode 100644
--- a/Control/Monad/Array.hs
+++ /dev/null
@@ -1,9 +0,0 @@
-{-# 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, module Control.Monad.Array.Unboxed) where
-
-import Control.Monad.Array.Class
-import Control.Monad.Array.ArrayT
-import Control.Monad.Array.MArray
-import Control.Monad.Array.IntMap
-import Control.Monad.Array.Unboxed
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,77 +0,0 @@
-{-# LANGUAGE TypeFamilies, GeneralizedNewtypeDeriving, UnboxedTuples, MagicHash, Rank2Types, 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, runArrayM_, runArrayT, runArrayT_) where
-
-import Control.Monad.Array.Class
-import Control.Monad.ST.Class
-
-import GHC.Exts
-import GHC.ST(ST(..))
-
-import Control.Monad.State.Strict
-import Control.Monad.Reader.Class
-import Control.Monad.Writer.Class
-import Control.Monad.Fix
-import Control.Monad.Trans
-
-import Control.Monad
-import Control.Monad.ST
-
-data MArr s e = MArr {-# UNPACK #-} !Int e (MutableArray# s e)
-
--- | Monad controlling safe access to an underlying array.
-type ArrayM s e = ArrayT e (ST s)
--- | Monad transformer that safely grants the underlying monad access to a mutable array.
-newtype ArrayT e m a = ArrayT {runArrT :: StateT (MArr (StateThread m) e) m a} deriving (Monad, MonadFix, MonadPlus, MonadReader r, MonadWriter w)
-
-instance MonadTrans (ArrayT e) where
-	lift = ArrayT . lift
-
-instance MonadState s m => MonadState s (ArrayT 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
-
-runArrayM_ :: Int -> (forall s . ArrayM s e a) -> a
-runArrayM_ n = runArrayM n emptyElement
-
-runArrayT :: (MonadST m, Monad m) => Int -> e -> ArrayT e m a -> m a
-runArrayT n d m = liftST (newMArr n d) >>= evalStateT (runArrT m)
-
-runArrayT_ :: (MonadST m, Monad m) => Int -> ArrayT e m a -> m a
-runArrayT_ n = runArrayT n emptyElement
-
-emptyElement :: e
-emptyElement = error "Undefined array element"
-
-instance (MonadST m, Monad m) => MonadArray (ArrayT e m) where
-	{-# SPECIALIZE instance MonadArray (ArrayM s e) #-}
-	{-# INLINE unsafeReadAt #-}
-	{-# INLINE unsafeWriteAt #-}
-	{-# INLINE askSize #-}
-	{-# INLINE resize #-}
-
-	type ArrayElem (ArrayT e m) = e
-
-	unsafeReadAt i = ArrayT $ 	do	arr <- get
-						liftST $ readMArr arr i
-	unsafeWriteAt i x = ArrayT $ 	do	arr <- get
-						liftST $ writeMArr arr i x
-	askSize = 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 _ _ arr) (I# i#) = ST $ readArray# arr i#
-
-writeMArr :: MArr s e -> Int -> e -> ST s ()
-writeMArr (MArr _ _ arr) (I# i#) x = ST $ \ s -> (# writeArray# arr i# x s, () #)
diff --git a/Control/Monad/Array/Class.hs b/Control/Monad/Array/Class.hs
deleted file mode 100644
--- a/Control/Monad/Array/Class.hs
+++ /dev/null
@@ -1,134 +0,0 @@
-{-# LANGUAGE UndecidableInstances, MultiParamTypeClasses, TypeFamilies, FlexibleInstances#-}
-module Control.Monad.Array.Class where
-
-import qualified Control.Monad.State.Lazy as LazyS
-import qualified Control.Monad.State.Strict as StrictS
-import Control.Monad.Reader
-import Control.Monad.List
-import qualified Control.Monad.Writer.Lazy as LazyW
-import qualified Control.Monad.Writer.Strict as StrictW
-import Control.Monad.Maybe
-import Data.Monoid
-import Control.Monad
-
--- | Type class abstraction for a monad with access to an underlying mutable array indexed by 'Int's.  Minimal implementation: 'readAt' or 'unsafeReadAt', 'writeAt' or 'unsafeWriteAt', 'askSize', 'resize' or 'ensureSize'.
-class Monad m => MonadArray m where
-	type ArrayElem m
-	{-# INLINE readAt #-}
-	{-# INLINE unsafeReadAt #-}
-	{-# INLINE writeAt #-}
-	{-# INLINE unsafeWriteAt #-}
-	{-# INLINE replaceAt #-}
-	{-# INLINE askElems #-}
-	{-# INLINE askSize #-}
-	{-# INLINE resize #-}
-	{-# INLINE ensureSize #-}
-	readAt :: Int -> m (ArrayElem m)
-	unsafeReadAt :: Int -> m (ArrayElem m)
-	writeAt :: Int -> ArrayElem m -> m ()
-	unsafeWriteAt :: Int -> ArrayElem m -> m ()
-	replaceAt :: Int -> ArrayElem m -> m (ArrayElem m)
-	askElems :: m [ArrayElem m]
-	askAssocs :: m [(Int, ArrayElem m)]
-	askSize :: m Int
-	resize :: Int -> m ()
-	ensureSize :: Int -> m ()
-	readAt i = 	do	n <- askSize
-				if i >= 0 && i < n then unsafeReadAt i else fail "Index out of bounds"
-	unsafeReadAt = 	readAt
-	writeAt i x = 	do	n <- askSize
-				if i >= 0 && i < n then unsafeWriteAt i x else fail "Index out of bounds"
-	unsafeWriteAt = writeAt
-	askAssocs = do	n <- askSize
-			mapM (\ i -> liftM ((,) i) (unsafeReadAt i)) [0..n-1]
-	askElems = liftM (map snd) askAssocs
-	ensureSize n =	do	m <- askSize
-				when (m < n) (resize n)
-	resize = ensureSize
-	replaceAt i x = do	y <- readAt i
-				writeAt i x
-				return y
-
-instance MonadArray m => MonadArray (LazyS.StateT s m) where
-	type ArrayElem (LazyS.StateT s m) = ArrayElem m
-	readAt = lift . readAt
-	unsafeReadAt = lift . unsafeReadAt
-	writeAt i x = lift (writeAt i x)
-	unsafeWriteAt i x = lift (unsafeWriteAt i x)
-	replaceAt i x = lift (replaceAt i x)
-	askElems = lift askElems
-	askSize = lift askSize
-	resize = lift . resize
-	ensureSize = lift . ensureSize
-
-instance MonadArray m => MonadArray (StrictS.StateT s m) where
-	type ArrayElem (StrictS.StateT s m) = ArrayElem m
-	readAt = lift . readAt
-	unsafeReadAt = lift . unsafeReadAt
-	writeAt i x = lift (writeAt i x)
-	unsafeWriteAt i x = lift (unsafeWriteAt i x)
-	replaceAt i x = lift (replaceAt i x)
-	askElems = lift askElems
-	askSize = lift askSize
-	resize = lift . resize
-	ensureSize = lift . ensureSize
-
-instance MonadArray m => MonadArray (ReaderT r m) where
-	type ArrayElem (ReaderT r m) = ArrayElem m
-	readAt = lift . readAt
-	unsafeReadAt = lift . unsafeReadAt
-	writeAt i x = lift (writeAt i x)
-	unsafeWriteAt i x = lift (unsafeWriteAt i x)
-	replaceAt i x = lift (replaceAt i x)
-	askElems = lift askElems
-	askSize = lift askSize
-	resize = lift . resize
-	ensureSize = lift . ensureSize
-
-instance (Monoid w, MonadArray m) => MonadArray (StrictW.WriterT w m) where
-	type ArrayElem (StrictW.WriterT w m) = ArrayElem m
-	readAt = lift . readAt
-	unsafeReadAt = lift . unsafeReadAt
-	writeAt i x = lift (writeAt i x)
-	unsafeWriteAt i x = lift (unsafeWriteAt i x)
-	replaceAt i x = lift (replaceAt i x)
-	askElems = lift askElems
-	askSize = lift askSize
-	resize = lift . resize
-	ensureSize = lift . ensureSize
-
-instance (Monoid w, MonadArray m) => MonadArray (LazyW.WriterT w m) where
-	type ArrayElem (LazyW.WriterT w m) = ArrayElem m
-	readAt = lift . readAt
-	unsafeReadAt = lift . unsafeReadAt
-	writeAt i x = lift (writeAt i x)
-	unsafeWriteAt i x = lift (unsafeWriteAt i x)
-	replaceAt i x = lift (replaceAt i x)
-	askElems = lift askElems
-	askSize = lift askSize
-	resize = lift . resize
-	ensureSize = lift . ensureSize
-
-instance MonadArray m => MonadArray (MaybeT m) where
-	type ArrayElem (MaybeT m) = ArrayElem m
-	readAt = lift . readAt
-	unsafeReadAt = lift . unsafeReadAt
-	writeAt i x = lift (writeAt i x)
-	unsafeWriteAt i x = lift (unsafeWriteAt i x)
-	replaceAt i x = lift (replaceAt i x)
-	askElems = lift askElems
-	askSize = lift askSize
-	resize = lift . resize
-	ensureSize = lift . ensureSize
-
-instance MonadArray m => MonadArray (ListT m) where
-	type ArrayElem (ListT m) = ArrayElem m
-	readAt = lift . readAt
-	unsafeReadAt = lift . unsafeReadAt
-	writeAt i x = lift (writeAt i x)
-	unsafeWriteAt i x = lift (unsafeWriteAt i x)
-	replaceAt i x = lift (replaceAt i x)
-	askElems = lift askElems
-	askSize = lift askSize
-	resize = lift . resize
-	ensureSize = lift . ensureSize
diff --git a/Control/Monad/Array/IntMap.hs b/Control/Monad/Array/IntMap.hs
deleted file mode 100644
--- a/Control/Monad/Array/IntMap.hs
+++ /dev/null
@@ -1,82 +0,0 @@
-{-# LANGUAGE GeneralizedNewtypeDeriving, TypeFamilies, UndecidableInstances, FlexibleInstances, MultiParamTypeClasses #-}
-
--- | A module implementing the array abstraction on a purely functional IntMap.  When attempting to debug a complex array-using algorithm, it may sometimes be useful to use a less segfault-prone implementation.  In addition, the execXXX commands allow the final state of the 'IntMap' to be returned.
-module Control.Monad.Array.IntMap (IntMapT, evalIntMapT, execIntMapT, execIntMapT_, evalIntMapT_, IntMapM, execIntMapM, evalIntMapM,  execIntMapM_, evalIntMapM_) where
-
-import Control.Monad.Array.Class
-
-import Control.Monad.State
-import Control.Monad.Reader
-import Control.Monad.Writer.Class
-import Control.Monad.Trans
-
-import qualified Data.IntMap as IM
-import Data.IntMap(IntMap)
-
-import Control.Monad
-
--- | An array transformer with an 'IntMap' on the back end.  Provides decent performance while retaining a purely functional back end.  /Note:/ resizing operations have no effect, and the 'askSize' operation returns the number of associations in the 'IntMap'.
-newtype IntMapT e m a = IntMapT {runIMapT :: ReaderT e (StateT (IntMap e) m) a} deriving (Monad, MonadFix, MonadPlus, MonadIO, MonadWriter w)
-
--- | Basic monad version of 'IntMapT'.
-newtype IntMapM e a = IntMapM {runIMapM :: ReaderT e (State (IntMap e)) a} deriving (Monad, MonadFix)
-
--- | Evaluates an 'IntMapT' computation with the specified default element.
-evalIntMapT :: Monad m => e -> IntMapT e m a -> m a
-evalIntMapT d m = evalStateT (runReaderT (runIMapT m) d) IM.empty
-
--- | Evaluates an 'IntMapT' computation with the specified default element, returning the final 'IntMap'.
-execIntMapT :: Monad m => e -> IntMapT e m a -> m (IntMap e)
-execIntMapT d m = execStateT (runReaderT (runIMapT m) d) IM.empty
-
-evalIntMapM :: e -> IntMapM e a -> a
-evalIntMapM d m = evalState (runReaderT (runIMapM m) d) IM.empty
-
-execIntMapM :: e -> IntMapM e a -> IntMap e
-execIntMapM d m = execState (runReaderT (runIMapM m) d) IM.empty
-
--- | Evaluates an 'IntMapT' computation with no default element specified.
-evalIntMapT_ :: Monad m => IntMapT e m a -> m a
-evalIntMapT_ = evalIntMapT emptyElement
-
--- | Evaluates an 'IntMapT' computation with no default element specified, returning the final 'IntMap'.
-execIntMapT_ :: Monad m => IntMapT e m a -> m (IntMap e)
-execIntMapT_ = execIntMapT emptyElement
-
-evalIntMapM_ :: IntMapM e a -> a
-evalIntMapM_ = evalIntMapM emptyElement
-
-execIntMapM_ :: IntMapM e a -> IntMap e
-execIntMapM_ = execIntMapM emptyElement
-
-emptyElement :: e
-emptyElement = error "Undefined array element"
-
-instance MonadTrans (IntMapT e) where
-	lift = IntMapT . lift . lift
-
-instance Monad m => MonadArray (IntMapT e m) where
-	type ArrayElem (IntMapT e m) = e
-	readAt i = IntMapT $ gets (IM.lookup i) >>= maybe ask return
-	writeAt i x = IntMapT $ modify (IM.insert i x)
-	askSize = IntMapT $ gets IM.size
-	ensureSize _ = return ()
-	askElems = IntMapT $ gets IM.elems
-	askAssocs = IntMapT $ gets IM.toList
-
-instance MonadArray (IntMapM e) where
-	type ArrayElem (IntMapM e) = e
-	readAt i = IntMapM $ gets (IM.lookup i) >>= maybe ask return
-	writeAt i x = IntMapM $ modify (IM.insert i x)
-	askSize = IntMapM $ gets IM.size
-	ensureSize _ = return ()
-	askElems = IntMapM $ gets IM.elems
-	askAssocs = IntMapM $ gets IM.toList
-
-instance MonadState s m => MonadState s (IntMapT e m) where
-	get = lift get
-	put = lift . put
-
-instance MonadReader r m => MonadReader r (IntMapT e m) where
-	ask = lift ask
-	local f = (lift . local f . return =<<)
diff --git a/Control/Monad/Array/MArray.hs b/Control/Monad/Array/MArray.hs
deleted file mode 100644
--- a/Control/Monad/Array/MArray.hs
+++ /dev/null
@@ -1,60 +0,0 @@
-{-# LANGUAGE FlexibleInstances, TypeFamilies, GeneralizedNewtypeDeriving #-}
-
--- | Provides a 'MonadArray' implementation for any 'MArray'.  Examples of when this would be useful include unboxed arrays and array implementations for specialized monads like STM.
-module Control.Monad.Array.MArray (MArrayM, liftMArray, evalMArrayM, execMArrayM, evalMArrayM_, execMArrayM_) where
-
-import Control.Monad.Array.Class
-import Control.Monad.ST.Class
-
-import GHC.Arr
-
-import Control.Monad.State
-import Control.Monad.Reader
-import Control.Monad.Trans
-
-import Data.Array.Base
-import Control.Monad
-
--- | Provides a monadic wrapper around any 'MArray' implementation.
-newtype MArrayM a e m x = MArrayM {runMArrayM :: ReaderT e (StateT (a Int e) m) x} deriving (Monad, MonadFix, MonadPlus, MonadIO, MonadST)
-
--- | Executes an 'MArrayM' computation with the specified initial size and default element.
-evalMArrayM :: (Monad m, MArray a e m) => Int -> e -> MArrayM a e m x -> m x
-evalMArrayM n d m = newArray (0, n-1) d >>= evalStateT (runReaderT (runMArrayM m) d)
-
--- | Executes an 'MArrayM' computation with the specified initial size and default element, returning the final array.
-execMArrayM :: (Monad m, MArray a e m) => Int -> e -> MArrayM a e m x -> m (a Int e)
-execMArrayM n d m = newArray (0, n-1) d >>= execStateT (runReaderT (runMArrayM m) d)
-
--- | Executes an 'MArrayM' computation with the specified initial size and no default element.
-evalMArrayM_ :: (Monad m, MArray a e m) => Int -> MArrayM a e m x -> m x
-evalMArrayM_ n = evalMArrayM n emptyElement
-
--- | Executes an 'MArrayM' computation with the specified initial size and no default element, returning the final array.
-execMArrayM_ :: (Monad m, MArray a e m) => Int -> MArrayM a e m x -> m (a Int e)
-execMArrayM_ n = execMArrayM n emptyElement
-
-emptyElement :: e
-emptyElement = error "Undefined array element"
-
-instance (Monad m, MArray a e m) => MonadArray (MArrayM a e m) where
-	type ArrayElem (MArrayM a e m) = e
-	unsafeWriteAt i x = MArrayM $ do	arr <- get
-						lift2 $ unsafeWrite arr i x
-	unsafeReadAt i = MArrayM $ do	arr <- get
-					lift2 $ unsafeRead arr i
-	askSize = MArrayM (get >>= lift2 . liftM rangeSize . getBounds)
-	resize n = do	prevSize <- askSize
-			prevConts <- mapM unsafeReadAt [0..prevSize-1]
-			def <- MArrayM ask
-			arr' <- liftMArray $ newListArray (0, n-1) (prevConts ++ replicate (n - prevSize) def)
-			MArrayM $ put arr'
-	askElems = MArrayM $ get >>= lift2 . getElems
-	askAssocs = MArrayM $ get >>= lift2 . getAssocs
-
--- | 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
-liftMArray = MArrayM . lift2
-
-lift2 :: (MonadTrans t1, MonadTrans t2, Monad m, Monad (t2 m)) => m a -> t1 (t2 m) a
-lift2 = lift . lift
diff --git a/Control/Monad/Array/Unboxed.hs b/Control/Monad/Array/Unboxed.hs
deleted file mode 100644
--- a/Control/Monad/Array/Unboxed.hs
+++ /dev/null
@@ -1,51 +0,0 @@
-{-# LANGUAGE Rank2Types,  UndecidableInstances, MultiParamTypeClasses, TypeFamilies, FlexibleInstances, GeneralizedNewtypeDeriving #-}
-
-module Control.Monad.Array.Unboxed where
-
-import Control.Monad.ST.Class
-import Control.Monad.Array.Class
-
-import Data.Array.Vector
-
-import Control.Monad.ST
-import Control.Monad.State.Strict
-import Control.Monad.Reader
-import Control.Monad.Writer.Class
-
-type UArrayM s e = UArrayT e (ST s)
-newtype UArrayT e m a = UArrayT {runUArrayT :: StateT (MUArr e (StateThread m)) m a} deriving (Monad, MonadReader r, MonadWriter w, MonadIO, MonadFix)
-
-evalUArrayT :: (UA e, MonadST m, Monad m) => Int -> UArrayT e m a -> m a
-evalUArrayT n m = liftST (newMU n) >>= evalStateT (runUArrayT m)
-
-defaultUA :: UA e => e
-defaultUA = runST $ do	arr <- newMU 1
-			readMU arr 0
-
-evalUArrayM :: UA e => Int -> (forall s . UArrayM s e a) -> a
-evalUArrayM n m = runST (evalUArrayT n m)
-
-instance MonadTrans (UArrayT e) where
-	lift m = UArrayT (lift m)
-
-instance MonadState s m => MonadState s (UArrayT e m) where
-	get = lift get
-	put = lift . put
-
--- instance MonadReader r m => MonadReader r (UArrayT e m) where
--- 	ask = lift ask
--- 	local f (UArrayT m) = UArrayT $ ReaderT $ \ r -> local f (runReaderT m r)
-
-instance (UA e, MonadST m, Monad m) => MonadArray (UArrayT e m) where
-	{-# SPECIALIZE instance UA e => MonadArray (UArrayM s e) #-}
-	type ArrayElem (UArrayT e m) = e
-	askSize = UArrayT $ gets lengthMU
-	readAt i = UArrayT $ gets (`readMU` i) >>= liftST
-	writeAt i x = UArrayT $ gets (\ arr -> writeMU arr i x) >>= liftST
-	resize n' = UArrayT $ do	n <- gets lengthMU
-					ice <- gets unsafeFreezeAllMU
-					put =<< liftST (do
-						noob <- newMU n'
-						copyMU noob 0 =<< ice
-						return noob)
-	askElems = UArrayT $ liftST =<< gets (liftM fromU . unsafeFreezeAllMU)
diff --git a/stateful-mtl.cabal b/stateful-mtl.cabal
--- a/stateful-mtl.cabal
+++ b/stateful-mtl.cabal
@@ -1,14 +1,22 @@
 name:		stateful-mtl
-version:	1.0.6
-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.  Includes typeclasses suitable for guaranteeing single-threaded monad behavior, avoiding previously encountered problems with ST monad transformers.  This package remains in a state of flux, so please notify the author about features you like or dislike.
+version:	1.0.7
+synopsis:	Typeclass instances for monad transformer stacks with an ST thread at the bottom.
+description:	A MonadST type class, instances, and some helpful monad functions.
 tested-with:	GHC
 category:	Monads
 license:	BSD3
 license-file:	LICENSE
 author:		Louis Wasserman
 maintainer:	wasserman.louis@gmail.com
-build-Depends:	base, array, ghc-prim, mtl, containers, MaybeT, uvector
+build-Depends:	base, mtl, 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.Trans.Operations, Control.Monad.Array.Unboxed
+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
+	--Control.Monad.Array.Unboxed
 ghc-options: