SafeHaskell: Added SafeHaskell to base

libraries/base/Control/Applicative.hs

+{-# 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(..))

libraries/base/Control/Arrow.hs

+{-# LANGUAGE Trustworthy #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Arrow

libraries/base/Control/Category.hs

+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------

libraries/base/Control/Concurrent.hs

+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP
            , ForeignFunctionInterface
            , MagicHash

libraries/base/Control/Concurrent/Chan.hs

+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 #ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}

libraries/base/Control/Concurrent/MVar.hs

+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------

libraries/base/Control/Concurrent/QSem.hs

+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 #ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}

libraries/base/Control/Concurrent/QSemN.hs

+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 #ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}

libraries/base/Control/Concurrent/SampleVar.hs

+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 #ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}

libraries/base/Control/Exception.hs

+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, ExistentialQuantification #-}
 
 -----------------------------------------------------------------------------

libraries/base/Control/Exception/Base.hs

+{-# 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

libraries/base/Control/Monad.hs

+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------

libraries/base/Control/Monad/Fix.hs

+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------

libraries/base/Control/Monad/Group.hs

+{-# LANGUAGE Trustworthy #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Monad.Group

libraries/base/Control/Monad/Instances.hs

+{-# LANGUAGE Safe #-}
 {-# OPTIONS_NHC98 --prelude #-}
 -- This module deliberately declares orphan instances:
 {-# OPTIONS_GHC -fno-warn-orphans #-}

libraries/base/Control/Monad/ST.hs

-{-# 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)
@@ -16,55 +19,35 @@
 --
 -----------------------------------------------------------------------------
 
-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
 

libraries/base/Control/Monad/ST/Imp.hs

+{-# 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
+
+

libraries/base/Control/Monad/ST/Lazy.hs

-{-# LANGUAGE CPP, MagicHash, UnboxedTuples, Rank2Types #-}
+{-# LANGUAGE CPP, SafeImports #-}
+#if sh_SAFE_DEFAULT
+{-# LANGUAGE Safe #-}
+#endif
 
 -----------------------------------------------------------------------------
 -- |
@@ -17,136 +20,28 @@
 -----------------------------------------------------------------------------
 
 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

libraries/base/Control/Monad/ST/Lazy/Imp.hs

+{-# 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.
+-}