Control.Monad.ST.Lazy

base-4.11.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

Contents

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

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

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

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

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

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

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

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

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 #

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 #

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