base-4.6.0.1: Basic libraries

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

Control.Monad.ST.Lazy

Contents

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

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

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

Monad (ST s) |
Functor (ST s) |
MonadFix (ST s) |
Applicative (ST s) |

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

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

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

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

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

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 Functions

unsafeInterleaveST :: ST s a -> ST s a

Deprecated: Please import from Control.Monad.ST.Lazy.Unsafe instead; This will be removed in the next release

unsafeIOToST :: IO a -> ST s a

Deprecated: Please import from Control.Monad.ST.Lazy.Unsafe instead; This will be removed in the next release