Portability | non-portable (requires universal quantification for runST) |
---|---|
Stability | provisional |
Maintainer | libraries@haskell.org |
Safe Haskell | Trustworthy |
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
The lazy state-transformer monad.
A computation of type
transforms an internal state indexed
by 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) = 2
runST :: (forall s. ST s a) -> aSource
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 aSource
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 aSource
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 aSource
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#
.