Copyright | (c) The University of Glasgow 2001 |
---|---|
License | BSD-style (see the file libraries/base/LICENSE) |
Maintainer | libraries@haskell.org |
Stability | provisional |
Portability | non-portable (requires universal quantification for runST) |
Safe Haskell | Trustworthy |
Language | Haskell2010 |
Deprecated: Safe is now the default, please use Control.Monad.ST.Lazy instead
This module presents an identical interface to Control.Monad.ST,
except that the monad delays evaluation of ST
operations until
a value depending on them is required.
Safe API only.
The ST
monad
The lazy
monad.
The ST monad allows for destructive updates, but is escapable (unlike ST
IO
).
A computation of type
returns a value of type ST
s aa
, and
executes in "thread" s
. The s
parameter is either
- an uninstantiated 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
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.
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#
.