base-4.20.2.0: Core data structures and operations

Copyright | (c) The University of Glasgow 1992-2002
License | see libraries/base/LICENSE
Maintainer | ghc-devs@haskell.org
Stability | internal
Portability | non-portable (GHC Extensions)
Safe Haskell | None
Language | Haskell2010

GHC.ST

Contents

- Unsafe functions

Description

The `ST` Monad.

Synopsis

- newtype ST s a = ST (STRep s a)
- data STret s a = STret (State# s) a
- type STRep s a = State# s -> (# State# s, a #)
- runST :: (forall s. ST s a) -> a
- liftST :: ST s a -> State# s -> STret s a
- unsafeInterleaveST :: ST s a -> ST s a
- unsafeDupableInterleaveST :: ST s a -> ST s a

# Documentation

newtype ST s a Source #

The strict `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 strict in the state (though not in values stored in the state). For example,

    runST (writeSTRef _|_ v >>= f) = _|_

Constructors

ST (STRep s a) |

#### Instances

Instances details

Applicative (ST s) | Since: base-4.4.0.0
Instance details Defined in GHC.Internal.ST 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) | Since: base-2.1
Instance details Defined in GHC.Internal.ST Methods fmap :: (a -> b) -> ST s a -> ST s b Source # (<$) :: a -> ST s b -> ST s a Source #
Monad (ST s) | Since: base-2.1
Instance details Defined in GHC.Internal.ST 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 #
MonadFix (ST s) | Since: base-2.1
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> ST s a) -> ST s a Source #
Monoid a => Monoid (ST s a) | Since: base-4.11.0.0
Instance details Defined in GHC.Internal.ST Methods mempty :: ST s a Source # mappend :: ST s a -> ST s a -> ST s a Source # mconcat :: [ST s a] -> ST s a Source #
Semigroup a => Semigroup (ST s a) | Since: base-4.11.0.0
Instance details Defined in GHC.Internal.ST Methods (<>) :: ST s a -> ST s a -> ST s a Source # sconcat :: NonEmpty (ST s a) -> ST s a Source # stimes :: Integral b => b -> ST s a -> ST s a Source #
Show (ST s a) | Since: base-2.1
Instance details Defined in GHC.Internal.ST Methods showsPrec :: Int -> ST s a -> ShowS Source # show :: ST s a -> String Source # showList :: [ST s a] -> ShowS Source #

data STret s a Source #

Constructors

STret (State# s) a |

type STRep s a = State# s -> (# State# s, a #) Source #

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

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

# Unsafe functions

liftST :: ST s a -> State# s -> STret s a Source #

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

`unsafeInterleaveST` allows an `ST` computation to be deferred lazily. When passed a value of type `ST a`, the `ST` computation will only be performed when the value of the `a` is demanded.

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

`unsafeDupableInterleaveST` allows an `ST` computation to be deferred lazily. When passed a value of type `ST a`, the `ST` computation will only be performed when the value of the `a` is demanded.

The computation may be performed multiple times by different threads, possibly at the same time. To prevent this, use `unsafeInterleaveST` instead.

Since: base-4.11