| base-3.0.2.0: Basic libraries | Source code | Contents | Index

Control.Monad.ST.Lazy

Portability | non-portable (requires universal quantification for runST)
Stability | provisional
Maintainer | libraries@haskell.org

Contents

The `ST` monad
Converting between strict and lazy `ST`
Converting `ST` To `IO`
Unsafe operations

Description
This module presents an identical interface to Control.Monad.ST, except that the monad delays evaluation of state operations until a value depending on them is required.
Synopsis

data ST s a
runST :: (forall s . ST s a) -> a
fixST :: (a -> ST s a) -> ST s a
strictToLazyST :: ST s a -> ST s a
lazyToStrictST :: ST s a -> ST s a
data RealWorld
stToIO :: ST RealWorld a -> IO a
unsafeInterleaveST :: ST s a -> ST s a
unsafeIOToST :: IO a -> ST s a

The `ST` monad

data ST s a | Source

The lazy state-transformer monad. A computation of type ``ST` s a` transforms an internal state indexed by `s`, and returns a value of type `a`. The `s` parameter is either

- an unstantiated type variable (inside invocations of `runST`), or
- `RealWorld` (inside invocations of `stToIO`).

It serves to keep the internal states of different invocations of `runST` separate from each other and from invocations of `stToIO`.

The `>>=` and `>>` operations are not strict in the state. For example,

    runST (writeSTRef _|_ v >>= readSTRef _|_ >> return 2) = 2

Instances

Functor (ST s)
Monad (ST s)
MonadFix (ST s)

runST :: (forall s . ST s a) -> a | Source

Return the value computed by a state transformer computation. The `forall` ensures that the internal state used by the `ST` computation is inaccessible to the rest of the program.

fixST :: (a -> ST s a) -> ST s a | Source

Allow the result of a state transformer computation to be used (lazily) inside the computation. Note that if `f` is strict, ``fixST` f = _|_`.
Converting between strict and lazy `ST`

strictToLazyST :: ST s a -> ST s a | Source

Convert a strict `ST` computation into a lazy one. The strict state thread passed to `strictToLazyST` is not performed until the result of the lazy state thread it returns is demanded.

lazyToStrictST :: ST s a -> ST s a | Source

Convert a lazy `ST` computation into a strict one.
Converting `ST` To `IO`

data RealWorld | Source

`RealWorld` is deeply magical. It is primitive, but it is not unlifted (hence `ptrArg`). We never manipulate values of type `RealWorld`; it's only used in the type system, to parameterise `State#`.
Instances

Typeable RealWorld

stToIO :: ST RealWorld a -> IO a | Source

A monad transformer embedding lazy state transformers in the `IO` monad. The `RealWorld` parameter indicates that the internal state used by the `ST` computation is a special one supplied by the `IO` monad, and thus distinct from those used by invocations of `runST`.
Unsafe operations

unsafeInterleaveST :: ST s a -> ST s a | Source

unsafeIOToST :: IO a -> ST s a | Source

Produced by Haddock version 0.9