stateful-mtl 1.0.1 → 1.0.2

raw patch · 7 files changed

+83/−64 lines, 7 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 +0/−55
• Control/Monad/Array/ArrayT.hs +73/−0
• Control/Monad/Array/IntMap.hs +4/−4
• Control/Monad/Array/MArray.hs +1/−0
• Control/Monad/ST/Class.hs +1/−1
• 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.ArrayM, module Control.Monad.Array.MArray, module Control.Monad.Array.IntMap) where+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  import Control.Monad.Array.Class-import Control.Monad.Array.ArrayM+import Control.Monad.Array.ArrayT import Control.Monad.Array.MArray import Control.Monad.Array.IntMap

@@ -1,55 +0,0 @@-{-# 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, () #)

@@ -0,0 +1,73 @@+{-# LANGUAGE GeneralizedNewtypeDeriving, UnboxedTuples, MagicHash, OverlappingInstances, RankNTypes, 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, runArrayMIO, runArrayM_, runArrayMIO_, runArrayT, runArrayT_) 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 controlling safe access to an underlying array.+type ArrayM s e = ArrayT s e (ST s)+-- | Monad transformer that safely grants the underlying monad access to a mutable array.+newtype ArrayT s e m a = ArrayT {runArrT :: StateT (MArr s e) m a} deriving (Monad, MonadTrans, MonadFix, MonadST s, MonadReader r, MonadWriter w)++instance MonadState t m => MonadState t (ArrayT s 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++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 s m, Monad m) => Int -> e -> ArrayT s e m a -> m a+runArrayT n d m = liftST (newMArr n d) >>= evalStateT (runArrT m)++runArrayT_ :: (MonadST s m, Monad m) => Int -> ArrayT s e m a -> m a+runArrayT_ n = runArrayT n emptyElement++emptyElement = error "Undefined array element"++instance (MonadST s m, Monad m) => MonadArray e (ArrayT s 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'++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, () #)

@@ -49,14 +49,14 @@ 	lift = IntMapT . lift . lift  instance Monad m => MonadArray e (IntMapT e m) where-	unsafeReadAt i = IntMapT $ gets (IM.lookup i) >>= maybe ask return-	unsafeWriteAt i x = IntMapT $ modify (IM.insert i x)+	readAt i = IntMapT $ gets (IM.lookup i) >>= maybe ask return+	writeAt i x = IntMapT $ modify (IM.insert i x) 	getSize = IntMapT $ gets IM.size 	ensureSize _ = return ()  instance MonadArray e (IntMapM e) where-	unsafeReadAt i = IntMapM $ gets (IM.lookup i) >>= maybe ask return-	unsafeWriteAt i x = IntMapM $ modify (IM.insert i x)+	readAt i = IntMapM $ gets (IM.lookup i) >>= maybe ask return+	writeAt i x = IntMapM $ modify (IM.insert i x) 	getSize = IntMapM $ gets IM.size 	ensureSize _ = return () 

@@ -47,6 +47,7 @@ 			def <- MArrayM ask 			arr' <- liftMArray $ newListArray (0, n-1) (prevConts ++ replicate (n - prevSize) def) 			MArrayM $ put arr'+	getContents = MArrayM $ get >>= lift . lift . getElems  -- | 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

@@ -1,4 +1,4 @@-{-# LANGUAGE FunctionalDependencies, MultiParamTypeClasses, FlexibleInstances, UndecidableInstances #-}+{-# LANGUAGE OverlappingInstances, FunctionalDependencies, MultiParamTypeClasses, FlexibleInstances, UndecidableInstances #-} module Control.Monad.ST.Class where  import GHC.IOBase(ioToST)

@@ -1,5 +1,5 @@ name:		stateful-mtl-version:	1.0.1+version:	1.0.2 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.ArrayM, Control.Monad.Array.IntMap, Control.Monad.Array.MArray, Control.Monad.Array.Class, Control.Monad.ST.Class, Control.Monad.Trans.Operations+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 ghc-options: