stateful-mtl 1.0.6 → 1.0.7

raw patch · 7 files changed

+13/−418 lines, 7 filesdep −arraydep −containersdep −ghc-primPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies removed: array, containers, ghc-prim, uvector

API changes (from Hackage documentation)

Files

• Control/Monad/Array.hs +0/−9
• Control/Monad/Array/ArrayT.hs +0/−77
• Control/Monad/Array/Class.hs +0/−134
• Control/Monad/Array/IntMap.hs +0/−82
• Control/Monad/Array/MArray.hs +0/−60
• Control/Monad/Array/Unboxed.hs +0/−51
• stateful-mtl.cabal +13/−5

@@ -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

@@ -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, () #)

@@ -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

@@ -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 =<<)

@@ -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

@@ -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)

@@ -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: