stateful-mtl 1.0.2 → 1.0.3

raw patch · 5 files changed

+66/−45 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/ArrayT.hs +15/−12
• Control/Monad/Array/IntMap.hs +1/−1
• Control/Monad/Array/MArray.hs +1/−1
• Control/Monad/ST/Class.hs +48/−30
• stateful-mtl.cabal +1/−1

@@ -1,7 +1,7 @@-{-# LANGUAGE GeneralizedNewtypeDeriving, UnboxedTuples, MagicHash, OverlappingInstances, RankNTypes, FlexibleInstances, MultiParamTypeClasses, UndecidableInstances #-}+{-# LANGUAGE GeneralizedNewtypeDeriving, UnboxedTuples, MagicHash, 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+module Control.Monad.Array.ArrayT (ArrayM, ArrayT, runArrayM, runArrayM_, runArrayT, runArrayT_) where  import GHC.Exts import GHC.ST(ST(..))@@ -19,35 +19,38 @@ 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)+type ArrayM s e = ArrayT 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)+newtype ArrayT e m a = ArrayT {runArrT :: StateT (MArr (StateThread m) e) m a} deriving (Monad, MonadFix, MonadPlus, MonadReader r, MonadWriter w) -instance MonadState t m => MonadState t (ArrayT s e m) where+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 -runArrayMIO :: Int -> e -> ArrayM RealWorld e a -> IO a-runArrayMIO n d m = stToIO $ 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+-- 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 :: (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 s m, Monad m) => Int -> ArrayT s e m a -> m a+runArrayT_ :: (MonadST m, Monad m) => Int -> ArrayT 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+instance (MonadST m, Monad m) => MonadArray e (ArrayT e m) where 	{-# INLINE unsafeReadAt #-} 	{-# INLINE unsafeWriteAt #-} 	{-# INLINE getSize #-}

@@ -14,7 +14,7 @@ import Control.Monad.Writer.Class  -- | 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, MonadST s, MonadWriter w)+newtype IntMapT e m a = IntMapT {runIMapT :: ReaderT e (StateT (IM.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)

@@ -15,7 +15,7 @@ import Control.Monad.ST.Class  -- | 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 s)+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

@@ -1,41 +1,59 @@-{-# LANGUAGE OverlappingInstances, FunctionalDependencies, MultiParamTypeClasses, FlexibleInstances, UndecidableInstances #-}-module Control.Monad.ST.Class where+{-# LANGUAGE TypeFamilies, FlexibleInstances #-}+{- | This module contains the 'MonadST' type class, which encapsulates a monad capable of lifting an ST computation.  This type class is /only/ intended to be implemented by the 'ST' monad and any stack of monad transformers over an 'ST' monad. -import GHC.IOBase(ioToST)-import Control.Monad.ST(RealWorld, ST)-import Control.Monad.Maybe-import Control.Monad.List-import qualified Control.Monad.State.Lazy as LazyS-import qualified Control.Monad.State.Strict as StrictS-import Control.Monad.Reader-import Data.Monoid(Monoid)-import qualified Control.Monad.Writer.Lazy as LazyW-import qualified Control.Monad.Writer.Strict as StrictW+Presence of a MonadST instance implies that --- | Type class of monads that can perform lifted computation in the 'ST' monad.-class Monad m => MonadST s m | m -> s where-	liftST :: ST s a -> m a+ * The monad is single-threaded: performing an 'ST' computation will not cause loss of referential transparency, and only one copy of its state thread will be available at any time. -instance MonadST s (ST s) where-	liftST m = m+ * Monad transformers can demand an underlying 'MonadST' instance and use its state thread for their own safe computation in the 'ST' monad. -instance MonadST s m => MonadST s (LazyS.StateT s' m) where-	liftST = lift . liftST+/Note/: Most monad type classes cannot pass instances up through any instance of 'MonadTrans', because a transformer farther out may wish to override the inner instance.  However, in 'MonadST' we very specifically only want one state thread for any stack of transformers, and specifically one at the very bottom level.  This justifies the very general 'MonadST' propagation instance, @(MonadST m, MonadTrans t, Monad m, Monad (t m)) => MonadST (t m)@ (not shown in Haddock for unknown reasons).   -instance MonadST s m => MonadST s (StrictS.StateT s' m) where-	liftST = lift . liftST+/Do not/ implement 'MonadST' propagation if you also provide a 'MonadTrans' instance.-}+module Control.Monad.ST.Class where -instance MonadST s m => MonadST s (ReaderT r m) where-	liftST = lift . liftST+import GHC.IOBase(ioToST, stToIO)+import Control.Monad.ST(RealWorld, ST)+import Control.Monad.Trans -instance (Monoid w, MonadST s m) => MonadST s (LazyW.WriterT w m) where-	liftST = lift . liftST+-- | Type class of monads that can perform lifted computation in the 'ST' monad.+class MonadST m where+	-- | The type of the state thread used in this monad, never actually instantiated.+	type StateThread m+	liftST :: ST (StateThread m) a -> m a -instance (Monoid w, MonadST s m) => MonadST s (StrictW.WriterT w m) where-	liftST = lift . liftST+instance MonadST (ST s) where+	type StateThread (ST s) = s+	liftST m = m -instance MonadST s m => MonadST s (MaybeT m) where-	liftST = lift . liftST+instance MonadST IO where+	type StateThread IO = RealWorld+	liftST = stToIO -instance MonadST s m => MonadST s (ListT m) where+instance (MonadST m, MonadTrans t, Monad m) => MonadST (t m) where+	type StateThread (t m) = StateThread m 	liftST = lift . liftST++-- instance (MonadST m, Monad m) => MonadST (LazyS.StateT s m) where+-- 	type StateThread (LazyS.StateT s m) = StateThread m+-- 	liftST = lift . liftST+-- +-- instance (MonadST m, Monad m) => MonadST (StrictS.StateT s m) where+-- 	type StateThread (StrictS.StateT s m) = StateThread m+-- 	liftST = lift . liftST+-- +-- instance (MonadST m, Monad m) => MonadST (ReaderT r m) where+-- 	type StateThread (ReaderT r m) = StateThread m+-- 	liftST = lift . liftST+-- +-- instance (MonadST m, Monad m, Monoid w) => MonadST (LazyW.WriterT w m) where+-- 	type StateThread (LazyW.WriterT w m) = StateThread m+-- 	liftST = lift . liftST+-- +-- instance (MonadST m, Monad m, Monoid w) => MonadST (StrictW.WriterT w m) where+-- 	type StateThread (StrictW.WriterT w m) = StateThread m+-- 	liftST = lift . liftST+-- +-- instance (MonadST m, Monad m) => MonadST (MaybeT m) where+-- 	type StateThread (MaybeT m) = StateThread m+-- 	liftST = lift . liftST

@@ -1,5 +1,5 @@ name:		stateful-mtl-version:	1.0.2+version:	1.0.3 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