Rebase.Control.Monad.ST.Lazy

The lazy ST monad. The ST monad allows for destructive updates, but is escapable (unlike IO). A computation of type ST s a returns a value of type a, and executes in "thread" s. The s parameter is either

• an uninstantiated 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

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#.

Allow the result of an ST computation to be used (lazily) inside the computation. Note that if f is strict, fixST f = _|_.

Convert a lazy ST computation into a strict one.

Return the value computed by an ST computation. The forall ensures that the internal state used by the ST computation is inaccessible to the rest of the program.

A monad transformer embedding lazy ST 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.

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.