module Control.Monad.ST.Trans(
STT,
runST,
runSTT,
STRef,
newSTRef,
readSTRef,
writeSTRef,
STArray,
newSTArray,
readSTArray,
writeSTArray,
boundsSTArray,
numElementsSTArray,
freezeSTArray,
thawSTArray,
runSTArray,
unsafeIOToSTT,
unsafeSTToIO,
unsafeSTRefToIORef,
unsafeIORefToSTRef
)where
import GHC.Base
import GHC.Arr (Ix(..), safeRangeSize, safeIndex,
Array(..), arrEleBottom)
import qualified GHC.Arr as STArray
import GHC.ST hiding (runST, liftST)
import Control.Monad.ST hiding (runST)
import Data.STRef (STRef)
import qualified Data.STRef as STRef
import Data.Array.ST hiding (runSTArray)
import qualified Data.Array.ST as STArray
import Control.Monad.ST.Trans.Internal
import Data.IORef
import Unsafe.Coerce
import System.IO.Unsafe
#if __GLASGOW_HASKELL__ < 708
isTrue# :: Bool -> Bool
isTrue# x = x
#endif
newSTRef :: Monad m => a -> STT s m (STRef s a)
newSTRef init = liftST (STRef.newSTRef init)
readSTRef :: Monad m => STRef s a -> STT s m a
readSTRef ref = liftST (STRef.readSTRef ref)
writeSTRef :: Monad m => STRef s a -> a -> STT s m ()
writeSTRef ref a = liftST (STRef.writeSTRef ref a)
runST :: Monad m => (forall s. STT s m a) -> m a
runST m = let (STT f) = m
in do (STTRet st a) <- ( f realWorld# )
return a
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
newSTArray :: (Ix i, Monad m) => (i,i) -> e -> STT s m (STArray s i e)
newSTArray bounds init = liftST (newArray bounds init)
boundsSTArray :: STArray s i e -> (i,i)
boundsSTArray = STArray.boundsSTArray
numElementsSTArray :: STArray s i e -> Int
numElementsSTArray = STArray.numElementsSTArray
readSTArray :: (Ix i, Monad m) => STArray s i e -> i -> STT s m e
readSTArray arr i = liftST (readArray arr i)
unsafeReadSTArray :: (Ix i, Monad m) => STArray s i e -> Int -> STT s m e
unsafeReadSTArray arr i = liftST (STArray.unsafeReadSTArray arr i)
writeSTArray :: (Ix i, Monad m) => STArray s i e -> i -> e -> STT s m ()
writeSTArray arr i e = liftST (writeArray arr i e)
unsafeWriteSTArray :: (Ix i, Monad m) => STArray s i e -> Int -> e -> STT s m ()
unsafeWriteSTArray arr i e = liftST (STArray.unsafeWriteSTArray arr i e)
freezeSTArray :: (Ix i,Monad m) => STArray s i e -> STT s m (Array i e)
freezeSTArray arr = liftST (STArray.freezeSTArray arr)
unsafeFreezeSTArray :: (Ix i, Monad m) => STArray s i e -> STT s m (Array i e)
unsafeFreezeSTArray arr = liftST (STArray.unsafeFreezeSTArray arr)
thawSTArray :: (Ix i, Monad m) => Array i e -> STT s m (STArray s i e)
thawSTArray arr = liftST (STArray.thawSTArray arr)
unsafeThawSTArray :: (Ix i, Monad m) => Array i e -> STT s m (STArray s i e)
unsafeThawSTArray arr = liftST (STArray.unsafeThawSTArray arr)
runSTArray :: (Ix i, Monad m)
=> (forall s . STT s m (STArray s i e))
-> m (Array i e)
runSTArray st = runST (st >>= unsafeFreezeSTArray)
unsafeIOToSTT :: (Monad m) => IO a -> STT s m a
unsafeIOToSTT m = return $! unsafePerformIO m
unsafeSTToIO :: STT s IO a -> IO a
unsafeSTToIO m = runST $ unsafeCoerce m
unsafeSTRefToIORef :: STRef s a -> IORef a
unsafeSTRefToIORef ref = unsafeCoerce ref
unsafeIORefToSTRef :: IORef a -> STRef s a
unsafeIORefToSTRef ref = unsafeCoerce ref