|Portability||non-portable (requires universal quantification for runST)|
|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.
|The ST monad
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
|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.
|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
|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.
|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#.
|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.
|Produced by Haddock version 2.6.0|