From 19de173b1bd4fa8cf1854cfefa619565910137f3 Mon Sep 17 00:00:00 2001
From: ross <unknown>
Date: Sun, 17 Oct 2004 00:09:59 +0000
Subject: [PATCH] [project @ 2004-10-17 00:09:58 by ross] move some
 GHC-specific implementations into GHC.*

---
 Control/Exception.hs |   23 ++---------------------
 Control/Monad/ST.hs  |   12 +++---------
 GHC/Exception.lhs    |   16 +++++++++++++++-
 GHC/IOBase.lhs       |    6 ++++++
 4 files changed, 26 insertions(+), 31 deletions(-)

diff --git a/Control/Exception.hs b/Control/Exception.hs
index 20105e8..aed144b 100644
--- a/Control/Exception.hs
+++ b/Control/Exception.hs
@@ -116,9 +116,9 @@ module Control.Exception (
 import GHC.Base		( assert )
 import GHC.Exception 	as ExceptionBase hiding (catch)
 import GHC.Conc		( throwTo, ThreadId )
-import GHC.IOBase	( IO(..), IORef(..), newIORef, readIORef, writeIORef )
-import GHC.Handle       ( stdout, hFlush )
+import Data.IORef	( IORef, newIORef, readIORef, writeIORef )
 import Foreign.C.String ( CString, withCStringLen )
+import System.IO	( stdout, hFlush )
 #endif
 
 #ifdef __HUGS__
@@ -220,25 +220,6 @@ handleJust :: (Exception -> Maybe b) -> (b -> IO a) -> IO a -> IO a
 handleJust p =  flip (catchJust p)
 
 -----------------------------------------------------------------------------
--- evaluate
-
--- | Forces its argument to be evaluated, and returns the result in
--- the 'IO' monad.  It can be used to order evaluation with respect to
--- other 'IO' operations; its semantics are given by
---
--- >   evaluate undefined `seq` return ()  ==> return ()
--- >   catch (evaluate undefined) (\e -> return ())  ==> return ()
---
--- NOTE: @(evaluate a)@ is /not/ the same as @(a \`seq\` return a)@.
-#ifdef __GLASGOW_HASKELL__
-evaluate :: a -> IO a
-evaluate a = IO $ \s -> case a `seq` () of () -> (# s, a #)
-	-- NB. can't write  
-	-- 	a `seq` (# s, a #)
-	-- because we can't have an unboxed tuple as a function argument
-#endif
-
------------------------------------------------------------------------------
 -- 'mapException'
 
 -- | This function maps one exception into another as proposed in the
diff --git a/Control/Monad/ST.hs b/Control/Monad/ST.hs
index 5ea1052..be57243 100644
--- a/Control/Monad/ST.hs
+++ b/Control/Monad/ST.hs
@@ -50,15 +50,9 @@ unsafeInterleaveST =
 #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
+import GHC.ST		( ST, runST, fixST, unsafeInterleaveST )
+import GHC.Base		( RealWorld )
+import GHC.IOBase 	( stToIO, unsafeIOToST )
 #endif
 
 instance MonadFix (ST s) where
diff --git a/GHC/Exception.lhs b/GHC/Exception.lhs
index 08f5e97..04f732a 100644
--- a/GHC/Exception.lhs
+++ b/GHC/Exception.lhs
@@ -100,4 +100,18 @@ block (IO io) = IO $ blockAsyncExceptions# io
 unblock (IO io) = IO $ unblockAsyncExceptions# io
 \end{code}
 
-
+\begin{code}
+-- | Forces its argument to be evaluated, and returns the result in
+-- the 'IO' monad.  It can be used to order evaluation with respect to
+-- other 'IO' operations; its semantics are given by
+--
+-- >   evaluate undefined `seq` return ()  ==> return ()
+-- >   catch (evaluate undefined) (\e -> return ())  ==> return ()
+--
+-- NOTE: @(evaluate a)@ is /not/ the same as @(a \`seq\` return a)@.
+evaluate :: a -> IO a
+evaluate a = IO $ \s -> case a `seq` () of () -> (# s, a #)
+        -- NB. can't write  
+        --      a `seq` (# s, a #)
+        -- because we can't have an unboxed tuple as a function argument
+\end{code}
diff --git a/GHC/IOBase.lhs b/GHC/IOBase.lhs
index 6fa596a..07273f9 100644
--- a/GHC/IOBase.lhs
+++ b/GHC/IOBase.lhs
@@ -122,6 +122,12 @@ stToIO (ST m) = IO m
 ioToST	      :: IO a -> ST RealWorld a
 ioToST (IO m) = (ST m)
 
+-- 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
+
 -- ---------------------------------------------------------------------------
 -- Unsafe IO operations
 
-- 
1.7.10.4