stateful-mtl 1.0.3 → 1.0.4

raw patch · 6 files changed

+116/−96 lines, 6 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• Control/Monad/Array/ArrayT.hs +19/−19
• Control/Monad/Array/Class.hs +49/−40
• Control/Monad/Array/IntMap.hs +31/−18
• Control/Monad/Array/MArray.hs +14/−11
• Control/Monad/ST/Class.hs +1/−6
• stateful-mtl.cabal +2/−2

@@ -1,21 +1,23 @@-{-# LANGUAGE GeneralizedNewtypeDeriving, UnboxedTuples, MagicHash, RankNTypes, FlexibleInstances, MultiParamTypeClasses, UndecidableInstances #-}+{-# 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 GHC.Exts import GHC.ST(ST(..)) -import Prelude hiding (getContents)-import Control.Monad.ST+import Control.Monad.ST.Class+import Control.Monad.State.Strict+import Control.Monad.Reader.Class+import Control.Monad.Writer.Class 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 +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.@@ -33,33 +35,31 @@ 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 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 e (ArrayT e m) where+instance (MonadST m, Monad m) => MonadArray (ArrayT e m) where 	{-# INLINE unsafeReadAt #-} 	{-# INLINE unsafeWriteAt #-}-	{-# INLINE getSize #-}+	{-# 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-	getSize = ArrayT $ 	do	MArr n _ _ <- get+	askSize = ArrayT $ 	do	MArr n _ _ <- get 					return n 	resize n' = ArrayT $ 	do	a@(MArr n d _) <- get 					a' <- liftST $ newMArr n' d@@ -70,7 +70,7 @@ 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#+readMArr (MArr _ _ arr) (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, () #)+writeMArr (MArr _ _ arr) (I# i#) x = ST $ \ s -> (# writeArray# arr i# x s, () #)

@@ -1,4 +1,4 @@-{-# LANGUAGE UndecidableInstances, RankNTypes, MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances#-}+{-# LANGUAGE UndecidableInstances, MultiParamTypeClasses, TypeFamilies, FlexibleInstances#-} module Control.Monad.Array.Class where  import qualified Control.Monad.State.Lazy as LazyS@@ -9,117 +9,126 @@ import qualified Control.Monad.Writer.Strict as StrictW import Control.Monad.Maybe import Data.Monoid-import Control.Monad(Monad(return), mapM, when)-import Prelude hiding (getContents)+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', 'getSize', 'resize' or 'ensureSize'.-class Monad m => MonadArray e m | m -> e where+-- | 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 getContents #-}-	{-# INLINE getSize #-}+	{-# INLINE askElems #-}+	{-# INLINE askSize #-} 	{-# INLINE resize #-} 	{-# INLINE ensureSize #-}-	readAt :: Int -> m e-	unsafeReadAt :: Int -> m e-	writeAt :: Int -> e -> m ()-	unsafeWriteAt :: Int -> e -> m ()-	replaceAt :: Int -> e -> m e-	getContents :: m [e]-	getSize :: m Int+	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 <- getSize+	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 <- getSize+	writeAt i x = 	do	n <- askSize 				if i >= 0 && i < n then unsafeWriteAt i x else fail "Index out of bounds" 	unsafeWriteAt = writeAt-	getContents =	do	n <- getSize-				mapM readAt [0..n-1]-	ensureSize n =	do	m <- getSize+	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 e m => MonadArray e (LazyS.StateT s m) where+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)-	getContents = lift getContents-	getSize = lift getSize+	askElems = lift askElems+	askSize = lift askSize 	resize = lift . resize 	ensureSize = lift . ensureSize -instance MonadArray e m => MonadArray e (StrictS.StateT s m) where+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)-	getContents = lift getContents-	getSize = lift getSize+	askElems = lift askElems+	askSize = lift askSize 	resize = lift . resize 	ensureSize = lift . ensureSize -instance MonadArray e m => MonadArray e (ReaderT r m) where+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)-	getContents = lift getContents-	getSize = lift getSize+	askElems = lift askElems+	askSize = lift askSize 	resize = lift . resize 	ensureSize = lift . ensureSize -instance (Monoid w, MonadArray e m) => MonadArray e (StrictW.WriterT w m) where+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)-	getContents = lift getContents-	getSize = lift getSize+	askElems = lift askElems+	askSize = lift askSize 	resize = lift . resize 	ensureSize = lift . ensureSize -instance (Monoid w, MonadArray e m) => MonadArray e (LazyW.WriterT w m) where+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)-	getContents = lift getContents-	getSize = lift getSize+	askElems = lift askElems+	askSize = lift askSize 	resize = lift . resize 	ensureSize = lift . ensureSize -instance MonadArray e m => MonadArray e (MaybeT m) where+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)-	getContents = lift getContents-	getSize = lift getSize+	askElems = lift askElems+	askSize = lift askSize 	resize = lift . resize 	ensureSize = lift . ensureSize -instance MonadArray e m => MonadArray e (ListT m) where+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)-	getContents = lift getContents-	getSize = lift getSize+	askElems = lift askElems+	askSize = lift askSize 	resize = lift . resize 	ensureSize = lift . ensureSize

@@ -1,36 +1,38 @@-{-# LANGUAGE GeneralizedNewtypeDeriving, UndecidableInstances, FlexibleInstances, MultiParamTypeClasses #-}+{-# 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, IntMapM, evalIntMapT, evalIntMapM, execIntMapT, execIntMapM, execIntMapT_, evalIntMapT_, execIntMapM_, evalIntMapM_) where+module Control.Monad.Array.IntMap (IntMapT, evalIntMapT, execIntMapT, execIntMapT_, evalIntMapT_, IntMapM, execIntMapM, evalIntMapM,  execIntMapM_, evalIntMapM_) where -import qualified Data.IntMap as IM-import Data.IntMap(IntMap)-import Control.Monad-import Control.Monad.Trans+import Control.Monad.Array.Class+ import Control.Monad.State import Control.Monad.Reader-import Control.Monad.Array.Class-import Control.Monad.ST.Class import Control.Monad.Writer.Class+import Control.Monad.Trans --- | 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 'getSize' operation returns the number of associations in the 'IntMap'.-newtype IntMapT e m a = IntMapT {runIMapT :: ReaderT e (StateT (IM.IntMap e) m) a} deriving (Monad, MonadFix, MonadPlus, MonadIO, MonadWriter w)+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 (IM.IntMap e)) a} deriving (Monad, MonadFix)+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 (IM.IntMap e)+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 -> IM.IntMap e+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.@@ -38,27 +40,38 @@ evalIntMapT_ = evalIntMapT emptyElement  -- | Evaluates an 'IntMapT' computation with no default element specified, returning the final 'IntMap'.-execIntMapT_ :: Monad m => IntMapT e m a -> m (IM.IntMap e)+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 e (IntMapT e m) where+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)-	getSize = IntMapT $ gets IM.size+	askSize = IntMapT $ gets IM.size 	ensureSize _ = return ()+	askElems = IntMapT $ gets IM.elems+	askAssocs = IntMapT $ gets IM.toList -instance MonadArray e (IntMapM e) where+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)-	getSize = IntMapM $ gets IM.size+	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

@@ -1,19 +1,20 @@-{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, GeneralizedNewtypeDeriving #-}+{-# 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 Data.Array.MArray-import GHC.Arr-import Data.Array.Base-import Prelude hiding (getContents) import Control.Monad.Array.Class-import Control.Monad+import Control.Monad.ST.Class++import GHC.Arr+ import Control.Monad.State import Control.Monad.Reader import Control.Monad.Trans-import Control.Monad.ST.Class +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) @@ -36,18 +37,20 @@ emptyElement :: e emptyElement = error "Undefined array element" -instance (Monad m, MArray a e m) => MonadArray e (MArrayM a e m) where+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-	getSize = MArrayM (get >>= lift2 . liftM rangeSize . getBounds)-	resize n = do	prevSize <- getSize+	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'-	getContents = MArrayM $ get >>= lift . lift . getElems+	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

@@ -12,8 +12,7 @@ /Do not/ implement 'MonadST' propagation if you also provide a 'MonadTrans' instance.-} module Control.Monad.ST.Class where -import GHC.IOBase(ioToST, stToIO)-import Control.Monad.ST(RealWorld, ST)+import Control.Monad.ST import Control.Monad.Trans  -- | Type class of monads that can perform lifted computation in the 'ST' monad.@@ -25,10 +24,6 @@ instance MonadST (ST s) where 	type StateThread (ST s) = s 	liftST m = m--instance MonadST IO where-	type StateThread IO = RealWorld-	liftST = stToIO  instance (MonadST m, MonadTrans t, Monad m) => MonadST (t m) where 	type StateThread (t m) = StateThread m

@@ -1,7 +1,7 @@ name:		stateful-mtl-version:	1.0.3+version:	1.0.4 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.+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. tested-with:	GHC category:	Monads license:	BSD3