packages feed

stateful-mtl (empty) → 1.0

raw patch · 11 files changed

+534/−0 lines, 11 filesdep +MaybeTdep +arraydep +basesetup-changed

Dependencies added: MaybeT, array, base, containers, ghc-prim, mtl

Files

+ Control/Monad/Array.hs view
@@ -0,0 +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++import Control.Monad.Array.Class+import Control.Monad.Array.ArrayT+import Control.Monad.Array.MArray+import Control.Monad.Array.IntMap
+ Control/Monad/Array/ArrayT.hs view
@@ -0,0 +1,125 @@+{-# 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, () #)
+ Control/Monad/Array/Class.hs view
@@ -0,0 +1,125 @@+{-# LANGUAGE UndecidableInstances, RankNTypes, MultiParamTypeClasses, FunctionalDependencies, 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(Monad(return), mapM, when)+import Prelude hiding (getContents)++-- | 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+	{-# INLINE readAt #-}+	{-# INLINE unsafeReadAt #-}+	{-# INLINE writeAt #-}+	{-# INLINE unsafeWriteAt #-}+	{-# INLINE replaceAt #-}+	{-# INLINE getContents #-}+	{-# INLINE getSize #-}+	{-# 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+	resize :: Int -> m ()+	ensureSize :: Int -> m ()+	readAt i = 	do	n <- getSize+				if i >= 0 && i < n then unsafeReadAt i else fail "Index out of bounds"+	unsafeReadAt = 	readAt+	writeAt i x = 	do	n <- getSize+				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+				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+	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+	resize = lift . resize+	ensureSize = lift . ensureSize++instance MonadArray e m => MonadArray e (StrictS.StateT s m) where+	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+	resize = lift . resize+	ensureSize = lift . ensureSize++instance MonadArray e m => MonadArray e (ReaderT r m) where+	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+	resize = lift . resize+	ensureSize = lift . ensureSize++instance (Monoid w, MonadArray e m) => MonadArray e (StrictW.WriterT w m) where+	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+	resize = lift . resize+	ensureSize = lift . ensureSize++instance (Monoid w, MonadArray e m) => MonadArray e (LazyW.WriterT w m) where+	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+	resize = lift . resize+	ensureSize = lift . ensureSize++instance MonadArray e m => MonadArray e (MaybeT m) where+	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+	resize = lift . resize+	ensureSize = lift . ensureSize++instance MonadArray e m => MonadArray e (ListT m) where+	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+	resize = lift . resize+	ensureSize = lift . ensureSize
+ Control/Monad/Array/IntMap.hs view
@@ -0,0 +1,69 @@+{-# LANGUAGE GeneralizedNewtypeDeriving, 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++import qualified Data.IntMap as IM+import Data.IntMap(IntMap)+import Control.Monad+import Control.Monad.Trans+import Control.Monad.State+import Control.Monad.Reader+import Control.Monad.Array.Class+import Control.Monad.ST.Class+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)++-- | Basic monad version of 'IntMapT'.+newtype IntMapM e a = IntMapM {runIMapM :: ReaderT e (State (IM.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 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 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 (IM.IntMap e)+execIntMapT_ = execIntMapT emptyElement+evalIntMapM_ = evalIntMapM emptyElement+execIntMapM_ = execIntMapM emptyElement++emptyElement = error "Undefined array element"++instance MonadTrans (IntMapT e) where+	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)+	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)+	getSize = IntMapM $ gets IM.size+	ensureSize _ = return ()++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 =<<)
+ Control/Monad/Array/MArray.hs view
@@ -0,0 +1,56 @@+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, 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.State+import Control.Monad.Reader+import Control.Monad.Trans+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)++-- | 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 e (MArrayM a e m) where+	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+			prevConts <- mapM unsafeReadAt [0..prevSize-1]+			def <- MArrayM ask+			arr' <- liftMArray $ newListArray (0, n-1) (prevConts ++ replicate (n - prevSize) def)+			MArrayM $ put arr'++-- | 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
+ Control/Monad/ST/Class.hs view
@@ -0,0 +1,41 @@+{-# LANGUAGE FunctionalDependencies, MultiParamTypeClasses, FlexibleInstances, UndecidableInstances #-}+module Control.Monad.ST.Class where++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++-- | 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++instance MonadST s (ST s) where+	liftST m = m++instance MonadST s m => MonadST s (LazyS.StateT s' m) where+	liftST = lift . liftST++instance MonadST s m => MonadST s (StrictS.StateT s' m) where+	liftST = lift . liftST++instance MonadST s m => MonadST s (ReaderT r m) where+	liftST = lift . liftST++instance (Monoid w, MonadST s m) => MonadST s (LazyW.WriterT w m) where+	liftST = lift . liftST++instance (Monoid w, MonadST s m) => MonadST s (StrictW.WriterT w m) where+	liftST = lift . liftST++instance MonadST s m => MonadST s (MaybeT m) where+	liftST = lift . liftST++instance MonadST s m => MonadST s (ListT m) where+	liftST = lift . liftST
+ Control/Monad/ST/Trans.hs view
@@ -0,0 +1,55 @@+{-# 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)
+ Control/Monad/Trans/Operations.hs view
@@ -0,0 +1,22 @@+module Control.Monad.Trans.Operations where++import Data.Maybe+import Control.Monad+import Control.Monad.Maybe+import Control.Monad.List+import Control.Monad.State.Class++repeatMaybe :: Monad m => MaybeT m a -> ListT m a+repeatMaybe m = lift (runMaybeT m) >>= maybe mzero (\ x -> return x `mplus` repeatMaybe m)++statefully :: MonadState s m => (s -> (a, s)) -> m a+statefully f = do	s <- get+			let (x, s') = f s+			put s'+			return x++(>>=?) :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()+m >>=? f = m >>= maybe (return ()) f++execMaybeT :: Monad m => MaybeT m () -> m ()+execMaybeT = liftM (fromMaybe ()) . runMaybeT
+ LICENSE view
@@ -0,0 +1,16 @@+Copyright (c) 2008, Louis Wasserman+All rights reserved.++Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:++    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.+    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the +documentation and/or other materials provided with the distribution.+    * The name of Louis Wasserman may not be used to endorse or promote products derived from this software without specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE +GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY +OF SUCH DAMAGE.
+ Setup.lhs view
@@ -0,0 +1,3 @@+#!/usr/bin/env runhaskell+> import Distribution.Simple+> main = defaultMain
+ stateful-mtl.cabal view
@@ -0,0 +1,14 @@+name:		stateful-mtl+version:	1.0+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+category:	Monads+license:	BSD3+license-file:	LICENSE+author:		Louis Wasserman+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+ghc-options: