Use Safe Haskell when GHC >= 7.2

Control/Monad.hs

+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 -- |
 -- The "Control.Monad" module provides the 'Functor', 'Monad' and
 -- 'MonadPlus' classes, together with some useful operations on monads.

Data/Array.hs

+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Trustworthy #-}
+#endif
+
 module Data.Array (
     -- * Immutable non-strict arrays
     -- $intro

Data/Bits.hs

+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 -- |
 -- This module defines bitwise operations for signed and unsigned
 -- integers.

Data/Char.hs

+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Data.Char (
     -- * Characters and strings
       Char

Data/Complex.hs

+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Data.Complex (
         -- * Rectangular form
           Complex((:+))

Data/Int.hs

+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Data.Int (
         -- * Signed integer types
 

Data/Ix.hs

+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Data.Ix (
     -- * The 'Ix' class
         Ix

Data/List.hs

+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Data.List (
    -- * Basic functions
 

Data/Maybe.hs

+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Data.Maybe (
    -- * The @Maybe@ type and operations
 

Data/Ratio.hs

+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Data.Ratio (
       Ratio
     , Rational

Data/Word.hs

+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Data.Word (
         -- * Unsigned integral types
 

Foreign/C.hs

+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Foreign.C (
 
        -- | The module "Foreign.C" combines the interfaces of all

Foreign/C/Error.hs

+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 -- | The module "Foreign.C.Error" facilitates C-specific error
 -- handling of @errno@.
 module Foreign.C.Error (

Foreign/C/String.hs

+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 -- |
 -- Utilities for primitive marshalling of C strings.
 --

Foreign/C/Types.hs

+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Foreign.C.Types
         ( -- * Representations of C types
           -- $ctypes

Foreign/Marshal/Alloc.hs

+{-# LANGUAGE CPP #-}
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 {- |
 The module "Foreign.Marshal.Alloc" provides operations to allocate and
 deallocate blocks of raw memory (i.e., unstructured chunks of memory

Foreign/Marshal/Array.hs

+{-# LANGUAGE CPP #-}
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 {- |
 The module "Foreign.Marshal.Array" provides operations for marshalling Haskell
 lists into monolithic arrays and vice versa.  Most functions come in two
@@ -61,7 +66,11 @@ module Foreign.Marshal.Array (
   ) where
 import qualified "base" Foreign.Marshal.Array as Base
 import "base" Foreign.Marshal.Array hiding (peekArray)
+#if __GLASGOW_HASKELL__ >= 701
+import "base" Foreign.Safe hiding (peekArray)
+#else
 import "base" Foreign hiding (peekArray)
+#endif
 
 -- |Convert an array of given length into a Haskell list.
 --

Foreign/Marshal/Error.hs

+{-# LANGUAGE CPP #-}
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Foreign.Marshal.Error (
   throwIf,       -- :: (a -> Bool) -> (a -> String) -> IO a       -> IO a
   throwIf_,      -- :: (a -> Bool) -> (a -> String) -> IO a       -> IO ()

Foreign/Marshal/Utils.hs

+{-# LANGUAGE CPP #-}
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Foreign.Marshal.Utils (
   -- * General marshalling utilities
 

Foreign/Ptr.hs

+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 -- | The module "Foreign.Ptr" provides typed pointers to foreign
 -- entities.  We distinguish two kinds of pointers: pointers to data
 -- and pointers to functions.  It is understood that these two kinds