File: ST.hs

package info (click to toggle)
ghc-cvs 20040725-2
  • links: PTS
  • area: main
  • in suites: sarge
  • size: 68,484 kB
  • ctags: 19,658
  • sloc: haskell: 251,945; ansic: 109,709; asm: 24,961; sh: 12,825; perl: 5,786; makefile: 5,334; xml: 3,884; python: 682; yacc: 650; lisp: 477; cpp: 337; ml: 76; fortran: 24; csh: 18
file content (70 lines) | stat: -rw-r--r-- 1,975 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
-----------------------------------------------------------------------------
-- |
-- Module      :  Control.Monad.ST
-- Copyright   :  (c) The University of Glasgow 2001
-- License     :  BSD-style (see the file libraries/base/LICENSE)
-- 
-- Maintainer  :  libraries@haskell.org
-- Stability   :  experimental
-- Portability :  non-portable (requires universal quantification for runST)
--
-- This library provides support for /strict/ state threads, as
-- described in the PLDI \'94 paper by John Launchbury and Simon Peyton
-- Jones /Lazy State Threads/.
--
-----------------------------------------------------------------------------

module Control.Monad.ST
  (
	-- * The 'ST' Monad
	ST,		-- abstract, instance of Functor, Monad, Typeable.
	runST,		-- :: (forall s. ST s a) -> a
	fixST,		-- :: (a -> ST s a) -> ST s a

	-- * Converting 'ST' to 'IO'
	RealWorld,		-- abstract
	stToIO,			-- :: ST RealWorld a -> IO a

	-- * Unsafe operations
	unsafeInterleaveST,  	-- :: ST s a -> ST s a
	unsafeIOToST		-- :: IO a -> ST s a
      ) where

import Prelude

import Control.Monad.Fix
import Data.Typeable

#include "Typeable.h"

#ifdef __HUGS__
import Hugs.ST
import qualified Hugs.LazyST as LazyST

fixST :: (a -> ST s a) -> ST s a
fixST f = LazyST.lazyToStrictST (LazyST.fixST (LazyST.strictToLazyST . f))

unsafeInterleaveST :: ST s a -> ST s a
unsafeInterleaveST =
    LazyST.lazyToStrictST . LazyST.unsafeInterleaveST . LazyST.strictToLazyST
#endif

#ifdef __GLASGOW_HASKELL__
import GHC.ST
import GHC.Base		( unsafeCoerce#, RealWorld )
import GHC.IOBase 	( IO(..), stToIO )

-- This relies on IO and ST having the same representation modulo the
-- constraint on the type of the state
--
unsafeIOToST        :: IO a -> ST s a
unsafeIOToST (IO io) = ST $ \ s -> (unsafeCoerce# io) s
#endif

instance MonadFix (ST s) where
	mfix = fixST

-- ---------------------------------------------------------------------------
-- Typeable instance

INSTANCE_TYPEABLE2(ST,sTTc,"ST")