1 -----------------------------------------------------------------------------
3 -- Module : Control.Monad.ST.Lazy
4 -- Copyright : (c) The University of Glasgow 2001
5 -- License : BSD-style (see the file libraries/base/LICENSE)
7 -- Maintainer : libraries@haskell.org
8 -- Stability : provisional
9 -- Portability : non-portable (requires universal quantification for runST)
11 -- This module presents an identical interface to "Control.Monad.ST",
12 -- but the underlying implementation of the state thread is /lazy/ (in
13 -- the sense that (@_|_ >> a@ is not necessarily equal to @_|_@).
15 -----------------------------------------------------------------------------
17 module Control.Monad.ST.Lazy (
23 -- * Converting between strict and lazy 'ST'
24 strictToLazyST, lazyToStrictST,
26 -- * Converting 'ST' To 'IO'
30 -- * Unsafe operations
37 import Control.Monad.Fix
39 import Control.Monad.ST (RealWorld)
40 import qualified Control.Monad.ST as ST
42 #ifdef __GLASGOW_HASKELL__
43 import qualified GHC.ST
52 #ifdef __GLASGOW_HASKELL__
53 -- | The lazy state-transformer monad.
54 -- The first parameter is used solely to keep the states of different
55 -- invocations of 'runST' separate from each other and from invocations
56 -- of 'Control.Monad.ST.stToIO'. In the first case the type parameter
57 -- is not instantiated; in the second it is 'RealWorld'.
58 newtype ST s a = ST (State s -> (a, State s))
59 data State s = S# (State# s)
61 instance Functor (ST s) where
62 fmap f m = ST $ \ s ->
69 instance Monad (ST s) where
71 return a = ST $ \ s -> (a,s)
72 m >> k = m >>= \ _ -> k
83 {-# NOINLINE runST #-}
84 -- | Return the value computed by a state transformer computation.
85 -- The @forall@ is a technical device to ensure that the state used
86 -- by the 'ST' computation is inaccessible to the rest of the program.
87 runST :: (forall s. ST s a) -> a
88 runST st = case st of ST the_st -> let (r,_) = the_st (S# realWorld#) in r
90 -- | Allow the result of a state transformer computation to be used (lazily)
91 -- inside the computation.
92 -- Note that if @f@ is strict, @'fixST' f@ will diverge.
93 fixST :: (a -> ST s a) -> ST s a
102 instance MonadFix (ST s) where
105 -- ---------------------------------------------------------------------------
108 #ifdef __GLASGOW_HASKELL__
110 Convert a strict 'ST' computation into a lazy one. The strict state
111 thread passed to 'strictToLazyST' is not performed until the result of
112 the lazy state thread it returns is demanded.
114 strictToLazyST :: ST.ST s a -> ST s a
115 strictToLazyST m = ST $ \s ->
117 pr = case s of { S# s# -> GHC.ST.liftST m s# }
118 r = case pr of { GHC.ST.STret _ v -> v }
119 s' = case pr of { GHC.ST.STret s2# _ -> S# s2# }
124 Convert a lazy 'ST' computation into a strict one.
126 lazyToStrictST :: ST s a -> ST.ST s a
127 lazyToStrictST (ST m) = GHC.ST.ST $ \s ->
128 case (m (S# s)) of (a, S# s') -> (# s', a #)
130 unsafeInterleaveST :: ST s a -> ST s a
131 unsafeInterleaveST = strictToLazyST . ST.unsafeInterleaveST . lazyToStrictST
134 unsafeIOToST :: IO a -> ST s a
135 unsafeIOToST = strictToLazyST . ST.unsafeIOToST
137 -- | A monad transformer embedding lazy state transformers in the 'IO'
138 -- monad. The 'RealWorld' parameter is a technical device to keep the
139 -- state used by such computations separate from those inside 'runST'.
140 stToIO :: ST RealWorld a -> IO a
141 stToIO = ST.stToIO . lazyToStrictST