Control.Monad.ST.Trans

STMonadTrans-0.4.3: A monad transformer version of the ST monad

Copyright | Josef Svenningsson 2008-2017 (c) The University of Glasgow, 1994-2000
License | BSD
Maintainer | josef.svenningsson@gmail.com
Stability | experimental
Portability | non-portable (GHC Extensions)
Safe Haskell | None
Language | Haskell98

Control.Monad.ST.Trans

Contents

- The ST Monad Transformer
- Mutable references
- Mutable arrays
- Unsafe Operations

Description

This library provides a monad transformer version of the ST monad.

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.

Synopsis

- data STT s m a
- runST :: Monad m => (forall s. STT s m a) -> m a
- runSTT :: Monad m => (forall s. STT s m a) -> m a
- data STRef s a :: * -> * -> *
- newSTRef :: (Applicative m, Monad m) => a -> STT s m (STRef s a)
- readSTRef :: (Applicative m, Monad m) => STRef s a -> STT s m a
- writeSTRef :: (Applicative m, Monad m) => STRef s a -> a -> STT s m ()
- data STArray s i e :: * -> * -> * -> *
- newSTArray :: (Ix i, Applicative m, Monad m) => (i, i) -> e -> STT s m (STArray s i e)
- readSTArray :: (Ix i, Applicative m, Monad m) => STArray s i e -> i -> STT s m e
- writeSTArray :: (Ix i, Applicative m, Monad m) => STArray s i e -> i -> e -> STT s m ()
- boundsSTArray :: STArray s i e -> (i, i)
- numElementsSTArray :: STArray s i e -> Int
- freezeSTArray :: (Ix i, Applicative m, Monad m) => STArray s i e -> STT s m (Array i e)
- thawSTArray :: (Ix i, Applicative m, Monad m) => Array i e -> STT s m (STArray s i e)
- runSTArray :: (Ix i, Applicative m, Monad m) => (forall s. STT s m (STArray s i e)) -> m (Array i e)
- unsafeReadSTArray :: (Ix i, Applicative m, Monad m) => STArray s i e -> Int -> STT s m e
- unsafeWriteSTArray :: (Ix i, Applicative m, Monad m) => STArray s i e -> Int -> e -> STT s m ()
- unsafeFreezeSTArray :: (Ix i, Applicative m, Monad m) => STArray s i e -> STT s m (Array i e)
- unsafeThawSTArray :: (Ix i, Applicative m, Monad m) => Array i e -> STT s m (STArray s i e)
- unsafeIOToSTT :: Monad m => IO a -> STT s m a
- unsafeSTToIO :: STT s IO a -> IO a
- unsafeSTTToIO :: STT s IO a -> IO a
- unsafeSTRefToIORef :: STRef s a -> IORef a
- unsafeIORefToSTRef :: IORef a -> STRef s a

# The ST Monad Transformer

data STT s m a #

`STT` is the monad transformer providing polymorphic updateable references

Instances

MonadError e m => MonadError e (STT s m) # |
Methods throwError :: e -> STT s m a # catchError :: STT s m a -> (e -> STT s m a) -> STT s m a #
MonadReader r m => MonadReader r (STT s m) # |
Methods ask :: STT s m r # local :: (r -> r) -> STT s m a -> STT s m a # reader :: (r -> a) -> STT s m a #
MonadState s m => MonadState s (STT s' m) # |
Methods get :: STT s' m s # put :: s -> STT s' m () # state :: (s -> (a, s)) -> STT s' m a #
MonadWriter w m => MonadWriter w (STT s m) # |
Methods writer :: (a, w) -> STT s m a # tell :: w -> STT s m () # listen :: STT s m a -> STT s m (a, w) # pass :: STT s m (a, w -> w) -> STT s m a #
MonadTrans (STT s) # |
Methods lift :: Monad m => m a -> STT s m a #
(Applicative m, Monad m) => MArray (STUArray s) Word64 (STT s m) # |
Methods getBounds :: Ix i => STUArray s i Word64 -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i Word64 -> STT s m Int newArray :: Ix i => (i, i) -> Word64 -> STT s m (STUArray s i Word64) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Word64) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Word64) unsafeRead :: Ix i => STUArray s i Word64 -> Int -> STT s m Word64 unsafeWrite :: Ix i => STUArray s i Word64 -> Int -> Word64 -> STT s m ()
(Applicative m, Monad m) => MArray (STUArray s) Word32 (STT s m) # |
Methods getBounds :: Ix i => STUArray s i Word32 -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i Word32 -> STT s m Int newArray :: Ix i => (i, i) -> Word32 -> STT s m (STUArray s i Word32) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Word32) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Word32) unsafeRead :: Ix i => STUArray s i Word32 -> Int -> STT s m Word32 unsafeWrite :: Ix i => STUArray s i Word32 -> Int -> Word32 -> STT s m ()
(Applicative m, Monad m) => MArray (STUArray s) Word16 (STT s m) # |
Methods getBounds :: Ix i => STUArray s i Word16 -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i Word16 -> STT s m Int newArray :: Ix i => (i, i) -> Word16 -> STT s m (STUArray s i Word16) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Word16) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Word16) unsafeRead :: Ix i => STUArray s i Word16 -> Int -> STT s m Word16 unsafeWrite :: Ix i => STUArray s i Word16 -> Int -> Word16 -> STT s m ()
(Applicative m, Monad m) => MArray (STUArray s) Word8 (STT s m) # |
Methods getBounds :: Ix i => STUArray s i Word8 -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i Word8 -> STT s m Int newArray :: Ix i => (i, i) -> Word8 -> STT s m (STUArray s i Word8) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Word8) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Word8) unsafeRead :: Ix i => STUArray s i Word8 -> Int -> STT s m Word8 unsafeWrite :: Ix i => STUArray s i Word8 -> Int -> Word8 -> STT s m ()
(Applicative m, Monad m) => MArray (STUArray s) Int64 (STT s m) # |
Methods getBounds :: Ix i => STUArray s i Int64 -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i Int64 -> STT s m Int newArray :: Ix i => (i, i) -> Int64 -> STT s m (STUArray s i Int64) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Int64) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Int64) unsafeRead :: Ix i => STUArray s i Int64 -> Int -> STT s m Int64 unsafeWrite :: Ix i => STUArray s i Int64 -> Int -> Int64 -> STT s m ()
(Applicative m, Monad m) => MArray (STUArray s) Int32 (STT s m) # |
Methods getBounds :: Ix i => STUArray s i Int32 -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i Int32 -> STT s m Int newArray :: Ix i => (i, i) -> Int32 -> STT s m (STUArray s i Int32) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Int32) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Int32) unsafeRead :: Ix i => STUArray s i Int32 -> Int -> STT s m Int32 unsafeWrite :: Ix i => STUArray s i Int32 -> Int -> Int32 -> STT s m ()
(Applicative m, Monad m) => MArray (STUArray s) Int16 (STT s m) # |
Methods getBounds :: Ix i => STUArray s i Int16 -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i Int16 -> STT s m Int newArray :: Ix i => (i, i) -> Int16 -> STT s m (STUArray s i Int16) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Int16) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Int16) unsafeRead :: Ix i => STUArray s i Int16 -> Int -> STT s m Int16 unsafeWrite :: Ix i => STUArray s i Int16 -> Int -> Int16 -> STT s m ()
(Applicative m, Monad m) => MArray (STUArray s) Int8 (STT s m) # |
Methods getBounds :: Ix i => STUArray s i Int8 -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i Int8 -> STT s m Int newArray :: Ix i => (i, i) -> Int8 -> STT s m (STUArray s i Int8) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Int8) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Int8) unsafeRead :: Ix i => STUArray s i Int8 -> Int -> STT s m Int8 unsafeWrite :: Ix i => STUArray s i Int8 -> Int -> Int8 -> STT s m ()
(Applicative m, Monad m) => MArray (STUArray s) Double (STT s m) # |
Methods getBounds :: Ix i => STUArray s i Double -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i Double -> STT s m Int newArray :: Ix i => (i, i) -> Double -> STT s m (STUArray s i Double) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Double) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Double) unsafeRead :: Ix i => STUArray s i Double -> Int -> STT s m Double unsafeWrite :: Ix i => STUArray s i Double -> Int -> Double -> STT s m ()
(Applicative m, Monad m) => MArray (STUArray s) Float (STT s m) # |
Methods getBounds :: Ix i => STUArray s i Float -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i Float -> STT s m Int newArray :: Ix i => (i, i) -> Float -> STT s m (STUArray s i Float) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Float) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Float) unsafeRead :: Ix i => STUArray s i Float -> Int -> STT s m Float unsafeWrite :: Ix i => STUArray s i Float -> Int -> Float -> STT s m ()
(Applicative m, Monad m) => MArray (STUArray s) Word (STT s m) # |
Methods getBounds :: Ix i => STUArray s i Word -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i Word -> STT s m Int newArray :: Ix i => (i, i) -> Word -> STT s m (STUArray s i Word) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Word) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Word) unsafeRead :: Ix i => STUArray s i Word -> Int -> STT s m Word unsafeWrite :: Ix i => STUArray s i Word -> Int -> Word -> STT s m ()
(Applicative m, Monad m) => MArray (STUArray s) Int (STT s m) # |
Methods getBounds :: Ix i => STUArray s i Int -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i Int -> STT s m Int newArray :: Ix i => (i, i) -> Int -> STT s m (STUArray s i Int) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Int) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Int) unsafeRead :: Ix i => STUArray s i Int -> Int -> STT s m Int unsafeWrite :: Ix i => STUArray s i Int -> Int -> Int -> STT s m ()
(Applicative m, Monad m) => MArray (STUArray s) Char (STT s m) # |
Methods getBounds :: Ix i => STUArray s i Char -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i Char -> STT s m Int newArray :: Ix i => (i, i) -> Char -> STT s m (STUArray s i Char) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Char) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Char) unsafeRead :: Ix i => STUArray s i Char -> Int -> STT s m Char unsafeWrite :: Ix i => STUArray s i Char -> Int -> Char -> STT s m ()
(Applicative m, Monad m) => MArray (STUArray s) Bool (STT s m) # |
Methods getBounds :: Ix i => STUArray s i Bool -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i Bool -> STT s m Int newArray :: Ix i => (i, i) -> Bool -> STT s m (STUArray s i Bool) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Bool) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i Bool) unsafeRead :: Ix i => STUArray s i Bool -> Int -> STT s m Bool unsafeWrite :: Ix i => STUArray s i Bool -> Int -> Bool -> STT s m ()
(Applicative m, Monad m) => MArray (STArray s) e (STT s m) # |
Methods getBounds :: Ix i => STArray s i e -> STT s m (i, i) # getNumElements :: Ix i => STArray s i e -> STT s m Int newArray :: Ix i => (i, i) -> e -> STT s m (STArray s i e) # newArray_ :: Ix i => (i, i) -> STT s m (STArray s i e) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STArray s i e) unsafeRead :: Ix i => STArray s i e -> Int -> STT s m e unsafeWrite :: Ix i => STArray s i e -> Int -> e -> STT s m ()
(Applicative m, Monad m) => MArray (STUArray s) (StablePtr a) (STT s m) # |
Methods getBounds :: Ix i => STUArray s i (StablePtr a) -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i (StablePtr a) -> STT s m Int newArray :: Ix i => (i, i) -> StablePtr a -> STT s m (STUArray s i (StablePtr a)) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i (StablePtr a)) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i (StablePtr a)) unsafeRead :: Ix i => STUArray s i (StablePtr a) -> Int -> STT s m (StablePtr a) unsafeWrite :: Ix i => STUArray s i (StablePtr a) -> Int -> StablePtr a -> STT s m ()
(Applicative m, Monad m) => MArray (STUArray s) (FunPtr a) (STT s m) # |
Methods getBounds :: Ix i => STUArray s i (FunPtr a) -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i (FunPtr a) -> STT s m Int newArray :: Ix i => (i, i) -> FunPtr a -> STT s m (STUArray s i (FunPtr a)) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i (FunPtr a)) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i (FunPtr a)) unsafeRead :: Ix i => STUArray s i (FunPtr a) -> Int -> STT s m (FunPtr a) unsafeWrite :: Ix i => STUArray s i (FunPtr a) -> Int -> FunPtr a -> STT s m ()
(Applicative m, Monad m) => MArray (STUArray s) (Ptr a) (STT s m) # |
Methods getBounds :: Ix i => STUArray s i (Ptr a) -> STT s m (i, i) # getNumElements :: Ix i => STUArray s i (Ptr a) -> STT s m Int newArray :: Ix i => (i, i) -> Ptr a -> STT s m (STUArray s i (Ptr a)) # newArray_ :: Ix i => (i, i) -> STT s m (STUArray s i (Ptr a)) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STUArray s i (Ptr a)) unsafeRead :: Ix i => STUArray s i (Ptr a) -> Int -> STT s m (Ptr a) unsafeWrite :: Ix i => STUArray s i (Ptr a) -> Int -> Ptr a -> STT s m ()
Monad m => Monad (STT s m) # |
Methods (>>=) :: STT s m a -> (a -> STT s m b) -> STT s m b # (>>) :: STT s m a -> STT s m b -> STT s m b # return :: a -> STT s m a # fail :: String -> STT s m a #
Functor m => Functor (STT s m) # |
Methods fmap :: (a -> b) -> STT s m a -> STT s m b # (<$) :: a -> STT s m b -> STT s m a #
MonadFix m => MonadFix (STT s m) # |
Methods mfix :: (a -> STT s m a) -> STT s m a #
(Monad m, Functor m) => Applicative (STT s m) # |
Methods pure :: a -> STT s m a # (<*>) :: STT s m (a -> b) -> STT s m a -> STT s m b # (*>) :: STT s m a -> STT s m b -> STT s m b # (<*) :: STT s m a -> STT s m b -> STT s m a #

runST :: Monad m => (forall s. STT s m a) -> m a #

Deprecated: Use runSTT instead

Executes a computation in the `STT` monad transformer

runSTT :: Monad m => (forall s. STT s m a) -> m a #

Executes a computation in the `STT` monad transformer

# Mutable references

data STRef s a :: * -> * -> * #

a value of type `STRef s a` is a mutable variable in state thread `s`, containing a value of type `a`

Instances

Eq (STRef s a) |
Methods (==) :: STRef s a -> STRef s a -> Bool # (/=) :: STRef s a -> STRef s a -> Bool #

newSTRef :: (Applicative m, Monad m) => a -> STT s m (STRef s a) #

Create a new reference

readSTRef :: (Applicative m, Monad m) => STRef s a -> STT s m a #

Reads the value of a reference

writeSTRef :: (Applicative m, Monad m) => STRef s a -> a -> STT s m () #

Modifies the value of a reference

# Mutable arrays

data STArray s i e :: * -> * -> * -> * #

Mutable, boxed, non-strict arrays in the `ST` monad. The type arguments are as follows:

- `s`: the state variable argument for the `ST` type
- `i`: the index type of the array (should be an instance of `Ix`)
- `e`: the element type of the array.

Instances

MArray (STArray s) e (ST s) |
Methods getBounds :: Ix i => STArray s i e -> ST s (i, i) # getNumElements :: Ix i => STArray s i e -> ST s Int newArray :: Ix i => (i, i) -> e -> ST s (STArray s i e) # newArray_ :: Ix i => (i, i) -> ST s (STArray s i e) # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STArray s i e) unsafeRead :: Ix i => STArray s i e -> Int -> ST s e unsafeWrite :: Ix i => STArray s i e -> Int -> e -> ST s ()
MArray (STArray s) e (ST s) |
Methods getBounds :: Ix i => STArray s i e -> ST s (i, i) # getNumElements :: Ix i => STArray s i e -> ST s Int newArray :: Ix i => (i, i) -> e -> ST s (STArray s i e) # newArray_ :: Ix i => (i, i) -> ST s (STArray s i e) # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STArray s i e) unsafeRead :: Ix i => STArray s i e -> Int -> ST s e unsafeWrite :: Ix i => STArray s i e -> Int -> e -> ST s ()
(Applicative m, Monad m) => MArray (STArray s) e (STT s m) # |
Methods getBounds :: Ix i => STArray s i e -> STT s m (i, i) # getNumElements :: Ix i => STArray s i e -> STT s m Int newArray :: Ix i => (i, i) -> e -> STT s m (STArray s i e) # newArray_ :: Ix i => (i, i) -> STT s m (STArray s i e) # unsafeNewArray_ :: Ix i => (i, i) -> STT s m (STArray s i e) unsafeRead :: Ix i => STArray s i e -> Int -> STT s m e unsafeWrite :: Ix i => STArray s i e -> Int -> e -> STT s m ()
Eq (STArray s i e) |
Methods (==) :: STArray s i e -> STArray s i e -> Bool # (/=) :: STArray s i e -> STArray s i e -> Bool #

newSTArray :: (Ix i, Applicative m, Monad m) => (i, i) -> e -> STT s m (STArray s i e) #

Creates a new mutable array

readSTArray :: (Ix i, Applicative m, Monad m) => STArray s i e -> i -> STT s m e #

Retrieves an element from the array

writeSTArray :: (Ix i, Applicative m, Monad m) => STArray s i e -> i -> e -> STT s m () #

Modifies an element in the array

boundsSTArray :: STArray s i e -> (i, i) #

Returns the lowest and highest indices of the array

numElementsSTArray :: STArray s i e -> Int #

Returns the number of elements in the array

freezeSTArray :: (Ix i, Applicative m, Monad m) => STArray s i e -> STT s m (Array i e) #

Copy a mutable array and turn it into an immutable array

thawSTArray :: (Ix i, Applicative m, Monad m) => Array i e -> STT s m (STArray s i e) #

Copy an immutable array and turn it into a mutable array

runSTArray :: (Ix i, Applicative m, Monad m) => (forall s. STT s m (STArray s i e)) -> m (Array i e) #

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.

# Unsafe Operations

unsafeReadSTArray :: (Ix i, Applicative m, Monad m) => STArray s i e -> Int -> STT s m e #

unsafeWriteSTArray :: (Ix i, Applicative m, Monad m) => STArray s i e -> Int -> e -> STT s m () #

unsafeFreezeSTArray :: (Ix i, Applicative m, Monad m) => STArray s i e -> STT s m (Array i e) #

unsafeThawSTArray :: (Ix i, Applicative m, Monad m) => Array i e -> STT s m (STArray s i e) #

unsafeIOToSTT :: Monad m => IO a -> STT s m a #

unsafeSTToIO :: STT s IO a -> IO a #

Deprecated: Use unsafeSTTToIO instead

unsafeSTTToIO :: STT s IO a -> IO a #

unsafeSTRefToIORef :: STRef s a -> IORef a #

unsafeIORefToSTRef :: IORef a -> STRef s a #