Hello community, here is the log from the commit of package ghc-STMonadTrans for openSUSE:Factory checked in at 2017-03-14 10:04:16 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-STMonadTrans (Old) and /work/SRC/openSUSE:Factory/.ghc-STMonadTrans.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-STMonadTrans" Tue Mar 14 10:04:16 2017 rev:3 rq:461527 version:0.4.3 Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-STMonadTrans/ghc-STMonadTrans.changes 2016-12-06 14:24:04.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.ghc-STMonadTrans.new/ghc-STMonadTrans.changes 2017-03-14 10:04:17.203580632 +0100 @@ -1,0 +2,5 @@ +Sun Feb 12 14:20:02 UTC 2017 - [email protected] + +- Update to version 0.4.3 with cabal2obs. + +------------------------------------------------------------------- Old: ---- STMonadTrans-0.3.4.tar.gz New: ---- STMonadTrans-0.4.3.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-STMonadTrans.spec ++++++ --- /var/tmp/diff_new_pack.JlXelQ/_old 2017-03-14 10:04:17.763501347 +0100 +++ /var/tmp/diff_new_pack.JlXelQ/_new 2017-03-14 10:04:17.763501347 +0100 @@ -1,7 +1,7 @@ # # spec file for package ghc-STMonadTrans # -# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2017 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -19,7 +19,7 @@ %global pkg_name STMonadTrans %bcond_with tests Name: ghc-%{pkg_name} -Version: 0.3.4 +Version: 0.4.3 Release: 0 Summary: A monad transformer version of the ST monad License: BSD-3-Clause @@ -75,5 +75,6 @@ %files devel -f %{name}-devel.files %defattr(-,root,root,-) +%doc changelog.md %changelog ++++++ STMonadTrans-0.3.4.tar.gz -> STMonadTrans-0.4.3.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/STMonadTrans-0.3.4/Control/Monad/ST/Trans/Internal.hs new/STMonadTrans-0.4.3/Control/Monad/ST/Trans/Internal.hs --- old/STMonadTrans-0.3.4/Control/Monad/ST/Trans/Internal.hs 2016-11-05 11:53:40.000000000 +0100 +++ new/STMonadTrans-0.4.3/Control/Monad/ST/Trans/Internal.hs 2017-02-09 14:18:16.000000000 +0100 @@ -24,6 +24,23 @@ module Control.Monad.ST.Trans.Internal where import GHC.Base +import GHC.ST hiding (liftST) + +import Control.Monad.Fix +import Control.Monad.Trans +import Control.Monad.Error.Class +import Control.Monad.Reader.Class +import Control.Monad.State.Class +import Control.Monad.Writer.Class + +import Control.Applicative + +import Data.Array.ST +import Data.Array.Base +import GHC.Int (Int8, Int16, Int32, Int64) +import GHC.Word (Word8, Word16, Word32, Word64) +import GHC.Ptr (Ptr, FunPtr) +import GHC.Stable (StablePtr) -- | 'STT' is the monad transformer providing polymorphic updateable references newtype STT s m a = STT (State# s -> m (STTRet s a)) @@ -35,3 +52,288 @@ -- around. This type is essentially a pair, but an ordinary pair is not -- not allowed to contain unboxed types. data STTRet s a = STTRet (State# s) a + +-- | Lifting the `ST` monad into `STT`. The library uses this function +-- extensively to be able to reuse functions from `ST`. +liftST :: Applicative m => ST s a -> STT s m a +liftST (ST f) = STT (\s -> let (# s', a #) = f s in pure (STTRet s' a)) +{-# INLINE liftST #-} + +-- All instances have to go in this module because otherwise they +-- would be orphan instances. + +instance Monad m => Monad (STT s m) where + return a = STT $ \st -> return (STTRet st a) + STT m >>= k = STT $ \st -> + do ret <- m st + case ret of + STTRet new_st a -> + unSTT (k a) new_st + fail msg = lift (fail msg) + +instance MonadTrans (STT s) where + lift m = STT $ \st -> + do a <- m + return (STTRet st a) + +liftSTT :: STT s m a -> State# s -> m (STTRet s a) +liftSTT (STT m) s = m s + +instance (MonadFix m) => MonadFix (STT s m) where + mfix k = STT $ \ s -> mdo + ans@(STTRet _ r) <- liftSTT (k r) s + return ans + +instance Functor (STTRet s) where + fmap f (STTRet s a) = STTRet s (f a) + +instance Functor m => Functor (STT s m) where + fmap f (STT g) = STT $ \s# -> (fmap . fmap) f (g s#) + +instance (Monad m, Functor m) => Applicative (STT s m) where + pure a = STT $ \s# -> return (STTRet s# a) + (STT m) <*> (STT n) = STT $ \s1 -> + do (STTRet s2 f) <- m s1 + (STTRet s3 x) <- n s2 + return (STTRet s3 (f x)) + +-- Instances of other monad classes + +instance MonadError e m => MonadError e (STT s m) where + throwError e = lift (throwError e) + catchError (STT m) f = STT $ \st -> catchError (m st) + (\e -> unSTT (f e) st) + +instance MonadReader r m => MonadReader r (STT s m) where + ask = lift ask + local f (STT m) = STT $ \st -> local f (m st) + +instance MonadState s m => MonadState s (STT s' m) where + get = lift get + put s = lift (put s) + +instance MonadWriter w m => MonadWriter w (STT s m) where + tell w = lift (tell w) + listen (STT m)= STT $ \st1 -> do (STTRet st2 a, w) <- listen (m st1) + return (STTRet st2 (a,w)) + pass (STT m) = STT $ \st1 -> pass (do (STTRet st2 (a,f)) <- m st1 + return (STTRet st2 a, f)) + +-- MArray instances + +instance (Applicative m, Monad m) => MArray (STArray s) e (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) Bool (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) Char (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) Int (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) Word (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) (Ptr a) (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) (FunPtr a) (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) Float (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) Double (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) (StablePtr a) (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) Int8 (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) Int16 (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) Int32 (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) Int64 (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) Word8 (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) Word16 (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) Word32 (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + +instance (Applicative m, Monad m) => MArray (STUArray s) Word64 (STT s m) where + {-# INLINE getBounds #-} + getBounds arr = liftST (getBounds arr) + {-# INLINE getNumElements #-} + getNumElements arr = liftST (getNumElements arr) + {-# INLINE newArray #-} + newArray bounds e = liftST (newArray bounds e) + {-# INLINE unsafeRead #-} + unsafeRead arr i = liftST (unsafeRead arr i) + {-# INLINE unsafeWrite #-} + unsafeWrite arr i e = liftST (unsafeWrite arr i e) + diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/STMonadTrans-0.3.4/Control/Monad/ST/Trans.hs new/STMonadTrans-0.4.3/Control/Monad/ST/Trans.hs --- old/STMonadTrans-0.3.4/Control/Monad/ST/Trans.hs 2016-11-05 11:53:40.000000000 +0100 +++ new/STMonadTrans-0.4.3/Control/Monad/ST/Trans.hs 2017-02-09 14:18:16.000000000 +0100 @@ -2,7 +2,7 @@ MultiParamTypeClasses, UndecidableInstances, RecursiveDo #-} {- | Module : Control.Monad.ST.Trans - Copyright : Josef Svenningsson 2008-2010 + Copyright : Josef Svenningsson 2008-2017 (c) The University of Glasgow, 1994-2000 License : BSD @@ -14,16 +14,17 @@ Warning! This monad transformer should not be used with monads that can contain multiple answers, like the list monad. The reason is that - the will be duplicated across the different answers and this cause - Bad Things to happen (such as loss of referential transparency). Safe - monads include the monads State, Reader, Writer, Maybe and - combinations of their corresponding monad transformers. + the state token will be duplicated across the different answers and + this causes Bad Things to happen (such as loss of referential + transparency). Safe monads include the monads State, Reader, Writer, + Maybe and combinations of their corresponding monad transformers. -} module Control.Monad.ST.Trans( -- * The ST Monad Transformer STT, runST, + runSTT, -- * Mutable references STRef, newSTRef, @@ -40,8 +41,13 @@ thawSTArray, runSTArray, -- * Unsafe Operations + unsafeReadSTArray, + unsafeWriteSTArray, + unsafeFreezeSTArray, + unsafeThawSTArray, unsafeIOToSTT, unsafeSTToIO, + unsafeSTTToIO, unsafeSTRefToIORef, unsafeIORefToSTRef )where @@ -49,17 +55,16 @@ import GHC.Base import GHC.Arr (Ix(..), safeRangeSize, safeIndex, Array(..), arrEleBottom) +import qualified GHC.Arr as STArray -import Control.Monad.ST.Trans.Internal +import Data.STRef (STRef) +import qualified Data.STRef as STRef -import Control.Monad.Fix -import Control.Monad.Trans -import Control.Monad.Error.Class -import Control.Monad.Reader.Class -import Control.Monad.State.Class -import Control.Monad.Writer.Class +import Data.Array.ST hiding (runSTArray) +import qualified Data.Array.ST as STArray import Control.Applicative +import Control.Monad.ST.Trans.Internal import Data.IORef @@ -71,188 +76,119 @@ isTrue# x = x #endif -instance Monad m => Monad (STT s m) where - return a = STT $ \st -> return (STTRet st a) - STT m >>= k = STT $ \st -> - do ret <- m st - case ret of - STTRet new_st a -> - unSTT (k a) new_st - fail msg = lift (fail msg) - -instance MonadTrans (STT s) where - lift m = STT $ \st -> - do a <- m - return (STTRet st a) - -liftSTT :: STT s m a -> State# s -> m (STTRet s a) -liftSTT (STT m) s = m s - -instance (MonadFix m) => MonadFix (STT s m) where - mfix k = STT $ \ s -> mdo - ans@(STTRet _ r) <- liftSTT (k r) s - return ans - -instance Functor (STTRet s) where - fmap f (STTRet s a) = STTRet s (f a) - -instance Functor m => Functor (STT s m) where - fmap f (STT g) = STT $ \s# -> (fmap . fmap) f (g s#) - -instance (Monad m, Functor m) => Applicative (STT s m) where - pure a = STT $ \s# -> return (STTRet s# a) - (STT m) <*> (STT n) = STT $ \s1 -> - do (STTRet s2 f) <- m s1 - (STTRet s3 x) <- n s2 - return (STTRet s3 (f x)) - --- | Mutable references -data STRef s a = STRef (MutVar# s a) - +{-# INLINE newSTRef #-} -- | Create a new reference -newSTRef :: Monad m => a -> STT s m (STRef s a) -newSTRef init = STT $ \st1 -> - case newMutVar# init st1 of - (# st2, var #) -> return (STTRet st2 (STRef var)) +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 :: Monad m => STRef s a -> STT s m a -readSTRef (STRef var) = STT $ \st1 -> - case readMutVar# var st1 of - (# st2, a #) -> return (STTRet st2 a) +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 :: Monad m => STRef s a -> a -> STT s m () -writeSTRef (STRef var) a = STT $ \st1 -> - case writeMutVar# var a st1 of - st2 -> return (STTRet st2 ()) - -instance Eq (STRef s a) where - STRef v1 == STRef v2 = isTrue# (sameMutVar# v1 v2) +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 runST m = let (STT f) = m -- the parenthesis is needed because of a bug in GHC's parser - in do (STTRet st a) <- ( f realWorld# ) + in do (STTRet _st a) <- ( f realWorld# ) return a --- Instances of other monad classes - -instance MonadError e m => MonadError e (STT s m) where - throwError e = lift (throwError e) - catchError (STT m) f = STT $ \st -> catchError (m st) - (\e -> unSTT (f e) st) - -instance MonadReader r m => MonadReader r (STT s m) where - ask = lift ask - local f (STT m) = STT $ \st -> local f (m st) - -instance MonadState s m => MonadState s (STT s' m) where - get = lift get - put s = lift (put s) - -instance MonadWriter w m => MonadWriter w (STT s m) where - tell w = lift (tell w) - listen (STT m)= STT $ \st1 -> do (STTRet st2 a, w) <- listen (m st1) - return (STTRet st2 (a,w)) - pass (STT m) = STT $ \st1 -> pass (do (STTRet st2 (a,f)) <- m st1 - return (STTRet st2 a, f)) - --- Mutable arrays. See the definition in GHC.Arr - --- | Mutable arrays -data STArray s i e = STArray !i !i !Int (MutableArray# s e) +{-# NOINLINE runSTT #-} +-- | Executes a computation in the 'STT' monad transformer +runSTT :: Monad m => (forall s. STT s m a) -> m a +runSTT m = let (STT f) = m + in do (STTRet _st a) <- ( f realWorld# ) + return a -instance Eq (STArray s i e) where - STArray _ _ _ arr1# == STArray _ _ _ arr2# = isTrue# (sameMutableArray# arr1# arr2#) +-- Mutable arrays. +{-# INLINE newSTArray #-} -- | Creates a new mutable array -newSTArray :: (Ix i, Monad m) => (i,i) -> e -> STT s m (STArray s i e) -newSTArray (l,u) init = STT $ \s1# -> - case safeRangeSize (l,u) of { n@(I# n#) -> - case newArray# n# init s1# of { (# s2#, marr# #) -> - return (STTRet s2# (STArray l u n marr#)) }} +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 l u _ _) = (l,u) +boundsSTArray = STArray.boundsSTArray +{-# INLINE numElementsSTArray #-} -- | Returns the number of elements in the array numElementsSTArray :: STArray s i e -> Int -numElementsSTArray (STArray _ _ n _) = n +numElementsSTArray = STArray.numElementsSTArray +{-# INLINE readSTArray #-} -- | Retrieves an element from the array -readSTArray :: (Ix i, Monad m) => STArray s i e -> i -> STT s m e -readSTArray marr@(STArray l u n _) i = - unsafeReadSTArray marr (safeIndex (l,u) n i) - -unsafeReadSTArray :: (Ix i, Monad m) => STArray s i e -> Int -> STT s m e -unsafeReadSTArray (STArray _ _ _ marr#) (I# i#) - = STT $ \s1# -> case readArray# marr# i# s1# of - (# s2#, e #) -> return (STTRet s2# e) +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, Monad m) => STArray s i e -> i -> e -> STT s m () -writeSTArray marr@(STArray l u n _) i e = - unsafeWriteSTArray marr (safeIndex (l,u) n i) e - -unsafeWriteSTArray :: (Ix i, Monad m) => STArray s i e -> Int -> e -> STT s m () -unsafeWriteSTArray (STArray _ _ _ marr#) (I# i#) e = STT $ \s1# -> - case writeArray# marr# i# e s1# of - s2# -> return (STTRet s2# ()) +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,Monad m) => STArray s i e -> STT s m (Array i e) -freezeSTArray (STArray l u n@(I# n#) marr#) = STT $ \s1# -> - case newArray# n# arrEleBottom s1# of { (# s2#, marr'# #) -> - let copy i# s3# | isTrue# (i# ==# n#) = s3# - | otherwise = - case readArray# marr# i# s3# of { (# s4#, e #) -> - case writeArray# marr'# i# e s4# of { s5# -> - copy (i# +# 1#) s5# }} in - case copy 0# s2# of { s3# -> - case unsafeFreezeArray# marr'# s3# of { (# s4#, arr# #) -> - return (STTRet s4# (Array l u n arr# )) }}} - -unsafeFreezeSTArray :: (Ix i, Monad m) => STArray s i e -> STT s m (Array i e) -unsafeFreezeSTArray (STArray l u n marr#) = STT $ \s1# -> - case unsafeFreezeArray# marr# s1# of { (# s2#, arr# #) -> - return (STTRet s2# (Array l u n arr# )) } +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, Monad m) => Array i e -> STT s m (STArray s i e) -thawSTArray (Array l u n@(I# n#) arr#) = STT $ \s1# -> - case newArray# n# arrEleBottom s1# of { (# s2#, marr# #) -> - let copy i# s3# | isTrue# (i# ==# n#) = s3# - | otherwise = - case indexArray# arr# i# of { (# e #) -> - case writeArray# marr# i# e s3# of { s4# -> - copy (i# +# 1#) s4# }} in - case copy 0# s2# of { s3# -> - return (STTRet s3# (STArray l u n marr# )) }} - -unsafeThawSTArray :: (Ix i, Monad m) => Array i e -> STT s m (STArray s i e) -unsafeThawSTArray (Array l u n arr#) = STT $ \s1# -> - case unsafeThawArray# arr# s1# of { (# s2#, marr# #) -> - return (STTRet s2# (STArray l u n marr# )) } +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, Monad m) +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 @@ -260,5 +196,3 @@ unsafeIORefToSTRef :: IORef a -> STRef s a unsafeIORefToSTRef ref = unsafeCoerce ref - - diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/STMonadTrans-0.3.4/STMonadTrans.cabal new/STMonadTrans-0.4.3/STMonadTrans.cabal --- old/STMonadTrans-0.3.4/STMonadTrans.cabal 2016-11-05 11:53:40.000000000 +0100 +++ new/STMonadTrans-0.4.3/STMonadTrans.cabal 2017-02-09 14:18:16.000000000 +0100 @@ -1,5 +1,5 @@ name: STMonadTrans -version: 0.3.4 +version: 0.4.3 cabal-version: >= 1.8 license: BSD3 license-file: LICENSE @@ -13,10 +13,13 @@ Warning! This monad transformer should not be used with monads that can contain multiple answers, like the list monad. The reason is that - the state token will be duplicated across the different answers and this causes - Bad Things to happen (such as loss of referential transparency). Safe - monads include the monads State, Reader, Writer, Maybe and - combinations of their corresponding monad transformers. + the state token will be duplicated across the different answers and + this causes Bad Things to happen (such as loss of referential + transparency). Safe monads include the monads State, Reader, Writer, + Maybe and combinations of their corresponding monad transformers. + +extra-source-files: + changelog.md source-repository head type: git diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/STMonadTrans-0.3.4/changelog.md new/STMonadTrans-0.4.3/changelog.md --- old/STMonadTrans-0.3.4/changelog.md 1970-01-01 01:00:00.000000000 +0100 +++ new/STMonadTrans-0.4.3/changelog.md 2017-02-09 14:18:16.000000000 +0100 @@ -0,0 +1,21 @@ +0.4.3 + + * Fix compilation for GHC 7.6.3. Thanks to Andrés Sicard-Ramírez. + * Export unsafe array operations + +0.4.2 + + * Deprecate runST and unsafeSTToIO in favor of + runSTT and unsafeSTTToIO. + * Added INLINE pragmas + +0.4.1 + + * Add Applicative constraints to be compatible with GHC 7.8.4 + * Add changelog + +0.4 + + * New library structure, based on liftST. It reuses more code and + types from the standard ST monad. Thanks to @wyager for liftST. + * Instances for MArray diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/STMonadTrans-0.3.4/dist/build/fooStub/fooStub-tmp/fooStub.hs new/STMonadTrans-0.4.3/dist/build/fooStub/fooStub-tmp/fooStub.hs --- old/STMonadTrans-0.3.4/dist/build/fooStub/fooStub-tmp/fooStub.hs 2016-11-05 11:53:40.000000000 +0100 +++ new/STMonadTrans-0.4.3/dist/build/fooStub/fooStub-tmp/fooStub.hs 1970-01-01 01:00:00.000000000 +0100 @@ -1,5 +0,0 @@ -module Main ( main ) where -import Distribution.Simple.Test.LibV09 ( stubMain ) -import Test ( tests ) -main :: IO () -main = stubMain tests
