stateful-mtl 1.0 → 1.0.1

raw patch · 5 files changed

+59/−184 lines, 5 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• Control/Monad/Array.hs +2/−2
• Control/Monad/Array/ArrayM.hs +55/−0
• Control/Monad/Array/ArrayT.hs +0/−125
• Control/Monad/ST/Trans.hs +0/−55
• stateful-mtl.cabal +2/−2

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

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

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

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

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