base-4.18.1.0: Basic libraries

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

Control.Monad.ST.Lazy.Safe

Contents

- The `ST` monad
- Converting between strict and lazy `ST`
- Converting `ST` To `IO`

Description

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.

Synopsis

- data ST s a
- runST :: (forall s. ST s a) -> a
- fixST :: (a -> ST s a) -> ST s a
- strictToLazyST :: ST s a -> ST s a
- lazyToStrictST :: ST s a -> ST s a
- data RealWorld
- stToIO :: ST RealWorld a -> IO a

# The `ST` monad

data ST s a Source #

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

#### Instances

Instances details

MonadFix (ST s) Source # | Since: base-2.1
Instance details Defined in Control.Monad.ST.Lazy.Imp Methods mfix :: (a -> ST s a) -> ST s a Source #
Applicative (ST s) Source # | Since: base-2.1
Instance details Defined in Control.Monad.ST.Lazy.Imp Methods pure :: a -> ST s a Source # (<*>) :: ST s (a -> b) -> ST s a -> ST s b Source # liftA2 :: (a -> b -> c) -> ST s a -> ST s b -> ST s c Source # (*>) :: ST s a -> ST s b -> ST s b Source # (<*) :: ST s a -> ST s b -> ST s a Source #
Functor (ST s) Source # | Since: base-2.1
Instance details Defined in Control.Monad.ST.Lazy.Imp Methods fmap :: (a -> b) -> ST s a -> ST s b Source # (<$) :: a -> ST s b -> ST s a Source #
Monad (ST s) Source # | Since: base-2.1
Instance details Defined in Control.Monad.ST.Lazy.Imp Methods (>>=) :: ST s a -> (a -> ST s b) -> ST s b Source # (>>) :: ST s a -> ST s b -> ST s b Source # return :: a -> ST s a Source #

runST :: (forall s. ST s a) -> a Source #

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.

fixST :: (a -> ST s a) -> ST s a Source #

Allow the result of an `ST` 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 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.

lazyToStrictST :: ST s a -> ST s a Source #

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

stToIO :: ST RealWorld a -> IO a Source #

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