STMonadTrans 0.4.1 → 0.4.2

raw patch · 3 files changed

+37/−7 lines, 3 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• Control/Monad/ST/Trans.hs +29/−6
• STMonadTrans.cabal +1/−1
• changelog.md +7/−0

@@ -43,6 +43,7 @@       -- * Unsafe Operations       unsafeIOToSTT,       unsafeSTToIO,+      unsafeSTTToIO,       unsafeSTRefToIORef,       unsafeIORefToSTRef       )where@@ -51,7 +52,12 @@ import GHC.Arr (Ix(..), safeRangeSize, safeIndex,                  Array(..), arrEleBottom) import qualified GHC.Arr as STArray-import GHC.ST hiding (runST, liftST)+import GHC.ST hiding+       (runST, liftST+#if !MIN_VERSION_base(4,7,0)+        , unsafeSTToIO+#endif+        ) import Control.Monad.ST hiding (runST)  import Data.STRef (STRef)@@ -73,19 +79,22 @@ isTrue# x = x #endif -+{-# INLINE newSTRef #-} -- | Create a new reference newSTRef :: (Applicative m, Monad m) => a -> STT s m (STRef s a) newSTRef init = liftST (STRef.newSTRef init) +{-# INLINE readSTRef #-} -- | Reads the value of a reference readSTRef :: (Applicative m, Monad m) => STRef s a -> STT s m a readSTRef ref = liftST (STRef.readSTRef ref) +{-# INLINE writeSTRef #-} -- | Modifies the value of a reference writeSTRef :: (Applicative m, Monad m) => STRef s a -> a -> STT s m () writeSTRef ref a = liftST (STRef.writeSTRef ref a) +{-# DEPRECATED runST "Use runSTT instead" #-} {-# NOINLINE runST #-} -- | Executes a computation in the 'STT' monad transformer runST :: Monad m => (forall s. STT s m a) -> m a@@ -103,76 +112,90 @@  -- Mutable arrays. +{-# INLINE newSTArray #-} -- | Creates a new mutable array newSTArray :: (Ix i, Applicative m, Monad m) =>               (i,i) -> e -> STT s m (STArray s i e) newSTArray bounds init = liftST (newArray bounds init) +{-# INLINE boundsSTArray #-} -- | Returns the lowest and highest indices of the array boundsSTArray :: STArray s i e -> (i,i) boundsSTArray = STArray.boundsSTArray +{-# INLINE numElementsSTArray #-} -- | Returns the number of elements in the array numElementsSTArray :: STArray s i e -> Int numElementsSTArray = STArray.numElementsSTArray +{-# INLINE readSTArray #-} -- | Retrieves an element from the array readSTArray :: (Ix i, Applicative m, Monad m) =>                STArray s i e -> i -> STT s m e readSTArray arr i = liftST (readArray arr i) +{-# INLINE unsafeReadSTArray #-} unsafeReadSTArray :: (Ix i, Applicative m, Monad m) =>                      STArray s i e -> Int -> STT s m e unsafeReadSTArray arr i = liftST (STArray.unsafeReadSTArray arr i) +{-# INLINE writeSTArray #-} -- | Modifies an element in the array writeSTArray :: (Ix i, Applicative m, Monad m) =>                 STArray s i e -> i -> e -> STT s m () writeSTArray arr i e = liftST (writeArray arr i e) +{-# INLINE unsafeWriteSTArray #-} unsafeWriteSTArray :: (Ix i, Applicative m, Monad m) =>                       STArray s i e -> Int -> e -> STT s m () unsafeWriteSTArray arr i e = liftST (STArray.unsafeWriteSTArray arr i e) +{-# INLINE freezeSTArray #-} -- | Copy a mutable array and turn it into an immutable array freezeSTArray :: (Ix i, Applicative m, Monad m) =>                  STArray s i e -> STT s m (Array i e) freezeSTArray arr = liftST (STArray.freezeSTArray arr) +{-# INLINE unsafeFreezeSTArray #-} unsafeFreezeSTArray :: (Ix i, Applicative m, Monad m) =>                        STArray s i e -> STT s m (Array i e) unsafeFreezeSTArray arr = liftST (STArray.unsafeFreezeSTArray arr) +{-# INLINE thawSTArray #-} -- | Copy an immutable array and turn it into a mutable array thawSTArray :: (Ix i, Applicative m, Monad m) =>                Array i e -> STT s m (STArray s i e) thawSTArray arr = liftST (STArray.thawSTArray arr) +{-# INLINE unsafeThawSTArray #-} unsafeThawSTArray :: (Ix i, Applicative m, Monad m) =>                      Array i e -> STT s m (STArray s i e) unsafeThawSTArray arr = liftST (STArray.unsafeThawSTArray arr) +{-# INLINE runSTArray #-} -- | A safe way to create and work with a mutable array before returning an -- immutable array for later perusal.  This function avoids copying -- the array before returning it. runSTArray :: (Ix i, Applicative m, Monad m)            => (forall s . STT s m (STArray s i e))            -> m (Array i e)-runSTArray st = runST (st >>= unsafeFreezeSTArray)+runSTArray st = runSTT (st >>= unsafeFreezeSTArray)   {-# NOINLINE unsafeIOToSTT #-}  unsafeIOToSTT :: (Monad m) => IO a -> STT s m a unsafeIOToSTT m = return $! unsafePerformIO m +{-# DEPRECATED unsafeSTToIO "Use unsafeSTTToIO instead" #-} unsafeSTToIO :: STT s IO a -> IO a-unsafeSTToIO m = runST $ unsafeCoerce m+unsafeSTToIO m = runSTT $ unsafeCoerce m +unsafeSTTToIO :: STT s IO a -> IO a+unsafeSTTToIO m = runSTT $ unsafeCoerce m+ -- This should work, as STRef and IORef should have identical internal representation unsafeSTRefToIORef  :: STRef s a -> IORef a unsafeSTRefToIORef ref = unsafeCoerce ref  unsafeIORefToSTRef :: IORef a -> STRef s a unsafeIORefToSTRef ref = unsafeCoerce ref--

@@ -1,5 +1,5 @@ name:		STMonadTrans-version:	0.4.1+version:	0.4.2 cabal-version:  >= 1.8 license:	BSD3 license-file:	LICENSE

@@ -1,3 +1,10 @@+0.4.2++  * Deprecate runST and unsafeSTToIO in favor of+    runSTT and unsafeSTTToIO.+  * Fix compilation for GHC 7.6.3. Thanks to Andrés Sicard-Ramírez.+  * Added INLINE pragmas+ 0.4.1    * Add Applicative constraints to be compatible with GHC 7.8.4