W3cubDocs

/Haskell 8

Control.Monad.ST.Lazy.Safe

Copyright (c) The University of Glasgow 2001
License BSD-style (see the file libraries/base/LICENSE)
Maintainer [email protected]
Stability provisional
Portability non-portable (requires universal quantification for runST)
Safe Haskell Trustworthy
Language Haskell2010

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.

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

(>>) :: ST s a -> ST s b -> ST s b Source

return :: a -> ST s a Source

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 Source

(<$) :: a -> ST s b -> ST s a Source

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 Source

MonadFail (ST s)

Since: base-4.10

Instance details

Defined in Control.Monad.ST.Lazy.Imp

Methods

fail :: String -> ST s a Source

Applicative (ST s)

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

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.

© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/8.8.3/docs/html/libraries/base-4.13.0.0/Control-Monad-ST-Lazy-Safe.html