base-4.6.0.0: Basic libraries

Portabilitynon-portable (requires universal quantification for runST)
Stabilityprovisional
Maintainer[email protected]
Safe HaskellUnsafe

Control.Monad.ST.Lazy

Contents

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.

Synopsis

The ST monad

data ST s a Source

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

Instances

Monad (ST s) 
Functor (ST s) 
Monad (ST s) => MonadFix (ST s) 
Functor (ST s) => Applicative (ST s) 

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

data RealWorld Source

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

Instances

stToIO :: ST RealWorld a -> IO aSource

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.

Unsafe Functions

unsafeInterleaveST :: ST s a -> ST s aSource

Deprecated: Please import from Control.Monad.ST.Lazy.Unsafe instead; This will be removed in the next release

unsafeIOToST :: IO a -> ST s aSource

Deprecated: Please import from Control.Monad.ST.Lazy.Unsafe instead; This will be removed in the next release