| Portability | non-portable (requires universal quantification for runST) | 
|---|---|
| Stability | provisional | 
| Maintainer | libraries@haskell.org | 
| Safe Haskell | Trustworthy | 
Control.Monad.ST.Lazy.Safe
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.
Safe API only.
The ST monad
data ST s a
The lazy state-transformer monad.
 A computation of type ST s as, and returns a value of type a.
 The s parameter is either
-  an unstantiated type variable (inside invocations of runST), or
-  RealWorld(inside invocations ofstToIO).
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) = 2runST :: (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
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#.