SafeHaskell: Added SafeHaskell to base
authorDavid Terei <davidterei@gmail.com>
Mon, 16 May 2011 21:57:46 +0000 (14:57 -0700)
committerDavid Terei <davidterei@gmail.com>
Sat, 18 Jun 2011 08:06:34 +0000 (01:06 -0700)
168 files changed:
Control/Applicative.hs
Control/Arrow.hs
Control/Category.hs
Control/Concurrent.hs
Control/Concurrent/Chan.hs
Control/Concurrent/MVar.hs
Control/Concurrent/QSem.hs
Control/Concurrent/QSemN.hs
Control/Concurrent/SampleVar.hs
Control/Exception.hs
Control/Exception/Base.hs
Control/Monad.hs
Control/Monad/Fix.hs
Control/Monad/Group.hs
Control/Monad/Instances.hs
Control/Monad/ST.hs
Control/Monad/ST/Imp.hs [new file with mode: 0644]
Control/Monad/ST/Lazy.hs
Control/Monad/ST/Lazy/Imp.hs [new file with mode: 0644]
Control/Monad/ST/Lazy/Safe.hs [new file with mode: 0644]
Control/Monad/ST/Lazy/Unsafe.hs [new file with mode: 0644]
Control/Monad/ST/Safe.hs [new file with mode: 0644]
Control/Monad/ST/Strict.hs
Control/Monad/ST/Unsafe.hs [new file with mode: 0644]
Control/Monad/Zip.hs
Control/OldException.hs
Data/Bits.hs
Data/Bool.hs
Data/Char.hs
Data/Complex.hs
Data/Either.hs
Data/Eq.hs
Data/Fixed.hs
Data/Foldable.hs
Data/Function.hs
Data/Functor.hs
Data/HashTable.hs
Data/IORef.hs
Data/Int.hs
Data/Ix.hs
Data/List.hs
Data/Maybe.hs
Data/Monoid.hs
Data/Ord.hs
Data/Ratio.hs
Data/STRef.hs
Data/STRef/Lazy.hs
Data/STRef/Strict.hs
Data/String.hs
Data/Traversable.hs
Data/Tuple.hs
Data/Typeable.hs
Data/Unique.hs
Data/Version.hs
Data/Word.hs
Foreign.hs
Foreign/C.hs
Foreign/C/Error.hs
Foreign/C/String.hs
Foreign/C/Types.hs
Foreign/Concurrent.hs
Foreign/ForeignPtr.hs
Foreign/ForeignPtr/Imp.hs [new file with mode: 0644]
Foreign/ForeignPtr/Safe.hs [new file with mode: 0644]
Foreign/ForeignPtr/Unsafe.hs [new file with mode: 0644]
Foreign/Marshal.hs
Foreign/Marshal/Alloc.hs
Foreign/Marshal/Array.hs
Foreign/Marshal/Error.hs
Foreign/Marshal/Pool.hs
Foreign/Marshal/Safe.hs [new file with mode: 0644]
Foreign/Marshal/Unsafe.hs [new file with mode: 0644]
Foreign/Marshal/Utils.hs
Foreign/Ptr.hs
Foreign/Safe.hs [new file with mode: 0644]
Foreign/StablePtr.hs
Foreign/Storable.hs
GHC/Arr.lhs
GHC/Base.lhs
GHC/Classes.hs
GHC/Conc/Signal.hs
GHC/ConsoleHandler.hs
GHC/Constants.hs
GHC/Desugar.hs
GHC/Enum.lhs
GHC/Environment.hs
GHC/Err.lhs
GHC/Err.lhs-boot
GHC/Event.hs
GHC/Exception.lhs
GHC/Exts.hs
GHC/Float.lhs
GHC/Float/ConversionUtils.hs
GHC/Float/RealFracMethods.hs
GHC/Foreign.hs
GHC/Handle.hs
GHC/IO.hs
GHC/IO/Buffer.hs
GHC/IO/BufferedIO.hs
GHC/IO/Device.hs
GHC/IO/Encoding.hs
GHC/IO/Encoding.hs-boot
GHC/IO/Encoding/CodePage.hs
GHC/IO/Encoding/Failure.hs
GHC/IO/Encoding/Iconv.hs
GHC/IO/Encoding/Latin1.hs
GHC/IO/Encoding/Types.hs
GHC/IO/Encoding/UTF16.hs
GHC/IO/Encoding/UTF32.hs
GHC/IO/Encoding/UTF8.hs
GHC/IO/Exception.hs
GHC/IO/Exception.hs-boot
GHC/IO/FD.hs
GHC/IO/Handle.hs
GHC/IO/Handle.hs-boot
GHC/IO/Handle/FD.hs
GHC/IO/Handle/FD.hs-boot
GHC/IO/Handle/Internals.hs
GHC/IO/Handle/Text.hs
GHC/IO/Handle/Types.hs
GHC/IO/IOMode.hs
GHC/IOArray.hs
GHC/IORef.hs
GHC/Int.hs
GHC/List.lhs
GHC/MVar.hs
GHC/Num.lhs
GHC/PArr.hs
GHC/Ptr.lhs
GHC/Read.lhs
GHC/Real.lhs
GHC/ST.lhs
GHC/STRef.lhs
GHC/Show.lhs
GHC/Show.lhs-boot
GHC/Stable.lhs
GHC/Storable.lhs
GHC/TopHandler.lhs
GHC/Unicode.hs
GHC/Unicode.hs-boot
GHC/Weak.lhs
GHC/Windows.hs
GHC/Word.hs
Numeric.hs
Prelude.hs
System/CPUTime.hsc
System/Console/GetOpt.hs
System/Environment.hs
System/Exit.hs
System/IO.hs
System/IO/Error.hs
System/IO/Unsafe.hs
System/Info.hs
System/Mem.hs
System/Mem/StableName.hs
System/Mem/Weak.hs
System/Posix/Internals.hs
System/Posix/Internals.hs-boot
System/Posix/Types.hs
System/Timeout.hs
Text/ParserCombinators/ReadP.hs
Text/ParserCombinators/ReadPrec.hs
Text/Printf.hs
Text/Read.hs
Text/Read/Lex.hs
Text/Show.hs
Text/Show/Functions.hs
base.cabal

index 6ef8bba..248bbac 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
@@ -51,8 +52,8 @@ import Control.Arrow (Arrow(arr, (&&&)), ArrowZero(zeroArrow), ArrowPlus((<+>)))
 import Control.Monad (liftM, ap, MonadPlus(..))
 import Control.Monad.Instances ()
 #ifndef __NHC__
-import Control.Monad.ST (ST)
-import qualified Control.Monad.ST.Lazy as Lazy (ST)
+import Control.Monad.ST.Safe (ST)
+import qualified Control.Monad.ST.Lazy.Safe as Lazy (ST)
 #endif
 import Data.Functor ((<$>), (<$))
 import Data.Monoid (Monoid(..))
index 20e3677..012a75a 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Arrow
index b63fc67..b06155f 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
index 62a30b4..04e0a8f 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP
            , ForeignFunctionInterface
            , MagicHash
index d6be913..23b21bb 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 #ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
index 2fda9f7..c407306 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index 6b9a059..5ed887d 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 #ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
index 43fe288..7e2cb2c 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 #ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
index 615a0bf..a621193 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 #ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
index c650682..a13b990 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, ExistentialQuantification #-}
 
 -----------------------------------------------------------------------------
index a617917..8a0f7b0 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, MagicHash #-}
 #ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
@@ -400,7 +401,7 @@ catch   :: Exception e
         -> (e -> IO a)  -- ^ Handler to invoke if an exception is raised
         -> IO a
 #if __GLASGOW_HASKELL__
-catch = GHC.IO.catchException
+catch = catchException
 #elif __HUGS__
 catch m h = Hugs.Exception.catchException m h'
   where h' e = case fromException e of
index 75b9d0b..21f0153 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index a1309fa..b1fe43d 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
index baab7da..3516562 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Monad.Group
index d41be4f..0cc1c53 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Safe #-}
 {-# OPTIONS_NHC98 --prelude #-}
 -- This module deliberately declares orphan instances:
 {-# OPTIONS_GHC -fno-warn-orphans #-}
index 397b072..0508b6e 100644 (file)
@@ -1,11 +1,14 @@
-{-# LANGUAGE CPP #-}
+{-# LANGUAGE CPP, SafeImports #-}
+#if sh_SAFE_DEFAULT
+{-# LANGUAGE Safe #-}
+#endif
 
 -----------------------------------------------------------------------------
 -- |
 -- 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)
 --
 -----------------------------------------------------------------------------
 
-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
-        unsafeSTToIO            -- :: ST s a -> IO a
-      ) where
-
-#if defined(__GLASGOW_HASKELL__)
-import Control.Monad.Fix ()
-#else
-import Control.Monad.Fix
+module Control.Monad.ST (
+          module Control.Monad.ST.Safe
+#if !sh_SAFE_DEFAULT
+        -- * Unsafe Functions
+        , unsafeInterleaveST
+        , unsafeIOToST
+        , unsafeSTToIO
 #endif
+    ) where
 
-#include "Typeable.h"
+import safe Control.Monad.ST.Safe
 
-#if defined(__GLASGOW_HASKELL__)
-import GHC.ST           ( ST, runST, fixST, unsafeInterleaveST )
-import GHC.Base         ( RealWorld )
-import GHC.IO           ( stToIO, unsafeIOToST, unsafeSTToIO )
-#elif defined(__HUGS__)
-import Data.Typeable
-import Hugs.ST
-import qualified Hugs.LazyST as LazyST
-#endif
-
-#if defined(__HUGS__)
-INSTANCE_TYPEABLE2(ST,sTTc,"ST")
-INSTANCE_TYPEABLE0(RealWorld,realWorldTc,"RealWorld")
+#if !sh_SAFE_DEFAULT
+import qualified Control.Monad.ST.Unsafe as U
 
-fixST :: (a -> ST s a) -> ST s a
-fixST f = LazyST.lazyToStrictST (LazyST.fixST (LazyST.strictToLazyST . f))
+{-# DEPRECATED unsafeInterleaveST, unsafeIOToST, unsafeSTToIO
+              "Please import from Control.Monad.ST.Unsafe instead; This will be removed in the next release"
+ #-}
 
+{-# INLINE unsafeInterleaveST #-}
 unsafeInterleaveST :: ST s a -> ST s a
-unsafeInterleaveST =
-    LazyST.lazyToStrictST . LazyST.unsafeInterleaveST . LazyST.strictToLazyST
-#endif
+unsafeInterleaveST = U.unsafeInterleaveST
+
+{-# INLINE unsafeIOToST #-}
+unsafeIOToST :: IO a -> ST s a
+unsafeIOToST = U.unsafeIOToST
 
-#if !defined(__GLASGOW_HASKELL__)
-instance MonadFix (ST s) where
-        mfix = fixST
+{-# INLINE unsafeSTToIO #-}
+unsafeSTToIO :: ST s a -> IO a
+unsafeSTToIO = U.unsafeSTToIO
 #endif
 
diff --git a/Control/Monad/ST/Imp.hs b/Control/Monad/ST/Imp.hs
new file mode 100644 (file)
index 0000000..ca768b4
--- /dev/null
@@ -0,0 +1,72 @@
+{-# LANGUAGE CPP #-}
+{-# OPTIONS_HADDOCK hide #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Monad.ST.Imp
+-- 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 Functional State Threads/.
+--
+-----------------------------------------------------------------------------
+
+-- #hide
+module Control.Monad.ST.Imp (
+        -- * 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
+        unsafeSTToIO            -- :: ST s a -> IO a
+    ) where
+
+#if defined(__GLASGOW_HASKELL__)
+import Control.Monad.Fix ()
+#else
+import Control.Monad.Fix
+#endif
+
+#include "Typeable.h"
+
+#if defined(__GLASGOW_HASKELL__)
+import GHC.ST           ( ST, runST, fixST, unsafeInterleaveST )
+import GHC.Base         ( RealWorld )
+import GHC.IO           ( stToIO, unsafeIOToST, unsafeSTToIO )
+#elif defined(__HUGS__)
+import Data.Typeable
+import Hugs.ST
+import qualified Hugs.LazyST as LazyST
+#endif
+
+#if defined(__HUGS__)
+INSTANCE_TYPEABLE2(ST,sTTc,"ST")
+INSTANCE_TYPEABLE0(RealWorld,realWorldTc,"RealWorld")
+
+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
+
+#if !defined(__GLASGOW_HASKELL__)
+instance MonadFix (ST s) where
+        mfix = fixST
+#endif
+
+
index 8aac665..d1ec5b9 100644 (file)
@@ -1,4 +1,7 @@
-{-# LANGUAGE CPP, MagicHash, UnboxedTuples, Rank2Types #-}
+{-# LANGUAGE CPP, SafeImports #-}
+#if sh_SAFE_DEFAULT
+{-# LANGUAGE Safe #-}
+#endif
 
 -----------------------------------------------------------------------------
 -- |
 -----------------------------------------------------------------------------
 
 module Control.Monad.ST.Lazy (
-        -- * The 'ST' monad
-        ST,
-        runST,
-        fixST,
-
-        -- * Converting between strict and lazy 'ST'
-        strictToLazyST, lazyToStrictST,
-
-        -- * Converting 'ST' To 'IO'
-        RealWorld,
-        stToIO,
-
-        -- * Unsafe operations
-        unsafeInterleaveST,
-        unsafeIOToST
-    ) where
-
-import Prelude
-
-import Control.Monad.Fix
-
-import qualified Control.Monad.ST as ST
-
-#ifdef __GLASGOW_HASKELL__
-import qualified GHC.ST
-import GHC.Base
-#endif
-
-#ifdef __HUGS__
-import Hugs.LazyST
+          module Control.Monad.ST.Lazy.Safe
+#if !sh_SAFE_DEFAULT
+        -- * Unsafe Functions
+        , unsafeInterleaveST
+        , unsafeIOToST
 #endif
+    ) where
 
-#ifdef __GLASGOW_HASKELL__
--- | The lazy state-transformer monad.
--- A computation of type @'ST' s a@ transforms an internal state indexed
--- by @s@, and returns a value of type @a@.
--- The @s@ parameter is either
---
--- * an unstantiated 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@
-newtype ST s a = ST (State s -> (a, State s))
-data State s = S# (State# s)
-
-instance Functor (ST s) where
-    fmap f m = ST $ \ s ->
-      let 
-       ST m_a = m
-       (r,new_s) = m_a s
-      in
-      (f r,new_s)
-
-instance Monad (ST s) where
-
-        return a = ST $ \ s -> (a,s)
-        m >> k   =  m >>= \ _ -> k
-        fail s   = error s
-
-        (ST m) >>= k
-         = ST $ \ s ->
-           let
-             (r,new_s) = m s
-             ST k_a = k r
-           in
-           k_a new_s
-
-{-# NOINLINE runST #-}
--- | Return the value computed by a state transformer computation.
--- The @forall@ ensures that the internal state used by the 'ST'
--- computation is inaccessible to the rest of the program.
-runST :: (forall s. ST s a) -> a
-runST st = case st of ST the_st -> let (r,_) = the_st (S# realWorld#) in r
-
--- | Allow the result of a state transformer computation to be used (lazily)
--- inside the computation.
--- Note that if @f@ is strict, @'fixST' f = _|_@.
-fixST :: (a -> ST s a) -> ST s a
-fixST m = ST (\ s -> 
-                let 
-                   ST m_r = m r
-                   (r,s') = m_r s
-                in
-                   (r,s'))
-#endif
-
-instance MonadFix (ST s) where
-        mfix = fixST
-
--- ---------------------------------------------------------------------------
--- Strict <--> Lazy
-
-#ifdef __GLASGOW_HASKELL__
-{-|
-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.
--}
-strictToLazyST :: ST.ST s a -> ST s a
-strictToLazyST m = ST $ \s ->
-        let 
-           pr = case s of { S# s# -> GHC.ST.liftST m s# }
-           r  = case pr of { GHC.ST.STret _ v -> v }
-           s' = case pr of { GHC.ST.STret s2# _ -> S# s2# }
-        in
-        (r, s')
+import safe Control.Monad.ST.Lazy.Safe
+#if !sh_SAFE_DEFAULT
+import qualified Control.Monad.ST.Lazy.Unsafe as U
 
-{-| 
-Convert a lazy 'ST' computation into a strict one.
--}
-lazyToStrictST :: ST s a -> ST.ST s a
-lazyToStrictST (ST m) = GHC.ST.ST $ \s ->
-        case (m (S# s)) of (a, S# s') -> (# s', a #)
+{-# DEPRECATED unsafeInterleaveST, unsafeIOToST
+              "Please import from Control.Monad.ST.Lazy.Unsafe instead; This will be removed in the next release"
+ #-}
 
+{-# INLINE unsafeInterleaveST #-}
 unsafeInterleaveST :: ST s a -> ST s a
-unsafeInterleaveST = strictToLazyST . ST.unsafeInterleaveST . lazyToStrictST
-#endif
+unsafeInterleaveST = U.unsafeInterleaveST
 
+{-# INLINE unsafeIOToST #-}
 unsafeIOToST :: IO a -> ST s a
-unsafeIOToST = strictToLazyST . ST.unsafeIOToST
+unsafeIOToST = U.unsafeIOToST
+#endif
 
--- | A monad transformer embedding lazy state transformers 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'.
-stToIO :: ST RealWorld a -> IO a
-stToIO = ST.stToIO . lazyToStrictST
diff --git a/Control/Monad/ST/Lazy/Imp.hs b/Control/Monad/ST/Lazy/Imp.hs
new file mode 100644 (file)
index 0000000..82c4974
--- /dev/null
@@ -0,0 +1,162 @@
+{-# LANGUAGE CPP, MagicHash, UnboxedTuples, Rank2Types #-}
+{-# OPTIONS_HADDOCK hide #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Monad.ST.Lazy.Imp
+-- Copyright   :  (c) The University of Glasgow 2001
+-- License     :  BSD-style (see the file libraries/base/LICENSE)
+-- 
+-- Maintainer  :  libraries@haskell.org
+-- Stability   :  provisional
+-- Portability :  non-portable (requires universal quantification for runST)
+--
+-- This module presents an identical interface to "Control.Monad.ST",
+-- except that the monad delays evaluation of state operations until
+-- a value depending on them is required.
+--
+-----------------------------------------------------------------------------
+
+-- #hide
+module Control.Monad.ST.Lazy.Imp (
+        -- * The 'ST' monad
+        ST,
+        runST,
+        fixST,
+
+        -- * Converting between strict and lazy 'ST'
+        strictToLazyST, lazyToStrictST,
+
+        -- * Converting 'ST' To 'IO'
+        RealWorld,
+        stToIO,
+
+        -- * Unsafe operations
+        unsafeInterleaveST,
+        unsafeIOToST
+    ) where
+
+import Prelude
+
+import Control.Monad.Fix
+
+import qualified Control.Monad.ST.Safe as ST
+import qualified Control.Monad.ST.Unsafe as ST
+
+#ifdef __GLASGOW_HASKELL__
+import qualified GHC.ST as GHC.ST
+import GHC.Base
+#endif
+
+#ifdef __HUGS__
+import Hugs.LazyST
+#endif
+
+#ifdef __GLASGOW_HASKELL__
+-- | The lazy state-transformer monad.
+-- A computation of type @'ST' s a@ transforms an internal state indexed
+-- by @s@, and returns a value of type @a@.
+-- The @s@ parameter is either
+--
+-- * an unstantiated 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@
+newtype ST s a = ST (State s -> (a, State s))
+data State s = S# (State# s)
+
+instance Functor (ST s) where
+    fmap f m = ST $ \ s ->
+      let 
+       ST m_a = m
+       (r,new_s) = m_a s
+      in
+      (f r,new_s)
+
+instance Monad (ST s) where
+
+        return a = ST $ \ s -> (a,s)
+        m >> k   =  m >>= \ _ -> k
+        fail s   = error s
+
+        (ST m) >>= k
+         = ST $ \ s ->
+           let
+             (r,new_s) = m s
+             ST k_a = k r
+           in
+           k_a new_s
+
+{-# NOINLINE runST #-}
+-- | Return the value computed by a state transformer computation.
+-- The @forall@ ensures that the internal state used by the 'ST'
+-- computation is inaccessible to the rest of the program.
+runST :: (forall s. ST s a) -> a
+runST st = case st of ST the_st -> let (r,_) = the_st (S# realWorld#) in r
+
+-- | Allow the result of a state transformer computation to be used (lazily)
+-- inside the computation.
+-- Note that if @f@ is strict, @'fixST' f = _|_@.
+fixST :: (a -> ST s a) -> ST s a
+fixST m = ST (\ s -> 
+                let 
+                   ST m_r = m r
+                   (r,s') = m_r s
+                in
+                   (r,s'))
+#endif
+
+instance MonadFix (ST s) where
+        mfix = fixST
+
+-- ---------------------------------------------------------------------------
+-- Strict <--> Lazy
+
+#ifdef __GLASGOW_HASKELL__
+{-|
+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.
+-}
+strictToLazyST :: ST.ST s a -> ST s a
+strictToLazyST m = ST $ \s ->
+        let 
+           pr = case s of { S# s# -> GHC.ST.liftST m s# }
+           r  = case pr of { GHC.ST.STret _ v -> v }
+           s' = case pr of { GHC.ST.STret s2# _ -> S# s2# }
+        in
+        (r, s')
+
+{-| 
+Convert a lazy 'ST' computation into a strict one.
+-}
+lazyToStrictST :: ST s a -> ST.ST s a
+lazyToStrictST (ST m) = GHC.ST.ST $ \s ->
+        case (m (S# s)) of (a, S# s') -> (# s', a #)
+#endif
+
+-- | A monad transformer embedding lazy state transformers 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'.
+stToIO :: ST RealWorld a -> IO a
+stToIO = ST.stToIO . lazyToStrictST
+
+-- ---------------------------------------------------------------------------
+-- Strict <--> Lazy
+
+#ifdef __GLASGOW_HASKELL__
+unsafeInterleaveST :: ST s a -> ST s a
+unsafeInterleaveST = strictToLazyST . ST.unsafeInterleaveST . lazyToStrictST
+#endif
+
+unsafeIOToST :: IO a -> ST s a
+unsafeIOToST = strictToLazyST . ST.unsafeIOToST
+
+
diff --git a/Control/Monad/ST/Lazy/Safe.hs b/Control/Monad/ST/Lazy/Safe.hs
new file mode 100644 (file)
index 0000000..387313f
--- /dev/null
@@ -0,0 +1,36 @@
+{-# LANGUAGE Trustworthy #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Monad.ST.Lazy.Safe
+-- Copyright   :  (c) The University of Glasgow 2001
+-- License     :  BSD-style (see the file libraries/base/LICENSE)
+--
+-- Maintainer  :  libraries@haskell.org
+-- Stability   :  provisional
+-- Portability :  non-portable (requires universal quantification for runST)
+--
+-- This module presents an identical interface to "Control.Monad.ST",
+-- except that the monad delays evaluation of state operations until
+-- a value depending on them is required.
+--
+-- Safe API only.
+--
+-----------------------------------------------------------------------------
+
+module Control.Monad.ST.Lazy.Safe (
+        -- * The 'ST' monad
+        ST,
+        runST,
+        fixST,
+
+        -- * Converting between strict and lazy 'ST'
+        strictToLazyST, lazyToStrictST,
+
+        -- * Converting 'ST' To 'IO'
+        RealWorld,
+        stToIO,
+    ) where
+
+import Control.Monad.ST.Lazy.Imp
+
diff --git a/Control/Monad/ST/Lazy/Unsafe.hs b/Control/Monad/ST/Lazy/Unsafe.hs
new file mode 100644 (file)
index 0000000..1ccdbbf
--- /dev/null
@@ -0,0 +1,26 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Monad.ST.Lazy.Unsafe
+-- Copyright   :  (c) The University of Glasgow 2001
+-- License     :  BSD-style (see the file libraries/base/LICENSE)
+--
+-- Maintainer  :  libraries@haskell.org
+-- Stability   :  provisional
+-- Portability :  non-portable (requires universal quantification for runST)
+--
+-- This module presents an identical interface to "Control.Monad.ST",
+-- except that the monad delays evaluation of state operations until
+-- a value depending on them is required.
+--
+-- Unsafe API.
+--
+-----------------------------------------------------------------------------
+
+module Control.Monad.ST.Lazy.Unsafe (
+        -- * Unsafe operations
+        unsafeInterleaveST,
+        unsafeIOToST
+    ) where
+
+import Control.Monad.ST.Lazy.Imp
+
diff --git a/Control/Monad/ST/Safe.hs b/Control/Monad/ST/Safe.hs
new file mode 100644 (file)
index 0000000..e6c8e8c
--- /dev/null
@@ -0,0 +1,33 @@
+{-# LANGUAGE Trustworthy #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Monad.ST.Safe
+-- 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 Functional State Threads/.
+--
+-- Safe API Only.
+--
+-----------------------------------------------------------------------------
+
+module Control.Monad.ST.Safe (
+        -- * 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
+    ) where
+
+import Control.Monad.ST.Imp
+
index d8692f8..1b63034 100644 (file)
@@ -1,9 +1,13 @@
+{-# LANGUAGE CPP #-}
+#if sh_SAFE_DEFAULT
+{-# LANGUAGE Safe #-}
+#endif
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Monad.ST.Strict
 -- Copyright   :  (c) The University of Glasgow 2001
 -- License     :  BSD-style (see the file libraries/base/LICENSE)
--- 
+--
 -- Maintainer  :  libraries@haskell.org
 -- Stability   :  provisional
 -- Portability :  non-portable (requires universal quantification for runST)
@@ -16,4 +20,9 @@ module Control.Monad.ST.Strict (
         module Control.Monad.ST
   ) where
 
+#if sh_SAFE_DEFAULT
+import safe Control.Monad.ST
+#else
 import Control.Monad.ST
+#endif
+
diff --git a/Control/Monad/ST/Unsafe.hs b/Control/Monad/ST/Unsafe.hs
new file mode 100644 (file)
index 0000000..1a224d0
--- /dev/null
@@ -0,0 +1,27 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Monad.ST.Unsafe
+-- 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 Functional State Threads/.
+--
+-- Unsafe API.
+--
+-----------------------------------------------------------------------------
+
+module Control.Monad.ST.Unsafe (
+        -- * Unsafe operations
+        unsafeInterleaveST,
+        unsafeIOToST,
+        unsafeSTToIO
+    ) where
+
+import Control.Monad.ST.Imp
+
index d6475b8..8c431bd 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Safe #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Monad.Zip
index 6442d67..0b4d751 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP
            , NoImplicitPrelude
            , ForeignFunctionInterface
index cbf7b37..35006f4 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, BangPatterns, MagicHash #-}
 
 -----------------------------------------------------------------------------
index ba2d8ae..8d80ec8 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index 40052a7..f45f369 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index 3692501..b456055 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, DeriveDataTypeable #-}
 #ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE StandaloneDeriving #-}
index 6ffc607..cdfa761 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 #ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, DeriveGeneric, StandaloneDeriving #-}
index e7b99f1..9386d60 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index cd44092..b1d7113 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 {-# OPTIONS -Wall -fno-warn-unused-binds #-}
 
index 354bd8b..a925fca 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
index 64ebfd0..ef6d9cf 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Safe #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Function
index 84d0aa7..2369cdb 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
index e96160a..9fe7899 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 {-# OPTIONS_GHC -funbox-strict-fields -fno-warn-name-shadowing #-}
 
index 934f1de..13eb9c9 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, MagicHash, UnboxedTuples #-}
 
 -----------------------------------------------------------------------------
@@ -40,7 +41,6 @@ import Hugs.IORef
 #ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.STRef
--- import GHC.IO
 import GHC.IORef hiding (atomicModifyIORef)
 import qualified GHC.IORef
 #if !defined(__PARALLEL_HASKELL__)
index c9c9036..1ff37bd 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index a01e516..f1edf00 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
index bb71da5..4f76c83 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, MagicHash #-}
 
 -----------------------------------------------------------------------------
index 2f98c70..a405bb4 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, DeriveGeneric #-}
 
 -----------------------------------------------------------------------------
index aaefd42..beac4f7 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index fd291ae..250e797 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index f044099..766fe41 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Safe #-}
 {-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
index 5002ee7..851a20f 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
index 288343e..ccc1905 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Safe #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.STRef.Lazy
@@ -20,7 +21,7 @@ module Data.STRef.Lazy (
         modifySTRef     -- :: STRef s a -> (a -> a) -> ST s ()
  ) where
 
-import Control.Monad.ST.Lazy
+import Control.Monad.ST.Lazy.Safe
 import qualified Data.STRef as ST
 import Prelude
 
index 9eb54a5..202df73 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Safe #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.STRef.Strict
index ac1e416..27d61d5 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, FlexibleInstances #-}
 
 -----------------------------------------------------------------------------
index 062d1a0..96ea010 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
index a5ea875..5b5d32f 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 {-# OPTIONS_GHC -fno-warn-unused-imports #-}
 -- XXX -fno-warn-unused-imports needed for the GHC.Tuple import below. Sigh.
index ce602e4..8180790 100644 (file)
@@ -106,7 +106,7 @@ import GHC.Err          (undefined)
 import GHC.Num          (Integer, (+))
 import GHC.Real         ( rem, Ratio )
 import GHC.IORef        (IORef,newIORef)
-import GHC.IO           (unsafePerformIO,mask_)
+import GHC.IO           (mask_, unsafePerformIO)
 
 -- These imports are so we can define Typeable instances
 -- It'd be better to give Typeable instances in the modules themselves
index c4c8827..50bc40f 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 
 #ifdef __GLASGOW_HASKELL__
index 7d7d329..b0dd92e 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, DeriveDataTypeable #-}
 
 -----------------------------------------------------------------------------
index 18300d2..1540999 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Safe #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index a26ffaf..e6280b6 100644 (file)
@@ -1,3 +1,6 @@
+#if sh_SAFE_DEFAULT
+{-# LANGUAGE Trustworthy #-}
+#endif
 {-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
@@ -25,11 +28,15 @@ module Foreign
         , module Foreign.Storable
         , module Foreign.Marshal
 
+#if !sh_SAFE_DEFAULT
+        -- * Unsafe Functions
+
         -- | 'unsafePerformIO' is exported here for backwards
         -- compatibility reasons only.  For doing local marshalling in
         -- the FFI, use 'unsafeLocalState'.  For other uses, see
         -- 'System.IO.Unsafe.unsafePerformIO'.
         , unsafePerformIO
+#endif
         ) where
 
 import Data.Bits
@@ -41,4 +48,14 @@ import Foreign.StablePtr
 import Foreign.Storable
 import Foreign.Marshal
 
-import System.IO.Unsafe (unsafePerformIO)
+#if !sh_SAFE_DEFAULT
+import GHC.IO (IO)
+import qualified System.IO.Unsafe (unsafePerformIO)
+
+{-# DEPRECATED unsafePerformIO "Use System.IO.Unsafe.unsafePerformIO instead; This function will be removed in the next release" #-}
+
+{-# INLINE unsafePerformIO #-}
+unsafePerformIO :: IO a -> a
+unsafePerformIO = System.IO.Unsafe.unsafePerformIO
+#endif
+
index 2c7fd2e..2e925cc 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Safe #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index 89c736d..6d3ef80 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, ForeignFunctionInterface #-}
 {-# OPTIONS_GHC -#include "HsBase.h" #-}
 
index fdefdc6..f369916 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index 14b53df..c571049 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP
            , NoImplicitPrelude
            , MagicHash
index e0f2faa..6a21b79 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
@@ -29,13 +30,11 @@ module Foreign.Concurrent
   ) where
 
 #ifdef __GLASGOW_HASKELL__
-import GHC.IO           ( IO )
-import GHC.Ptr          ( Ptr )
-import GHC.ForeignPtr   ( ForeignPtr )
+import GHC.IO         ( IO )
+import GHC.Ptr        ( Ptr )
+import GHC.ForeignPtr ( ForeignPtr )
 import qualified GHC.ForeignPtr
-#endif
 
-#ifdef __GLASGOW_HASKELL__
 newForeignPtr :: Ptr a -> IO () -> IO (ForeignPtr a)
 -- ^Turns a plain memory reference into a foreign object by associating
 -- a finalizer - given by the monadic operation - with the reference.
@@ -52,3 +51,4 @@ addForeignPtrFinalizer :: ForeignPtr a -> IO () -> IO ()
 -- same object.
 addForeignPtrFinalizer = GHC.ForeignPtr.addForeignPtrConcFinalizer
 #endif
+
index b91ffeb..0199fe7 100644 (file)
@@ -1,4 +1,8 @@
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE SafeImports, CPP, NoImplicitPrelude #-}
+#if sh_SAFE_DEFAULT
+{-# LANGUAGE Trustworthy #-}
+#endif
+{-# OPTIONS_HADDOCK hide #-}
 
 -----------------------------------------------------------------------------
 -- |
 --
 -----------------------------------------------------------------------------
 
-module Foreign.ForeignPtr
-        ( 
-        -- * Finalised data pointers
-          ForeignPtr
-        , FinalizerPtr
-#if defined(__HUGS__) || defined(__GLASGOW_HASKELL__)
-        , FinalizerEnvPtr
-#endif
-        -- ** Basic operations
-        , newForeignPtr
-        , newForeignPtr_
-        , addForeignPtrFinalizer
-#if defined(__HUGS__) || defined(__GLASGOW_HASKELL__)
-        , newForeignPtrEnv
-        , addForeignPtrFinalizerEnv
-#endif
-        , withForeignPtr
-
-#ifdef __GLASGOW_HASKELL__
-        , finalizeForeignPtr
-#endif
-
-        -- ** Low-level operations
+module Foreign.ForeignPtr ( 
+          module Foreign.ForeignPtr.Safe
+#if !sh_SAFE_DEFAULT
+        -- ** Unsafe low-level operations
         , unsafeForeignPtrToPtr
-        , touchForeignPtr
-        , castForeignPtr
-
-        -- ** Allocating managed memory
-        , mallocForeignPtr
-        , mallocForeignPtrBytes
-        , mallocForeignPtrArray
-        , mallocForeignPtrArray0
-        ) 
-        where
-
-import Foreign.Ptr
-
-#ifdef __NHC__
-import NHC.FFI
-  ( ForeignPtr
-  , FinalizerPtr
-  , newForeignPtr
-  , newForeignPtr_
-  , addForeignPtrFinalizer
-  , withForeignPtr
-  , unsafeForeignPtrToPtr
-  , touchForeignPtr
-  , castForeignPtr
-  , Storable(sizeOf)
-  , malloc, mallocBytes, finalizerFree
-  )
-#endif
-
-#ifdef __HUGS__
-import Hugs.ForeignPtr
-#endif
-
-#ifndef __NHC__
-import Foreign.Storable ( Storable(sizeOf) )
-#endif
-
-#ifdef __GLASGOW_HASKELL__
-import GHC.Base
--- import GHC.IO
-import GHC.Num
-import GHC.Err          ( undefined )
-import GHC.ForeignPtr
 #endif
+    ) where
 
-#if !defined(__NHC__) && !defined(__GLASGOW_HASKELL__)
-import Foreign.Marshal.Alloc    ( malloc, mallocBytes, finalizerFree )
+import safe Foreign.ForeignPtr.Safe
 
-instance Eq (ForeignPtr a) where 
-    p == q  =  unsafeForeignPtrToPtr p == unsafeForeignPtrToPtr q
+#if !sh_SAFE_DEFAULT
+import Foreign.Ptr ( Ptr )
+import qualified Foreign.ForeignPtr.Unsafe as U
 
-instance Ord (ForeignPtr a) where 
-    compare p q  =  compare (unsafeForeignPtrToPtr p) (unsafeForeignPtrToPtr q)
-
-instance Show (ForeignPtr a) where
-    showsPrec p f = showsPrec p (unsafeForeignPtrToPtr f)
+{-# DEPRECATED unsafeForeignPtrToPtr "Use Foreign.ForeignPtr.Unsafe.unsafeForeignPtrToPtr instead; This function will be removed in the next release" #-}
+{-# INLINE unsafeForeignPtrToPtr #-}
+unsafeForeignPtrToPtr :: ForeignPtr a -> Ptr a
+unsafeForeignPtrToPtr = U.unsafeForeignPtrToPtr
 #endif
 
-
-#ifndef __NHC__
-newForeignPtr :: FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
--- ^Turns a plain memory reference into a foreign pointer, and
--- associates a finalizer with the reference.  The finalizer will be
--- executed after the last reference to the foreign object is dropped.
--- There is no guarantee of promptness, however the finalizer will be
--- executed before the program exits.
-newForeignPtr finalizer p
-  = do fObj <- newForeignPtr_ p
-       addForeignPtrFinalizer finalizer fObj
-       return fObj
-
-withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b
--- ^This is a way to look at the pointer living inside a
--- foreign object.  This function takes a function which is
--- applied to that pointer. The resulting 'IO' action is then
--- executed. The foreign object is kept alive at least during
--- the whole action, even if it is not used directly
--- inside. Note that it is not safe to return the pointer from
--- the action and use it after the action completes. All uses
--- of the pointer should be inside the
--- 'withForeignPtr' bracket.  The reason for
--- this unsafeness is the same as for
--- 'unsafeForeignPtrToPtr' below: the finalizer
--- may run earlier than expected, because the compiler can only
--- track usage of the 'ForeignPtr' object, not
--- a 'Ptr' object made from it.
---
--- This function is normally used for marshalling data to
--- or from the object pointed to by the
--- 'ForeignPtr', using the operations from the
--- 'Storable' class.
-withForeignPtr fo io
-  = do r <- io (unsafeForeignPtrToPtr fo)
-       touchForeignPtr fo
-       return r
-#endif /* ! __NHC__ */
-
-#if defined(__HUGS__) || defined(__GLASGOW_HASKELL__)
--- | This variant of 'newForeignPtr' adds a finalizer that expects an
--- environment in addition to the finalized pointer.  The environment
--- that will be passed to the finalizer is fixed by the second argument to
--- 'newForeignPtrEnv'.
-newForeignPtrEnv ::
-    FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO (ForeignPtr a)
-newForeignPtrEnv finalizer env p
-  = do fObj <- newForeignPtr_ p
-       addForeignPtrFinalizerEnv finalizer env fObj
-       return fObj
-#endif /* __HUGS__ */
-
-#ifndef __GLASGOW_HASKELL__
-mallocForeignPtr :: Storable a => IO (ForeignPtr a)
-mallocForeignPtr = do
-  r <- malloc
-  newForeignPtr finalizerFree r
-
-mallocForeignPtrBytes :: Int -> IO (ForeignPtr a)
-mallocForeignPtrBytes n = do
-  r <- mallocBytes n
-  newForeignPtr finalizerFree r
-#endif /* !__GLASGOW_HASKELL__ */
-
--- | This function is similar to 'Foreign.Marshal.Array.mallocArray',
--- but yields a memory area that has a finalizer attached that releases
--- the memory area.  As with 'mallocForeignPtr', it is not guaranteed that
--- the block of memory was allocated by 'Foreign.Marshal.Alloc.malloc'.
-mallocForeignPtrArray :: Storable a => Int -> IO (ForeignPtr a)
-mallocForeignPtrArray  = doMalloc undefined
-  where
-    doMalloc            :: Storable b => b -> Int -> IO (ForeignPtr b)
-    doMalloc dummy size  = mallocForeignPtrBytes (size * sizeOf dummy)
-
--- | This function is similar to 'Foreign.Marshal.Array.mallocArray0',
--- but yields a memory area that has a finalizer attached that releases
--- the memory area.  As with 'mallocForeignPtr', it is not guaranteed that
--- the block of memory was allocated by 'Foreign.Marshal.Alloc.malloc'.
-mallocForeignPtrArray0      :: Storable a => Int -> IO (ForeignPtr a)
-mallocForeignPtrArray0 size  = mallocForeignPtrArray (size + 1)
diff --git a/Foreign/ForeignPtr/Imp.hs b/Foreign/ForeignPtr/Imp.hs
new file mode 100644 (file)
index 0000000..6ce615f
--- /dev/null
@@ -0,0 +1,180 @@
+{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# OPTIONS_HADDOCK hide #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Foreign.ForeignPtr.Imp
+-- Copyright   :  (c) The University of Glasgow 2001
+-- License     :  BSD-style (see the file libraries/base/LICENSE)
+-- 
+-- Maintainer  :  ffi@haskell.org
+-- Stability   :  provisional
+-- Portability :  portable
+--
+-- The 'ForeignPtr' type and operations.  This module is part of the
+-- Foreign Function Interface (FFI) and will usually be imported via
+-- the "Foreign" module.
+--
+-----------------------------------------------------------------------------
+
+module Foreign.ForeignPtr.Imp
+        ( 
+        -- * Finalised data pointers
+          ForeignPtr
+        , FinalizerPtr
+#if defined(__HUGS__) || defined(__GLASGOW_HASKELL__)
+        , FinalizerEnvPtr
+#endif
+        -- ** Basic operations
+        , newForeignPtr
+        , newForeignPtr_
+        , addForeignPtrFinalizer
+#if defined(__HUGS__) || defined(__GLASGOW_HASKELL__)
+        , newForeignPtrEnv
+        , addForeignPtrFinalizerEnv
+#endif
+        , withForeignPtr
+
+#ifdef __GLASGOW_HASKELL__
+        , finalizeForeignPtr
+#endif
+
+        -- ** Low-level operations
+        , unsafeForeignPtrToPtr
+        , touchForeignPtr
+        , castForeignPtr
+
+        -- ** Allocating managed memory
+        , mallocForeignPtr
+        , mallocForeignPtrBytes
+        , mallocForeignPtrArray
+        , mallocForeignPtrArray0
+        ) 
+        where
+
+import Foreign.Ptr
+
+#ifdef __NHC__
+import NHC.FFI
+  ( ForeignPtr
+  , FinalizerPtr
+  , newForeignPtr
+  , newForeignPtr_
+  , addForeignPtrFinalizer
+  , withForeignPtr
+  , unsafeForeignPtrToPtr
+  , touchForeignPtr
+  , castForeignPtr
+  , Storable(sizeOf)
+  , malloc, mallocBytes, finalizerFree
+  )
+#endif
+
+#ifdef __HUGS__
+import Hugs.ForeignPtr
+#endif
+
+#ifndef __NHC__
+import Foreign.Storable ( Storable(sizeOf) )
+#endif
+
+#ifdef __GLASGOW_HASKELL__
+import GHC.Base
+import GHC.Num
+import GHC.Err          ( undefined )
+import GHC.ForeignPtr
+#endif
+
+#if !defined(__NHC__) && !defined(__GLASGOW_HASKELL__)
+import Foreign.Marshal.Alloc    ( malloc, mallocBytes, finalizerFree )
+
+instance Eq (ForeignPtr a) where 
+    p == q  =  unsafeForeignPtrToPtr p == unsafeForeignPtrToPtr q
+
+instance Ord (ForeignPtr a) where 
+    compare p q  =  compare (unsafeForeignPtrToPtr p) (unsafeForeignPtrToPtr q)
+
+instance Show (ForeignPtr a) where
+    showsPrec p f = showsPrec p (unsafeForeignPtrToPtr f)
+#endif
+
+
+#ifndef __NHC__
+newForeignPtr :: FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
+-- ^Turns a plain memory reference into a foreign pointer, and
+-- associates a finalizer with the reference.  The finalizer will be
+-- executed after the last reference to the foreign object is dropped.
+-- There is no guarantee of promptness, however the finalizer will be
+-- executed before the program exits.
+newForeignPtr finalizer p
+  = do fObj <- newForeignPtr_ p
+       addForeignPtrFinalizer finalizer fObj
+       return fObj
+
+withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b
+-- ^This is a way to look at the pointer living inside a
+-- foreign object.  This function takes a function which is
+-- applied to that pointer. The resulting 'IO' action is then
+-- executed. The foreign object is kept alive at least during
+-- the whole action, even if it is not used directly
+-- inside. Note that it is not safe to return the pointer from
+-- the action and use it after the action completes. All uses
+-- of the pointer should be inside the
+-- 'withForeignPtr' bracket.  The reason for
+-- this unsafeness is the same as for
+-- 'unsafeForeignPtrToPtr' below: the finalizer
+-- may run earlier than expected, because the compiler can only
+-- track usage of the 'ForeignPtr' object, not
+-- a 'Ptr' object made from it.
+--
+-- This function is normally used for marshalling data to
+-- or from the object pointed to by the
+-- 'ForeignPtr', using the operations from the
+-- 'Storable' class.
+withForeignPtr fo io
+  = do r <- io (unsafeForeignPtrToPtr fo)
+       touchForeignPtr fo
+       return r
+#endif /* ! __NHC__ */
+
+#if defined(__HUGS__) || defined(__GLASGOW_HASKELL__)
+-- | This variant of 'newForeignPtr' adds a finalizer that expects an
+-- environment in addition to the finalized pointer.  The environment
+-- that will be passed to the finalizer is fixed by the second argument to
+-- 'newForeignPtrEnv'.
+newForeignPtrEnv ::
+    FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO (ForeignPtr a)
+newForeignPtrEnv finalizer env p
+  = do fObj <- newForeignPtr_ p
+       addForeignPtrFinalizerEnv finalizer env fObj
+       return fObj
+#endif /* __HUGS__ */
+
+#ifndef __GLASGOW_HASKELL__
+mallocForeignPtr :: Storable a => IO (ForeignPtr a)
+mallocForeignPtr = do
+  r <- malloc
+  newForeignPtr finalizerFree r
+
+mallocForeignPtrBytes :: Int -> IO (ForeignPtr a)
+mallocForeignPtrBytes n = do
+  r <- mallocBytes n
+  newForeignPtr finalizerFree r
+#endif /* !__GLASGOW_HASKELL__ */
+
+-- | This function is similar to 'Foreign.Marshal.Array.mallocArray',
+-- but yields a memory area that has a finalizer attached that releases
+-- the memory area.  As with 'mallocForeignPtr', it is not guaranteed that
+-- the block of memory was allocated by 'Foreign.Marshal.Alloc.malloc'.
+mallocForeignPtrArray :: Storable a => Int -> IO (ForeignPtr a)
+mallocForeignPtrArray  = doMalloc undefined
+  where
+    doMalloc            :: Storable b => b -> Int -> IO (ForeignPtr b)
+    doMalloc dummy size  = mallocForeignPtrBytes (size * sizeOf dummy)
+
+-- | This function is similar to 'Foreign.Marshal.Array.mallocArray0',
+-- but yields a memory area that has a finalizer attached that releases
+-- the memory area.  As with 'mallocForeignPtr', it is not guaranteed that
+-- the block of memory was allocated by 'Foreign.Marshal.Alloc.malloc'.
+mallocForeignPtrArray0      :: Storable a => Int -> IO (ForeignPtr a)
+mallocForeignPtrArray0 size  = mallocForeignPtrArray (size + 1)
diff --git a/Foreign/ForeignPtr/Safe.hs b/Foreign/ForeignPtr/Safe.hs
new file mode 100644 (file)
index 0000000..4f19072
--- /dev/null
@@ -0,0 +1,55 @@
+{-# LANGUAGE Trustworthy #-}
+{-# LANGUAGE CPP, NoImplicitPrelude #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Foreign.ForeignPtr.Safe
+-- Copyright   :  (c) The University of Glasgow 2001
+-- License     :  BSD-style (see the file libraries/base/LICENSE)
+-- 
+-- Maintainer  :  ffi@haskell.org
+-- Stability   :  provisional
+-- Portability :  portable
+--
+-- The 'ForeignPtr' type and operations.  This module is part of the
+-- Foreign Function Interface (FFI) and will usually be imported via
+-- the "Foreign" module.
+--
+-- Safe API Only.
+--
+-----------------------------------------------------------------------------
+
+module Foreign.ForeignPtr.Safe (
+        -- * Finalised data pointers
+          ForeignPtr
+        , FinalizerPtr
+#if defined(__HUGS__) || defined(__GLASGOW_HASKELL__)
+        , FinalizerEnvPtr
+#endif
+        -- ** Basic operations
+        , newForeignPtr
+        , newForeignPtr_
+        , addForeignPtrFinalizer
+#if defined(__HUGS__) || defined(__GLASGOW_HASKELL__)
+        , newForeignPtrEnv
+        , addForeignPtrFinalizerEnv
+#endif
+        , withForeignPtr
+
+#ifdef __GLASGOW_HASKELL__
+        , finalizeForeignPtr
+#endif
+
+        -- ** Low-level operations
+        , touchForeignPtr
+        , castForeignPtr
+
+        -- ** Allocating managed memory
+        , mallocForeignPtr
+        , mallocForeignPtrBytes
+        , mallocForeignPtrArray
+        , mallocForeignPtrArray0
+    ) where
+
+import Foreign.ForeignPtr.Imp
+
diff --git a/Foreign/ForeignPtr/Unsafe.hs b/Foreign/ForeignPtr/Unsafe.hs
new file mode 100644 (file)
index 0000000..8980ab9
--- /dev/null
@@ -0,0 +1,28 @@
+{-# LANGUAGE Trustworthy #-}
+{-# LANGUAGE CPP, NoImplicitPrelude #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Foreign.ForeignPtr.Unsafe
+-- Copyright   :  (c) The University of Glasgow 2001
+-- License     :  BSD-style (see the file libraries/base/LICENSE)
+-- 
+-- Maintainer  :  ffi@haskell.org
+-- Stability   :  provisional
+-- Portability :  portable
+--
+-- The 'ForeignPtr' type and operations.  This module is part of the
+-- Foreign Function Interface (FFI) and will usually be imported via
+-- the "Foreign" module.
+--
+-- Unsafe API Only.
+--
+-----------------------------------------------------------------------------
+
+module Foreign.ForeignPtr.Unsafe (
+        -- ** Unsafe low-level operations
+        unsafeForeignPtrToPtr,
+    ) where
+
+import Foreign.ForeignPtr.Imp
+
index 77a4ebf..438dc2f 100644 (file)
@@ -57,5 +57,9 @@ results in undefined behaviour.
 It is expected that this operation will be
 replaced in a future revision of Haskell.
 -}
+{-# DEPRECATED unsafeLocalState
+               "Please import from Foreign.Marshall.Unsafe instead; This will be removed in the next release"
+ #-}
 unsafeLocalState :: IO a -> a
 unsafeLocalState = unsafePerformIO
+
index 612d2c7..74db164 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP
            , NoImplicitPrelude
            , MagicHash
index 1ca3e9e..e284ec4 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, MagicHash #-}
 
 -----------------------------------------------------------------------------
index ccf514d..9e3ad3b 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
@@ -38,7 +39,6 @@ import System.IO.Error
 #endif
 import GHC.Base
 import GHC.Num
--- import GHC.IO
 import GHC.IO.Exception
 #endif
 
index ed94e46..8ca160d 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 --------------------------------------------------------------------------------
diff --git a/Foreign/Marshal/Safe.hs b/Foreign/Marshal/Safe.hs
new file mode 100644 (file)
index 0000000..7313217
--- /dev/null
@@ -0,0 +1,36 @@
+{-# LANGUAGE Safe #-}
+{-# LANGUAGE CPP, NoImplicitPrelude #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Foreign.Marshal.Safe
+-- Copyright   :  (c) The FFI task force 2003
+-- License     :  BSD-style (see the file libraries/base/LICENSE)
+-- 
+-- Maintainer  :  ffi@haskell.org
+-- Stability   :  provisional
+-- Portability :  portable
+--
+-- Marshalling support
+--
+-- Safe API Only.
+--
+-----------------------------------------------------------------------------
+
+module Foreign.Marshal.Safe
+        (
+         -- | The module "Foreign.Marshal.Safe" re-exports the other modules in the
+         -- @Foreign.Marshal@ hierarchy:
+          module Foreign.Marshal.Alloc
+        , module Foreign.Marshal.Array
+        , module Foreign.Marshal.Error
+        , module Foreign.Marshal.Pool
+        , module Foreign.Marshal.Utils
+        ) where
+
+import Foreign.Marshal.Alloc
+import Foreign.Marshal.Array
+import Foreign.Marshal.Error
+import Foreign.Marshal.Pool
+import Foreign.Marshal.Utils
+
diff --git a/Foreign/Marshal/Unsafe.hs b/Foreign/Marshal/Unsafe.hs
new file mode 100644 (file)
index 0000000..1fa0e3a
--- /dev/null
@@ -0,0 +1,49 @@
+{-# LANGUAGE Trustworthy #-}
+{-# LANGUAGE CPP, NoImplicitPrelude #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Foreign.Marshal.Unsafe
+-- Copyright   :  (c) The FFI task force 2003
+-- License     :  BSD-style (see the file libraries/base/LICENSE)
+-- 
+-- Maintainer  :  ffi@haskell.org
+-- Stability   :  provisional
+-- Portability :  portable
+--
+-- Marshalling support. Unsafe API.
+--
+-----------------------------------------------------------------------------
+
+module Foreign.Marshal.Unsafe (
+        -- * Unsafe functions
+        unsafeLocalState
+    ) where
+
+#ifdef __GLASGOW_HASKELL__
+import GHC.IO
+#else
+import System.IO.Unsafe
+#endif
+
+{- |
+Sometimes an external entity is a pure function, except that it passes
+arguments and/or results via pointers.  The function
+@unsafeLocalState@ permits the packaging of such entities as pure
+functions.  
+
+The only IO operations allowed in the IO action passed to
+@unsafeLocalState@ are (a) local allocation (@alloca@, @allocaBytes@
+and derived operations such as @withArray@ and @withCString@), and (b)
+pointer operations (@Foreign.Storable@ and @Foreign.Ptr@) on the
+pointers to local storage, and (c) foreign functions whose only
+observable effect is to read and/or write the locally allocated
+memory.  Passing an IO operation that does not obey these rules
+results in undefined behaviour.
+
+It is expected that this operation will be
+replaced in a future revision of Haskell.
+-}
+unsafeLocalState :: IO a -> a
+unsafeLocalState = unsafePerformIO
+
index bf9bdb3..d3ab1fd 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, ForeignFunctionInterface #-}
 
 -----------------------------------------------------------------------------
index 26dda5c..d6588f5 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP
            , NoImplicitPrelude
            , ForeignFunctionInterface
@@ -67,7 +68,6 @@ import GHC.Show
 import GHC.Enum
 import GHC.Word         ( Word(..) )
 
--- import Data.Int
 import Data.Word
 #else
 import Control.Monad    ( liftM )
diff --git a/Foreign/Safe.hs b/Foreign/Safe.hs
new file mode 100644 (file)
index 0000000..9809aff
--- /dev/null
@@ -0,0 +1,40 @@
+{-# LANGUAGE Safe #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Foreign.Safe
+-- Copyright   :  (c) The FFI task force 2001
+-- License     :  BSD-style (see the file libraries/base/LICENSE)
+-- 
+-- Maintainer  :  ffi@haskell.org
+-- Stability   :  provisional
+-- Portability :  portable
+--
+-- A collection of data types, classes, and functions for interfacing
+-- with another programming language.
+--
+-- Safe API Only.
+--
+-----------------------------------------------------------------------------
+
+module Foreign.Safe
+        ( module Data.Bits
+        , module Data.Int
+        , module Data.Word
+        , module Foreign.Ptr
+        , module Foreign.ForeignPtr.Safe
+        , module Foreign.StablePtr
+        , module Foreign.Storable
+        , module Foreign.Marshal.Safe
+        ) where
+
+import Data.Bits
+import Data.Int
+import Data.Word
+import Foreign.Ptr
+import Foreign.ForeignPtr.Safe
+import Foreign.StablePtr
+import Foreign.Storable
+import Foreign.Marshal.Safe
+
index 522c6fc..68b2056 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index 700a4ff..482b5d9 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, ScopedTypeVariables #-}
 
 -----------------------------------------------------------------------------
index ade0b98..9ef2090 100644 (file)
 -----------------------------------------------------------------------------
 
 -- #hide
-module GHC.Arr where
+module GHC.Arr (
+        Ix(..), Array(..), STArray(..),
+
+        indexError, hopelessIndexError,
+        arrEleBottom, array, listArray,
+        (!), safeRangeSize, negRange, safeIndex, badSafeIndex,
+        bounds, numElements, numElementsSTArray, indices, elems,
+        assocs, accumArray, adjust, (//), accum,
+        amap, ixmap,
+        eqArray, cmpArray, cmpIntArray,
+        newSTArray, boundsSTArray,
+        readSTArray, writeSTArray,
+        freezeSTArray, thawSTArray,
+
+        -- * Unsafe operations
+        fill, done,
+        unsafeArray, unsafeArray',
+        lessSafeIndex, unsafeAt, unsafeReplace,
+        unsafeAccumArray, unsafeAccumArray', unsafeAccum,
+        unsafeReadSTArray, unsafeWriteSTArray,
+        unsafeFreezeSTArray, unsafeThawSTArray,
+    ) where
 
 import GHC.Enum
 import GHC.Num
@@ -351,8 +372,6 @@ instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5) => Ix (a1,a2,a3,a4,a5)  where
 %*********************************************************
 
 \begin{code}
-type IPr = (Int, Int)
-
 -- | The type of immutable non-strict (boxed) arrays
 -- with indices in @i@ and elements in @e@.
 data Array i e
index 5075478..f4181eb 100644 (file)
@@ -98,7 +98,7 @@ module GHC.Base
         module GHC.Base,
         module GHC.Classes,
         module GHC.CString,
-        --module GHC.Generics,        -- JPM: We no longer export GHC.Generics
+        -- module GHC.Generics,        -- JPM: We no longer export GHC.Generics
                                       -- by default to avoid name clashes
         module GHC.Ordering,
         module GHC.Types,
@@ -111,7 +111,7 @@ import GHC.Types
 import GHC.Classes
 import GHC.CString
 -- JPM: Since we don't export it, we don't need to import GHC.Generics
---import GHC.Generics
+-- import GHC.Generics
 import GHC.Ordering
 import GHC.Prim
 import {-# SOURCE #-} GHC.Show
@@ -613,7 +613,7 @@ instance  Monad IO  where
     m >> k    = m >>= \ _ -> k
     return    = returnIO
     (>>=)     = bindIO
-    fail s    = GHC.IO.failIO s
+    fail s    = failIO s
 
 returnIO :: a -> IO a
 returnIO x = IO $ \ s -> (# s, x #)
@@ -833,3 +833,4 @@ a `iShiftRL#` b | b >=# WORD_SIZE_IN_BITS# = 0#
 data RealWorld
 \end{code}
 #endif
+
index 54b36bc..071905c 100644 (file)
@@ -1,4 +1,4 @@
-
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude, MagicHash, StandaloneDeriving #-}
 {-# OPTIONS_GHC -fno-warn-unused-imports #-}
 -- XXX -fno-warn-unused-imports needed for the GHC.Tuple import below. Sigh.
index 851c4bb..3ceb4b3 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude, ForeignFunctionInterface #-}
 
 module GHC.Conc.Signal
@@ -19,8 +20,8 @@ import GHC.Arr (inRange)
 import GHC.Base
 import GHC.Conc.Sync (forkIO)
 import GHC.IO (mask_, unsafePerformIO)
-import GHC.IOArray (IOArray, boundsIOArray, newIOArray, unsafeReadIOArray,
-                    unsafeWriteIOArray)
+import GHC.IOArray (IOArray, boundsIOArray, newIOArray,
+                    unsafeReadIOArray, unsafeWriteIOArray)
 import GHC.Real (fromIntegral)
 import GHC.Word (Word8)
 
index 562ef32..a72b2b2 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, ForeignFunctionInterface #-}
 
 -----------------------------------------------------------------------------
index 871829d..99abba5 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 
 module GHC.Constants where
index 65dd645..3d1d740 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP
            , NoImplicitPrelude
            , Rank2Types
index ac6e9a9..abcc624 100644 (file)
@@ -1,4 +1,5 @@
 \begin{code}
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude, BangPatterns, MagicHash #-}
 {-# OPTIONS_HADDOCK hide #-}
 -----------------------------------------------------------------------------
index aeffeb4..57c0a90 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, ForeignFunctionInterface #-}
 
 module GHC.Environment (getFullArgs) where
index 90142f4..348f17c 100644 (file)
@@ -1,4 +1,5 @@
 \begin{code}
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 {-# OPTIONS_HADDOCK hide #-}
 
index 932f699..cc39bc8 100644 (file)
@@ -1,4 +1,5 @@
 \begin{code}
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 
 ---------------------------------------------------------------------------
index 7920895..850e036 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 -- | This module provides scalable event notification for file
 -- descriptors and timeouts.
 --
index c5b9679..ec4f893 100644 (file)
@@ -1,4 +1,5 @@
 \begin{code}
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude
            , ExistentialQuantification
            , MagicHash
index 81a9dbb..67b4a97 100644 (file)
@@ -60,7 +60,6 @@ import GHC.Base
 import GHC.Magic
 import GHC.Word
 import GHC.Int
--- import GHC.Float
 import GHC.Ptr
 import Data.String
 import Data.List
index 1c6fd5f..fa31751 100644 (file)
@@ -1,4 +1,5 @@
 \begin{code}
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP
            , NoImplicitPrelude
            , MagicHash
index 83dbe74..1d849f1 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, MagicHash, UnboxedTuples, NoImplicitPrelude #-}
 {-# OPTIONS_GHC -O2 #-}
 {-# OPTIONS_HADDOCK hide #-}
index 8ef5a20..7967957 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, MagicHash, UnboxedTuples, ForeignFunctionInterface,
     NoImplicitPrelude #-}
 {-# OPTIONS_HADDOCK hide #-}
index 109fa83..12d7888 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index e99c40a..8cc81f8 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# OPTIONS_HADDOCK hide #-}
 -----------------------------------------------------------------------------
 -- |
@@ -53,3 +54,4 @@ import GHC.IO.IOMode
 import GHC.IO.Handle
 import GHC.IO.Handle.Internals
 import GHC.IO.Handle.FD
+
index ad98a5e..99dc093 100644 (file)
--- a/GHC/IO.hs
+++ b/GHC/IO.hs
 
 -- #hide
 module GHC.IO (
-    IO(..), unIO, failIO, liftIO,
-    unsafePerformIO, unsafeInterleaveIO,
-    unsafeDupablePerformIO, unsafeDupableInterleaveIO,
-    noDuplicate,
+        IO(..), unIO, failIO, liftIO,
+        unsafePerformIO, unsafeInterleaveIO,
+        unsafeDupablePerformIO, unsafeDupableInterleaveIO,
+        noDuplicate,
 
         -- To and from from ST
-    stToIO, ioToST, unsafeIOToST, unsafeSTToIO,
+        stToIO, ioToST, unsafeIOToST, unsafeSTToIO,
 
-    FilePath,
+        FilePath,
 
-    catchException, catchAny, throwIO,
-    mask, mask_, uninterruptibleMask, uninterruptibleMask_, 
-    MaskingState(..), getMaskingState,
-    block, unblock, blocked, unsafeUnmask,
-    onException, bracket, finally, evaluate
-  ) where
+        catchException, catchAny, throwIO,
+        mask, mask_, uninterruptibleMask, uninterruptibleMask_, 
+        MaskingState(..), getMaskingState,
+        block, unblock, blocked, unsafeUnmask,
+        onException, bracket, finally, evaluate
+    ) where
 
 import GHC.Base
 import GHC.ST
index c019d69..456b1e1 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, ForeignFunctionInterface #-}
 {-# OPTIONS_GHC -funbox-strict-fields #-}
 
index 874a02d..7690fc7 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 {-# OPTIONS_GHC -funbox-strict-fields #-}
 
 -----------------------------------------------------------------------------
 
 module GHC.IO.BufferedIO (
-   BufferedIO(..),
-   readBuf, readBufNonBlocking, writeBuf, writeBufNonBlocking
- ) where
+        BufferedIO(..),
+        readBuf, readBufNonBlocking, writeBuf, writeBufNonBlocking
   ) where
 
 import GHC.Base
 import GHC.Ptr
 import Data.Word
 import GHC.Num
 import Data.Maybe
--- import GHC.IO
 import GHC.IO.Device as IODevice
 import GHC.IO.Device as RawIO
 import GHC.IO.Buffer
index bc772b8..903c041 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, BangPatterns #-}
 
 -----------------------------------------------------------------------------
 -----------------------------------------------------------------------------
 
 module GHC.IO.Device (
-    RawIO(..),
-    IODevice(..),
-    IODeviceType(..),
-    SeekMode(..)
-  ) where  
+        RawIO(..),
+        IODevice(..),
+        IODeviceType(..),
+        SeekMode(..)
+    ) where  
 
 #ifdef __GLASGOW_HASKELL__
 import GHC.Base
index 92ca843..6a97775 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, PatternGuards #-}
 {-# OPTIONS_GHC -funbox-strict-fields #-}
 
 -----------------------------------------------------------------------------
 
 module GHC.IO.Encoding (
-  BufferCodec(..), TextEncoding(..), TextEncoder, TextDecoder, CodingProgress(..),
-  latin1, latin1_encode, latin1_decode,
-  utf8, utf8_bom,
-  utf16, utf16le, utf16be,
-  utf32, utf32le, utf32be, 
-  localeEncoding, fileSystemEncoding, foreignEncoding,
-  char8,
-  mkTextEncoding,
-  ) where
+        BufferCodec(..), TextEncoding(..), TextEncoder, TextDecoder, CodingProgress(..),
+        latin1, latin1_encode, latin1_decode,
+        utf8, utf8_bom,
+        utf16, utf16le, utf16be,
+        utf32, utf32le, utf32be, 
+        localeEncoding, fileSystemEncoding, foreignEncoding,
+        char8,
+        mkTextEncoding,
+    ) where
 
 import GHC.Base
---import GHC.IO
 import GHC.IO.Exception
 import GHC.IO.Buffer
 import GHC.IO.Encoding.Failure
index 9223cc3..48c7825 100644 (file)
@@ -1,6 +1,7 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 module GHC.IO.Encoding where
 
 import GHC.IO.Encoding.Types
 
-localeEncoding, fileSystemEncoding, foreignEncoding :: TextEncoding
\ No newline at end of file
+localeEncoding, fileSystemEncoding, foreignEncoding :: TextEncoding
index a6b4e95..724b8ae 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, BangPatterns, ForeignFunctionInterface, NoImplicitPrelude,
              NondecreasingIndentation, MagicHash #-}
 module GHC.IO.Encoding.CodePage(
index a27650b..08e084d 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude, PatternGuards #-}
 -----------------------------------------------------------------------------
 -- |
index d919071..f8dfb88 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP
            , NoImplicitPrelude
            , ForeignFunctionInterface
@@ -31,7 +32,7 @@ module GHC.IO.Encoding.Iconv (
 
 #if !defined(mingw32_HOST_OS)
 
-import Foreign hiding (unsafePerformIO)
+import Foreign.Safe
 import Foreign.C
 import Data.Maybe
 import GHC.Base
index 197222e..0e3de39 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude
            , BangPatterns
            , NondecreasingIndentation
index ebce578..df6ce2f 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude, ExistentialQuantification #-}
 {-# OPTIONS_GHC -funbox-strict-fields #-}
 
index 1932220..af3cae0 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP
            , NoImplicitPrelude
            , BangPatterns
index 89a0d11..815f36c 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude
            , BangPatterns
            , NondecreasingIndentation
index 55d09c8..df3e67b 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude
            , BangPatterns
            , NondecreasingIndentation
index 4134fca..e3482cb 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude, DeriveDataTypeable, MagicHash #-}
 {-# OPTIONS_GHC -funbox-strict-fields #-}
 {-# OPTIONS_HADDOCK hide #-}
index d094ef2..fa3abe7 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 module GHC.IO.Exception where
 
index 65ed913..282c215 100644 (file)
@@ -13,7 +13,7 @@
 -- Module      :  GHC.IO.FD
 -- Copyright   :  (c) The University of Glasgow, 1994-2008
 -- License     :  see libraries/base/LICENSE
--- 
+--
 -- Maintainer  :  libraries@haskell.org
 -- Stability   :  internal
 -- Portability :  non-portable
 -----------------------------------------------------------------------------
 
 module GHC.IO.FD (
-  FD(..),
-  openFile, mkFD, release,
-  setNonBlockingMode,
-  readRawBufferPtr, readRawBufferPtrNoBlock, writeRawBufferPtr,
-  stdin, stdout, stderr
-  ) where
+        FD(..),
+        openFile, mkFD, release,
+        setNonBlockingMode,
+        readRawBufferPtr, readRawBufferPtrNoBlock, writeRawBufferPtr,
+        stdin, stdout, stderr
+    ) where
 
 import GHC.Base
 import GHC.Num
@@ -56,7 +56,6 @@ import Foreign.C
 import qualified System.Posix.Internals
 import System.Posix.Internals hiding (FD, setEcho, getEcho)
 import System.Posix.Types
--- import GHC.Ptr
 
 c_DEBUG_DUMP :: Bool
 c_DEBUG_DUMP = False
index fcfa92d..cb6f650 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP
            , NoImplicitPrelude
            , RecordWildCards
index d925f08..935bf5e 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 
 module GHC.IO.Handle where
index cb16645..31f90ea 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, PatternGuards, ForeignFunctionInterface #-}
 
 -----------------------------------------------------------------------------
@@ -24,19 +25,16 @@ module GHC.IO.Handle.FD (
 import GHC.Base
 import GHC.Show
 import Data.Maybe
--- import Control.Monad
 import Foreign.C.Types
 import GHC.MVar
 import GHC.IO
 import GHC.IO.Encoding
--- import GHC.IO.Exception
 import GHC.IO.Device as IODevice
 import GHC.IO.Exception
 import GHC.IO.IOMode
 import GHC.IO.Handle
 import GHC.IO.Handle.Types
 import GHC.IO.Handle.Internals
-import GHC.IO.FD (FD(..))
 import qualified GHC.IO.FD as FD
 import qualified System.Posix.Internals as Posix
 
@@ -90,7 +88,7 @@ stdHandleFinalizer fp m = do
 
 -- We have to put the FDs into binary mode on Windows to avoid the newline
 -- translation that the CRT IO library does.
-setBinaryMode :: FD -> IO ()
+setBinaryMode :: FD.FD -> IO ()
 #ifdef mingw32_HOST_OS
 setBinaryMode fd = do _ <- setmode (fdFD fd) True
                       return ()
@@ -199,7 +197,7 @@ openFile' filepath iomode binary non_blocking = do
 -- Converting file descriptors to Handles
 
 mkHandleFromFD
-   :: FD
+   :: FD.FD
    -> IODeviceType
    -> FilePath  -- a string describing this file descriptor (e.g. the filename)
    -> IOMode
index 2d84884..fb8ee97 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 module GHC.IO.Handle.FD where
 
index a2b644f..7e619c4 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude
            , RecordWildCards
            , BangPatterns
@@ -75,8 +76,7 @@ import GHC.MVar
 import Data.Typeable
 import Control.Monad
 import Data.Maybe
-import Foreign hiding (unsafePerformIO)
--- import System.IO.Error
+import Foreign.Safe
 import System.Posix.Internals hiding (FD)
 
 import Foreign.C
index 0d0e05b..7b390cd 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP
            , NoImplicitPrelude
            , RecordWildCards
 
 -- #hide
 module GHC.IO.Handle.Text ( 
-   hWaitForInput, hGetChar, hGetLine, hGetContents, hPutChar, hPutStr,
-   commitBuffer',       -- hack, see below
-   hGetBuf, hGetBufSome, hGetBufNonBlocking, hPutBuf, hPutBufNonBlocking,
-   memcpy, hPutStrLn,
- ) where
+        hWaitForInput, hGetChar, hGetLine, hGetContents, hPutChar, hPutStr,
+        commitBuffer',       -- hack, see below
+        hGetBuf, hGetBufSome, hGetBufNonBlocking, hPutBuf, hPutBufNonBlocking,
+        memcpy, hPutStrLn,
   ) where
 
 import GHC.IO
 import GHC.IO.FD
index bff4681..40c557a 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP
            , NoImplicitPrelude
            , ExistentialQuantification
index 3b0943c..b649ac1 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 {-# OPTIONS_HADDOCK hide #-}
 -----------------------------------------------------------------------------
index 67ee014..0b43c8b 100644 (file)
@@ -6,7 +6,7 @@
 -- Module      :  GHC.IOArray
 -- Copyright   :  (c) The University of Glasgow 2008
 -- License     :  see libraries/base/LICENSE
--- 
+--
 -- Maintainer  :  cvs-ghc@haskell.org
 -- Stability   :  internal
 -- Portability :  non-portable (GHC Extensions)
 -----------------------------------------------------------------------------
 
 module GHC.IOArray (
-    IOArray(..),
-    newIOArray, unsafeReadIOArray, unsafeWriteIOArray,
-    readIOArray, writeIOArray,
-    boundsIOArray
-  ) where
+        IOArray(..),
+        newIOArray, unsafeReadIOArray, unsafeWriteIOArray,
+        readIOArray, writeIOArray,
+        boundsIOArray
+    ) where
 
 import GHC.Base
 import GHC.IO
 import GHC.Arr
 
 -- ---------------------------------------------------------------------------
--- | An 'IOArray' is a mutable, boxed, non-strict array in the 'IO' monad.  
+-- | An 'IOArray' is a mutable, boxed, non-strict array in the 'IO' monad.
 -- The type arguments are as follows:
 --
 --  * @i@: the index type of the array (should be an instance of 'Ix')
 --
 --  * @e@: the element type of the array.
 --
--- 
+--
 
 newtype IOArray i e = IOArray (STArray RealWorld i e)
 
@@ -66,5 +66,6 @@ writeIOArray :: Ix i => IOArray i e -> i -> e -> IO ()
 writeIOArray (IOArray marr) i e = stToIO (writeSTArray marr i e)
 
 {-# INLINE boundsIOArray #-}
-boundsIOArray :: IOArray i e -> (i,i)  
+boundsIOArray :: IOArray i e -> (i,i)
 boundsIOArray (IOArray marr) = boundsSTArray marr
+
index be2808d..6efb77f 100644 (file)
@@ -7,7 +7,7 @@
 -- Module      :  GHC.IORef
 -- Copyright   :  (c) The University of Glasgow 2008
 -- License     :  see libraries/base/LICENSE
--- 
+--
 -- Maintainer  :  cvs-ghc@haskell.org
 -- Stability   :  internal
 -- Portability :  non-portable (GHC Extensions)
@@ -16,9 +16,9 @@
 --
 -----------------------------------------------------------------------------
 module GHC.IORef (
-    IORef(..),
-    newIORef, readIORef, writeIORef, atomicModifyIORef
-  ) where
+        IORef(..),
+        newIORef, readIORef, writeIORef, atomicModifyIORef
+    ) where
 
 import GHC.Base
 import GHC.STRef
index 27ee990..b80bd1a 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, BangPatterns, MagicHash, 
              StandaloneDeriving #-}
 {-# OPTIONS_HADDOCK hide #-}
@@ -19,8 +20,8 @@
 
 -- #hide
 module GHC.Int (
-    Int8(..), Int16(..), Int32(..), Int64(..),
-    uncheckedIShiftL64#, uncheckedIShiftRA64#
+        Int8(..), Int16(..), Int32(..), Int64(..),
+        uncheckedIShiftL64#, uncheckedIShiftRA64#
     ) where
 
 import Data.Bits
index ff8593c..838491a 100644 (file)
@@ -1,4 +1,5 @@
 \begin{code}
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, MagicHash #-}
 {-# OPTIONS_HADDOCK hide #-}
 
index 8c653dc..e6d960e 100644 (file)
@@ -7,7 +7,7 @@
 -- Module      :  GHC.MVar
 -- Copyright   :  (c) The University of Glasgow 2008
 -- License     :  see libraries/base/LICENSE
--- 
+--
 -- Maintainer  :  cvs-ghc@haskell.org
 -- Stability   :  internal
 -- Portability :  non-portable (GHC Extensions)
@@ -27,11 +27,10 @@ module GHC.MVar (
         , tryPutMVar    -- :: MVar a -> a -> IO Bool
         , isEmptyMVar   -- :: MVar a -> IO Bool
         , addMVarFinalizer -- :: MVar a -> IO () -> IO ()
-
-  ) where
+    ) where
 
 import GHC.Base
-import GHC.IO()   -- instance Monad IO
+import GHC.IO ()   -- instance Monad IO
 import Data.Maybe
 
 data MVar a = MVar (MVar# RealWorld a)
@@ -71,9 +70,9 @@ newMVar value =
     return mvar
 
 -- |Return the contents of the 'MVar'.  If the 'MVar' is currently
--- empty, 'takeMVar' will wait until it is full.  After a 'takeMVar', 
+-- empty, 'takeMVar' will wait until it is full.  After a 'takeMVar',
 -- the 'MVar' is left empty.
--- 
+--
 -- There are two further important properties of 'takeMVar':
 --
 --   * 'takeMVar' is single-wakeup.  That is, if there are multiple
@@ -133,13 +132,13 @@ tryPutMVar (MVar mvar#) x = IO $ \ s# ->
 -- the MVar may have been filled (or emptied) - so be extremely
 -- careful when using this operation.   Use 'tryTakeMVar' instead if possible.
 isEmptyMVar :: MVar a -> IO Bool
-isEmptyMVar (MVar mv#) = IO $ \ s# -> 
+isEmptyMVar (MVar mv#) = IO $ \ s# ->
     case isEmptyMVar# mv# s# of
         (# s2#, flg #) -> (# s2#, not (flg ==# 0#) #)
 
 -- |Add a finalizer to an 'MVar' (GHC only).  See "Foreign.ForeignPtr" and
 -- "System.Mem.Weak" for more about finalizers.
 addMVarFinalizer :: MVar a -> IO () -> IO ()
-addMVarFinalizer (MVar m) finalizer = 
+addMVarFinalizer (MVar m) finalizer =
   IO $ \s -> case mkWeak# m () finalizer s of { (# s1, _ #) -> (# s1, () #) }
 
index 5dc5e75..b7b0260 100644 (file)
@@ -1,4 +1,5 @@
 \begin{code}
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, MagicHash, UnboxedTuples #-}
 -- We believe we could deorphan this module, by moving lots of things
 -- around, but we haven't got there yet:
index 704fc5a..ee7eea8 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE ParallelArrays, MagicHash #-}
 {-# OPTIONS_GHC -funbox-strict-fields #-}
 {-# OPTIONS_HADDOCK hide #-}
index bf78f71..e7e0b1f 100644 (file)
 -----------------------------------------------------------------------------
 
 -- #hide
-module GHC.Ptr where
+module GHC.Ptr (
+        Ptr(..), FunPtr(..),
+        nullPtr, castPtr, plusPtr, alignPtr, minusPtr,
+        nullFunPtr, castFunPtr,
+
+        -- * Unsafe functions
+        castFunPtrToPtr, castPtrToFunPtr
+    ) where
 
 import GHC.Base
 import GHC.Show
@@ -156,5 +163,5 @@ instance Show (Ptr a) where
 
 instance Show (FunPtr a) where
    showsPrec p = showsPrec p . castFunPtrToPtr
-\end{code}
 
+\end{code}
index 6305276..fcbdb8e 100644 (file)
@@ -1,4 +1,5 @@
 \begin{code}
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, StandaloneDeriving #-}
 {-# OPTIONS_HADDOCK hide #-}
 
@@ -688,4 +689,4 @@ Instances for types of the generic deriving mechanism.
 deriving instance Read Arity
 deriving instance Read Associativity
 deriving instance Read Fixity
-\end{code}
\ No newline at end of file
+\end{code}
index 27b1b6c..6d44e29 100644 (file)
@@ -1,4 +1,5 @@
 \begin{code}
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, MagicHash, UnboxedTuples #-}
 {-# OPTIONS_HADDOCK hide #-}
 -----------------------------------------------------------------------------
index a66a5f8..4e27fb2 100644 (file)
 -----------------------------------------------------------------------------
 
 -- #hide
-module GHC.ST where
+module GHC.ST (
+        ST(..), STret(..), STRep,
+        fixST, runST, runSTRep,
+
+        -- * Unsafe functions
+        liftST, unsafeInterleaveST
+    ) where
 
 import GHC.Base
 import GHC.Show
index 9306b24..4e5952a 100644 (file)
@@ -7,7 +7,7 @@
 -- Module      :  GHC.STRef
 -- Copyright   :  (c) The University of Glasgow, 1994-2002
 -- License     :  see libraries/base/LICENSE
--- 
+--
 -- Maintainer  :  cvs-ghc@haskell.org
 -- Stability   :  internal
 -- Portability :  non-portable (GHC Extensions)
 -----------------------------------------------------------------------------
 
 -- #hide
-module GHC.STRef where
+module GHC.STRef (
+        STRef(..),
+        newSTRef, readSTRef, writeSTRef
+    ) where
 
 import GHC.ST
 import GHC.Base
@@ -45,4 +48,5 @@ writeSTRef (STRef var#) val = ST $ \s1# ->
 -- Just pointer equality on mutable references:
 instance Eq (STRef s a) where
     STRef v1# == STRef v2# = sameMutVar# v1# v2#
+
 \end{code}
index bbfe458..1645b4a 100644 (file)
@@ -1,4 +1,5 @@
 \begin{code}
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude, BangPatterns, MagicHash, StandaloneDeriving #-}
 {-# OPTIONS_HADDOCK hide #-}
 
index 6c5fa61..a2363f6 100644 (file)
@@ -1,4 +1,5 @@
 \begin{code}
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 
 module GHC.Show (showSignedInt) where
index e96bf68..10675f7 100644 (file)
 -----------------------------------------------------------------------------
 
 -- #hide
-module GHC.Stable 
-        ( StablePtr(..)
-        , newStablePtr          -- :: a -> IO (StablePtr a)    
-        , deRefStablePtr        -- :: StablePtr a -> a
-        , freeStablePtr         -- :: StablePtr a -> IO ()
-        , castStablePtrToPtr    -- :: StablePtr a -> Ptr ()
-        castPtrToStablePtr    -- :: Ptr () -> StablePtr a
-   ) where
+module GHC.Stable (
+        StablePtr(..),
+        newStablePtr,         -- :: a -> IO (StablePtr a)    
+        deRefStablePtr,       -- :: StablePtr a -> a
+        freeStablePtr,        -- :: StablePtr a -> IO ()
+        castStablePtrToPtr,   -- :: StablePtr a -> Ptr ()
+        castPtrToStablePtr    -- :: Ptr () -> StablePtr a
+    ) where
 
 import GHC.Ptr
 import GHC.Base
--- import GHC.IO
 
 -----------------------------------------------------------------------------
 -- Stable Pointers
@@ -109,4 +108,5 @@ instance Eq (StablePtr a) where
         case eqStablePtr# sp1 sp2 of
            0# -> False
            _  -> True
+
 \end{code}
index a722873..119fed6 100644 (file)
@@ -1,4 +1,5 @@
 \begin{code}
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude, MagicHash, UnboxedTuples #-}
 {-# OPTIONS_HADDOCK hide #-}
 
@@ -52,7 +53,7 @@ module GHC.Storable
         , writeWord64OffPtr   
         ) where
 
-import GHC.Stable       ( StablePtr(..) )
+import GHC.Stable ( StablePtr(..) )
 import GHC.Int
 import GHC.Word
 import GHC.Ptr
index 7bedcfe..0ebc42c 100644 (file)
@@ -1,4 +1,5 @@
 \begin{code}
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP
            , NoImplicitPrelude
            , ForeignFunctionInterface
 
 -- #hide
 module GHC.TopHandler (
-   runMainIO, runIO, runIOFastExit, runNonIO,
-   topHandler, topHandlerFastExit,
-   reportStackOverflow, reportError,
-  ) where
+        runMainIO, runIO, runIOFastExit, runNonIO,
+        topHandler, topHandlerFastExit,
+        reportStackOverflow, reportError,
+    ) where
 
 #include "HsBaseConfig.h"
 
index b34f677..a55c8a0 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, ForeignFunctionInterface #-}
 {-# OPTIONS -#include "WCsubst.h" #-}
 {-# OPTIONS_HADDOCK hide #-}
 
 -- #hide
 module GHC.Unicode (
-    isAscii, isLatin1, isControl,
-    isAsciiUpper, isAsciiLower,
-    isPrint, isSpace,  isUpper,
-    isLower, isAlpha,  isDigit,
-    isOctDigit, isHexDigit, isAlphaNum,
-    toUpper, toLower, toTitle,
-    wgencat,
-  ) where
+        isAscii, isLatin1, isControl,
+        isAsciiUpper, isAsciiLower,
+        isPrint, isSpace,  isUpper,
+        isLower, isAlpha,  isDigit,
+        isOctDigit, isHexDigit, isAlphaNum,
+        toUpper, toLower, toTitle,
+        wgencat
+    ) where
 
 import GHC.Base
 import GHC.Real        (fromIntegral)
index cc67dbb..1e01a1c 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 
 module GHC.Unicode where
index 92e1eb8..3de4655 100644 (file)
 -----------------------------------------------------------------------------
 
 -- #hide
-module GHC.Weak where
+module GHC.Weak (
+        Weak(..),
+        mkWeak,
+        deRefWeak,
+        finalize,
+        runFinalizerBatch
+    ) where
 
 import GHC.Base
 import Data.Maybe
index 2a74a5f..836dcf8 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude, ForeignFunctionInterface #-}
 -----------------------------------------------------------------------------
 -- |
 --
 -----------------------------------------------------------------------------
 
-module GHC.Windows where
+module GHC.Windows (
+        HANDLE, DWORD, LPTSTR, iNFINITE,
+        throwGetLastError, maperrno
+    ) where
 
 import GHC.Base
 import GHC.Ptr
index 9d3e1a6..dd7e7d5 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, BangPatterns, MagicHash #-}
 {-# OPTIONS_HADDOCK hide #-}
 
index 4b202d0..8989f96 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, MagicHash #-}
 
 -----------------------------------------------------------------------------
index 4c183ae..59bffae 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, BangPatterns #-}
 
 -----------------------------------------------------------------------------
@@ -156,8 +157,6 @@ import Data.Tuple
 
 #ifdef __GLASGOW_HASKELL__
 import GHC.Base
--- import GHC.IO
--- import GHC.IO.Exception
 import Text.Read
 import GHC.Enum
 import GHC.Num
index 90ff1e9..f07b2e4 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NondecreasingIndentation, ForeignFunctionInterface #-}
 
 -----------------------------------------------------------------------------
@@ -33,7 +34,7 @@ import CPUTime ( getCPUTime, cpuTimePrecision )
 #endif
 
 #ifdef __GLASGOW_HASKELL__
-import Foreign hiding (unsafePerformIO)
+import Foreign.Safe
 import Foreign.C
 #if !defined(CLK_TCK)
 import System.IO.Unsafe (unsafePerformIO)
index 92ebd52..d5a32f3 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Safe #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  System.Console.GetOpt
index cf73c3d..e185575 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Safe #-}
 {-# LANGUAGE CPP, ForeignFunctionInterface #-}
 
 -----------------------------------------------------------------------------
@@ -31,7 +32,7 @@ module System.Environment
 import Prelude
 
 #ifdef __GLASGOW_HASKELL__
-import Foreign
+import Foreign.Safe
 import Foreign.C
 import Control.Exception.Base   ( bracket )
 -- import GHC.IO
index 7eb17cf..9a9ed00 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
index bf26835..768d557 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index a026f33..1458d60 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index 3ef3d9f..719bd3e 100644 (file)
@@ -21,7 +21,7 @@ module System.IO.Unsafe (
   ) where
 
 #ifdef __GLASGOW_HASKELL__
-import GHC.IO (unsafePerformIO, unsafeInterleaveIO)
+import GHC.IO      (unsafePerformIO, unsafeInterleaveIO)
 #endif
 
 #ifdef __HUGS__
index 92da1a6..5fc816c 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Safe #-}
 {-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
index af96b5d..67b80cc 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Safe #-}
 {-# LANGUAGE CPP #-}
 
 #ifdef __GLASGOW_HASKELL__
index 2bce839..7d688e9 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 #ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
index 21411e5..8980a51 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
index 6a30ba0..632e69e 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, ForeignFunctionInterface #-}
 {-# OPTIONS_HADDOCK hide #-}
 
index 40415fc..ff4c4e8 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 module System.Posix.Internals where
 
index 9bb85e2..c8c0c48 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP
            , NoImplicitPrelude
            , MagicHash
index df33625..d1cbbff 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 #ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
index 27bba54..2bb9363 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 #ifndef __NHC__
 {-# LANGUAGE Rank2Types #-}
index f282d1a..8a200b9 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index 7d4611e..021f670 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Safe #-}
 {-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
index d935ffe..cea334b 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index 222d6cf..88c9c07 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index 4d23e57..3662d12 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Safe #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
index 1ae46aa..fa202f7 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE Safe #-}
 {-# LANGUAGE CPP #-}
 -- This module deliberately declares orphan instances:
 {-# OPTIONS_GHC -fno-warn-orphans #-}
index 6bb96f6..5824952 100644 (file)
@@ -52,38 +52,38 @@ Library {
             GHC.Exception,
             GHC.Exts,
             GHC.Float,
+            GHC.Float.ConversionUtils,
             GHC.Float.RealFracMethods,
             GHC.Foreign,
-            GHC.Float.ConversionUtils,
             GHC.ForeignPtr,
-            GHC.MVar,
+            GHC.Handle,
             GHC.IO,
-            GHC.IO.IOMode,
             GHC.IO.Buffer,
-            GHC.IO.Device,
             GHC.IO.BufferedIO,
-            GHC.IO.FD,
-            GHC.IO.Exception,
+            GHC.IO.Device,
             GHC.IO.Encoding,
+            GHC.IO.Encoding.CodePage,
+            GHC.IO.Encoding.Failure,
+            GHC.IO.Encoding.Iconv,
             GHC.IO.Encoding.Latin1,
-            GHC.IO.Encoding.UTF8,
+            GHC.IO.Encoding.Types,
             GHC.IO.Encoding.UTF16,
             GHC.IO.Encoding.UTF32,
-            GHC.IO.Encoding.Types,
-            GHC.IO.Encoding.Iconv,
-            GHC.IO.Encoding.CodePage,
-            GHC.IO.Encoding.Failure,
+            GHC.IO.Encoding.UTF8,
+            GHC.IO.Exception,
+            GHC.IO.FD,
             GHC.IO.Handle,
-            GHC.IO.Handle.Types,
-            GHC.IO.Handle.Internals,
             GHC.IO.Handle.FD,
+            GHC.IO.Handle.Internals,
             GHC.IO.Handle.Text,
+            GHC.IO.Handle.Types,
+            GHC.IO.IOMode,
+            GHC.IOArray,
             GHC.IOBase,
-            GHC.Handle,
             GHC.IORef,
-            GHC.IOArray,
             GHC.Int,
             GHC.List,
+            GHC.MVar,
             GHC.Num,
             GHC.PArr,
             GHC.Pack,
@@ -91,10 +91,10 @@ Library {
             GHC.Read,
             GHC.Real,
             GHC.ST,
-            GHC.STRef,
             GHC.Show,
             GHC.Stable,
             GHC.Storable,
+            GHC.STRef,
             GHC.TopHandler,
             GHC.Unicode,
             GHC.Weak,
@@ -121,9 +121,13 @@ Library {
         Control.Monad,
         Control.Monad.Fix,
         Control.Monad.Instances,
-        Control.Monad.ST
-        Control.Monad.ST.Lazy
-        Control.Monad.ST.Strict
+        Control.Monad.ST,
+        Control.Monad.ST.Safe,
+        Control.Monad.ST.Unsafe,
+        Control.Monad.ST.Lazy,
+        Control.Monad.ST.Lazy.Safe,
+        Control.Monad.ST.Lazy.Unsafe,
+        Control.Monad.ST.Strict,
         Control.Monad.Group
         Control.Monad.Zip
         Data.Bits,
@@ -164,13 +168,18 @@ Library {
         Foreign.C.String,
         Foreign.C.Types,
         Foreign.ForeignPtr,
+        Foreign.ForeignPtr.Safe,
+        Foreign.ForeignPtr.Unsafe,
         Foreign.Marshal,
         Foreign.Marshal.Alloc,
         Foreign.Marshal.Array,
         Foreign.Marshal.Error,
         Foreign.Marshal.Pool,
+        Foreign.Marshal.Safe,
         Foreign.Marshal.Utils,
+        Foreign.Marshal.Unsafe,
         Foreign.Ptr,
+        Foreign.Safe,
         Foreign.StablePtr,
         Foreign.Storable,
         Numeric,
@@ -196,6 +205,10 @@ Library {
         Text.Show,
         Text.Show.Functions
         Unsafe.Coerce
+    other-modules:
+        Control.Monad.ST.Imp
+        Control.Monad.ST.Lazy.Imp
+        Foreign.ForeignPtr.Imp
     c-sources:
         cbits/PrelIOUtils.c
         cbits/WCsubst.c
@@ -232,4 +245,5 @@ Library {
     -- as it's magic.
     ghc-options: -package-name base
     nhc98-options: -H4M -K3M
+    extensions: CPP
 }