diff --git a/Array.hs b/Array.hs
--- a/Array.hs
+++ b/Array.hs
@@ -1,8 +1,12 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Trustworthy #-}
+#endif
+
 module Array (
-    module Ix,  -- export all of Ix for convenience
-    Array, array, listArray, (!), bounds, indices, elems, assocs, 
-    accumArray, (//), accum, ixmap
-  ) where
+        module Ix,  -- export all of Ix for convenience
+        Array, array, listArray, (!), bounds, indices, elems, assocs, 
+        accumArray, (//), accum, ixmap
+    ) where
 
 import Ix
 import Data.Array
diff --git a/Bits.hs b/Bits.hs
--- a/Bits.hs
+++ b/Bits.hs
@@ -1,3 +1,7 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Bits (module Data.Bits) where
 import Data.Bits
 
diff --git a/CError.hs b/CError.hs
--- a/CError.hs
+++ b/CError.hs
@@ -1,2 +1,7 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module CError (module Foreign.C.Error) where
 import Foreign.C.Error
+
diff --git a/CForeign.hs b/CForeign.hs
--- a/CForeign.hs
+++ b/CForeign.hs
@@ -1,2 +1,6 @@
-module CForeign ( module Foreign.C ) where
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
+module CForeign (module Foreign.C) where
 import Foreign.C
diff --git a/CPUTime.hs b/CPUTime.hs
--- a/CPUTime.hs
+++ b/CPUTime.hs
@@ -1,5 +1,8 @@
-module CPUTime (
-    getCPUTime, cpuTimePrecision 
-  ) where
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
 
+module CPUTime (
+        getCPUTime, cpuTimePrecision 
+    ) where
 import System.CPUTime
diff --git a/CString.hs b/CString.hs
--- a/CString.hs
+++ b/CString.hs
@@ -1,2 +1,6 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module CString (module Foreign.C.String) where
 import Foreign.C.String
diff --git a/CTypes.hs b/CTypes.hs
--- a/CTypes.hs
+++ b/CTypes.hs
@@ -1,2 +1,6 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module CTypes (module Foreign.C.Types) where
 import Foreign.C.Types
diff --git a/Char.hs b/Char.hs
--- a/Char.hs
+++ b/Char.hs
@@ -1,13 +1,17 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Char (
-    isAscii, isLatin1, isControl, isPrint, isSpace, isUpper, isLower, 
-    isAlpha, isDigit, isOctDigit, isHexDigit, isAlphaNum, 
-    digitToInt, intToDigit,
-    toUpper, toLower,
-    ord, chr,
-    readLitChar, showLitChar, lexLitChar,
+        isAscii, isLatin1, isControl, isPrint, isSpace, isUpper, isLower, 
+        isAlpha, isDigit, isOctDigit, isHexDigit, isAlphaNum, 
+        digitToInt, intToDigit,
+        toUpper, toLower,
+        ord, chr,
+        readLitChar, showLitChar, lexLitChar,
 
--- ...and what the Prelude exports
-    Char, String
-  ) where
+        -- ...and what the Prelude exports
+        Char, String
+    ) where
 
 import Data.Char
diff --git a/Complex.hs b/Complex.hs
--- a/Complex.hs
+++ b/Complex.hs
@@ -1,6 +1,10 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Complex (
-    Complex((:+)), realPart, imagPart, conjugate, 
-    mkPolar, cis, polar, magnitude, phase 
-  ) where
+        Complex((:+)), realPart, imagPart, conjugate, 
+        mkPolar, cis, polar, magnitude, phase 
+    ) where
 
 import Data.Complex
diff --git a/Directory.hs b/Directory.hs
--- a/Directory.hs
+++ b/Directory.hs
@@ -1,12 +1,16 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Trustworthy #-}
+#endif
+
 module Directory (
-    Permissions( Permissions, readable, writable, executable, searchable ), 
-    createDirectory, removeDirectory, removeFile, 
-    renameDirectory, renameFile, getDirectoryContents,
-    getCurrentDirectory, setCurrentDirectory,
-    doesFileExist, doesDirectoryExist,
-    getPermissions, setPermissions,
-    getModificationTime 
-  ) where
+        Permissions( Permissions, readable, writable, executable, searchable ), 
+        createDirectory, removeDirectory, removeFile, 
+        renameDirectory, renameFile, getDirectoryContents,
+        getCurrentDirectory, setCurrentDirectory,
+        doesFileExist, doesDirectoryExist,
+        getPermissions, setPermissions,
+        getModificationTime 
+    ) where
 
 import System.Directory hiding (Permissions,
                                 readable, writable, executable, searchable,
diff --git a/ForeignPtr.hs b/ForeignPtr.hs
--- a/ForeignPtr.hs
+++ b/ForeignPtr.hs
@@ -1,2 +1,6 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Trustworthy #-}
+#endif
+
 module ForeignPtr (module Foreign.ForeignPtr) where
 import Foreign.ForeignPtr
diff --git a/IO.hs b/IO.hs
--- a/IO.hs
+++ b/IO.hs
@@ -1,29 +1,31 @@
-
 {-# OPTIONS_GHC -fno-warn-deprecations #-}
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
 
 module IO (
-    Handle, HandlePosn,
-    IOMode(ReadMode,WriteMode,AppendMode,ReadWriteMode),
-    BufferMode(NoBuffering,LineBuffering,BlockBuffering),
-    SeekMode(AbsoluteSeek,RelativeSeek,SeekFromEnd),
-    stdin, stdout, stderr, 
-    openFile, hClose, hFileSize, hIsEOF, isEOF,
-    hSetBuffering, hGetBuffering, hFlush, 
-    hGetPosn, hSetPosn, hSeek, 
-    hWaitForInput, hReady, hGetChar, hGetLine, hLookAhead, hGetContents, 
-    hPutChar, hPutStr, hPutStrLn, hPrint,
-    hIsOpen, hIsClosed, hIsReadable, hIsWritable, hIsSeekable,
-    isAlreadyExistsError, isDoesNotExistError, isAlreadyInUseError, 
-    isFullError, isEOFError,
-    isIllegalOperation, isPermissionError, isUserError, 
-    ioeGetErrorString, ioeGetHandle, ioeGetFileName,
-    try, bracket, bracket_,
+        Handle, HandlePosn,
+        IOMode(ReadMode,WriteMode,AppendMode,ReadWriteMode),
+        BufferMode(NoBuffering,LineBuffering,BlockBuffering),
+        SeekMode(AbsoluteSeek,RelativeSeek,SeekFromEnd),
+        stdin, stdout, stderr, 
+        openFile, hClose, hFileSize, hIsEOF, isEOF,
+        hSetBuffering, hGetBuffering, hFlush, 
+        hGetPosn, hSetPosn, hSeek, 
+        hWaitForInput, hReady, hGetChar, hGetLine, hLookAhead, hGetContents, 
+        hPutChar, hPutStr, hPutStrLn, hPrint,
+        hIsOpen, hIsClosed, hIsReadable, hIsWritable, hIsSeekable,
+        isAlreadyExistsError, isDoesNotExistError, isAlreadyInUseError, 
+        isFullError, isEOFError,
+        isIllegalOperation, isPermissionError, isUserError, 
+        ioeGetErrorString, ioeGetHandle, ioeGetFileName,
+        try, bracket, bracket_,
 
-    -- ...and what the Prelude exports
-    IO, FilePath, IOError, ioError, userError, catch, interact,
-    putChar, putStr, putStrLn, print, getChar, getLine, getContents,
-    readFile, writeFile, appendFile, readIO, readLn
-  ) where
+        -- ...and what the Prelude exports
+        IO, FilePath, IOError, ioError, userError, catch, interact,
+        putChar, putStr, putStrLn, print, getChar, getLine, getContents,
+        readFile, writeFile, appendFile, readIO, readLn
+    ) where
 
 import System.IO
 import System.IO.Error hiding (catch, try)
diff --git a/Int.hs b/Int.hs
--- a/Int.hs
+++ b/Int.hs
@@ -1,2 +1,6 @@
-module Int ( module Data.Int ) where
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
+module Int (module Data.Int) where
 import Data.Int
diff --git a/Ix.hs b/Ix.hs
--- a/Ix.hs
+++ b/Ix.hs
@@ -1,5 +1,9 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Ix (
-    Ix(range, index, inRange), rangeSize
-  ) where
+        Ix(range, index, inRange), rangeSize
+    ) where
 
 import Data.Ix
diff --git a/List.hs b/List.hs
--- a/List.hs
+++ b/List.hs
@@ -1,29 +1,33 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module List (
-    elemIndex, elemIndices,
-    find, findIndex, findIndices,
-    nub, nubBy, delete, deleteBy, (\\), deleteFirstsBy,
-    union, unionBy, intersect, intersectBy,
-    intersperse, transpose, partition, group, groupBy,
-    inits, tails, isPrefixOf, isSuffixOf,
-    mapAccumL, mapAccumR,
-    sort, sortBy, insert, insertBy, maximumBy, minimumBy,
-    genericLength, genericTake, genericDrop,
-    genericSplitAt, genericIndex, genericReplicate,
-    zip4, zip5, zip6, zip7,
-    zipWith4, zipWith5, zipWith6, zipWith7,
-    unzip4, unzip5, unzip6, unzip7, unfoldr,
+        elemIndex, elemIndices,
+        find, findIndex, findIndices,
+        nub, nubBy, delete, deleteBy, (\\), deleteFirstsBy,
+        union, unionBy, intersect, intersectBy,
+        intersperse, transpose, partition, group, groupBy,
+        inits, tails, isPrefixOf, isSuffixOf,
+        mapAccumL, mapAccumR,
+        sort, sortBy, insert, insertBy, maximumBy, minimumBy,
+        genericLength, genericTake, genericDrop,
+        genericSplitAt, genericIndex, genericReplicate,
+        zip4, zip5, zip6, zip7,
+        zipWith4, zipWith5, zipWith6, zipWith7,
+        unzip4, unzip5, unzip6, unzip7, unfoldr,
 
-    -- ...and what the Prelude exports
-    -- []((:), []), -- This is built-in syntax
-    map, (++), concat, filter,
-    head, last, tail, init, null, length, (!!),
-    foldl, foldl1, scanl, scanl1, foldr, foldr1, scanr, scanr1,
-    iterate, repeat, replicate, cycle,
-    take, drop, splitAt, takeWhile, dropWhile, span, break,
-    lines, words, unlines, unwords, reverse, and, or,
-    any, all, elem, notElem, lookup,
-    sum, product, maximum, minimum, concatMap, 
-    zip, zip3, zipWith, zipWith3, unzip, unzip3
-  ) where
+        -- ...and what the Prelude exports
+        -- []((:), []), -- This is built-in syntax
+        map, (++), concat, filter,
+        head, last, tail, init, null, length, (!!),
+        foldl, foldl1, scanl, scanl1, foldr, foldr1, scanr, scanr1,
+        iterate, repeat, replicate, cycle,
+        take, drop, splitAt, takeWhile, dropWhile, span, break,
+        lines, words, unlines, unwords, reverse, and, or,
+        any, all, elem, notElem, lookup,
+        sum, product, maximum, minimum, concatMap, 
+        zip, zip3, zipWith, zipWith3, unzip, unzip3
+    ) where
 
 import Data.List hiding (foldl', splitAt)
diff --git a/Locale.hs b/Locale.hs
--- a/Locale.hs
+++ b/Locale.hs
@@ -1,6 +1,10 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Trustworthy #-}
+#endif
+
 module Locale (
-    TimeLocale(..), defaultTimeLocale
-  ) where
+        TimeLocale(..), defaultTimeLocale
+    ) where
 
 import System.Locale ( 
 	-- just the bits that are specified by Haskell 98
diff --git a/MarshalAlloc.hs b/MarshalAlloc.hs
--- a/MarshalAlloc.hs
+++ b/MarshalAlloc.hs
@@ -1,2 +1,6 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module MarshalAlloc (module Foreign.Marshal.Alloc) where
 import Foreign.Marshal.Alloc
diff --git a/MarshalArray.hs b/MarshalArray.hs
--- a/MarshalArray.hs
+++ b/MarshalArray.hs
@@ -1,2 +1,6 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module MarshalArray (module Foreign.Marshal.Array) where
 import Foreign.Marshal.Array
diff --git a/MarshalError.hs b/MarshalError.hs
--- a/MarshalError.hs
+++ b/MarshalError.hs
@@ -1,3 +1,7 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module MarshalError (
   	module Foreign.Marshal.Error,
 	IOErrorType,
diff --git a/MarshalUtils.hs b/MarshalUtils.hs
--- a/MarshalUtils.hs
+++ b/MarshalUtils.hs
@@ -1,2 +1,6 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module MarshalUtils (module Foreign.Marshal.Utils) where
 import Foreign.Marshal.Utils
diff --git a/Maybe.hs b/Maybe.hs
--- a/Maybe.hs
+++ b/Maybe.hs
@@ -1,11 +1,15 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Maybe (
-    isJust, isNothing,
-    fromJust, fromMaybe, listToMaybe, maybeToList,
-    catMaybes, mapMaybe,
+        isJust, isNothing,
+        fromJust, fromMaybe, listToMaybe, maybeToList,
+        catMaybes, mapMaybe,
 
-    -- ...and what the Prelude exports
-    Maybe(Nothing, Just),
-    maybe
-  ) where
+        -- ...and what the Prelude exports
+        Maybe(Nothing, Just),
+        maybe
+    ) where
 
 import Data.Maybe
diff --git a/Monad.hs b/Monad.hs
--- a/Monad.hs
+++ b/Monad.hs
@@ -1,14 +1,18 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Monad (
-    MonadPlus(mzero, mplus),
-    join, guard, when, unless, ap,
-    msum,
-    filterM, mapAndUnzipM, zipWithM, zipWithM_, foldM, 
-    liftM, liftM2, liftM3, liftM4, liftM5,
+        MonadPlus(mzero, mplus),
+        join, guard, when, unless, ap,
+        msum,
+        filterM, mapAndUnzipM, zipWithM, zipWithM_, foldM, 
+        liftM, liftM2, liftM3, liftM4, liftM5,
 
-    -- ...and what the Prelude exports
-    Monad((>>=), (>>), return, fail),
-    Functor(fmap),
-    mapM, mapM_, sequence, sequence_, (=<<), 
-  ) where
+        -- ...and what the Prelude exports
+        Monad((>>=), (>>), return, fail),
+        Functor(fmap),
+        mapM, mapM_, sequence, sequence_, (=<<), 
+    ) where
 
 import Control.Monad
diff --git a/Numeric.hs b/Numeric.hs
--- a/Numeric.hs
+++ b/Numeric.hs
@@ -1,4 +1,7 @@
 {-# LANGUAGE PackageImports #-}
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
 
 module Numeric (
 
@@ -27,7 +30,7 @@
         readSigned,       -- :: (Real a) => ReadS a -> ReadS a
 
         readInt,          -- :: (Integral a) => a -> (Char -> Bool)
-                          --         -> (Char -> Int) -> ReadS a
+                      --         -> (Char -> Int) -> ReadS a
         readDec,          -- :: (Integral a) => ReadS a
         readOct,          -- :: (Integral a) => ReadS a
         readHex,          -- :: (Integral a) => ReadS a
@@ -40,6 +43,6 @@
 
         fromRat,          -- :: (RealFloat a) => Rational -> a
 
-        ) where
+    ) where
 
 import "base" Numeric
diff --git a/Prelude.hs b/Prelude.hs
--- a/Prelude.hs
+++ b/Prelude.hs
@@ -1,4 +1,7 @@
-{-# LANGUAGE CPP, NoImplicitPrelude, BangPatterns, PackageImports #-}
+{-# LANGUAGE NoImplicitPrelude, BangPatterns, PackageImports #-}
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Trustworthy #-}
+#endif
 
 -- |
 -- The Haskell 98 Prelude: a standard module imported by default
@@ -7,131 +10,131 @@
 
 module Prelude (
 
-    -- * Standard types, classes and related functions
+        -- * Standard types, classes and related functions
 
-    -- ** Basic data types
-    Bool(False, True),
-    (&&), (||), not, otherwise,
+        -- ** Basic data types
+        Bool(False, True),
+        (&&), (||), not, otherwise,
 
-    Maybe(Nothing, Just),
-    maybe,
+        Maybe(Nothing, Just),
+        maybe,
 
-    Either(Left, Right),
-    either,
+        Either(Left, Right),
+        either,
 
-    Ordering(LT, EQ, GT),
-    Char, String,
+        Ordering(LT, EQ, GT),
+        Char, String,
 
-    -- *** Tuples
-    fst, snd, curry, uncurry,
+        -- *** Tuples
+        fst, snd, curry, uncurry,
 
 #if defined(__NHC__)
-    []((:), []),        -- Not legal Haskell 98;
-                        -- ... available through built-in syntax
-    module Data.Tuple,  -- Includes tuple types
-    ()(..),             -- Not legal Haskell 98
-    (->),               -- ... available through built-in syntax
+        []((:), []),        -- Not legal Haskell 98;
+                            -- ... available through built-in syntax
+        module Data.Tuple,  -- Includes tuple types
+        ()(..),             -- Not legal Haskell 98
+        (->),               -- ... available through built-in syntax
 #endif
 #ifdef __HUGS__
-    (:),                -- Not legal Haskell 98
+        (:),                -- Not legal Haskell 98
 #endif
 
-    -- ** Basic type classes
-    Eq((==), (/=)),
-    Ord(compare, (<), (<=), (>=), (>), max, min),
-    Enum(succ, pred, toEnum, fromEnum, enumFrom, enumFromThen,
-         enumFromTo, enumFromThenTo),
-    Bounded(minBound, maxBound),
+        -- ** Basic type classes
+        Eq((==), (/=)),
+        Ord(compare, (<), (<=), (>=), (>), max, min),
+        Enum(succ, pred, toEnum, fromEnum, enumFrom, enumFromThen,
+             enumFromTo, enumFromThenTo),
+        Bounded(minBound, maxBound),
 
-    -- ** Numbers
+        -- ** Numbers
 
-    -- *** Numeric types
-    Int, Integer, Float, Double,
-    Rational,
+        -- *** Numeric types
+        Int, Integer, Float, Double,
+        Rational,
 
-    -- *** Numeric type classes
-    Num((+), (-), (*), negate, abs, signum, fromInteger),
-    Real(toRational),
-    Integral(quot, rem, div, mod, quotRem, divMod, toInteger),
-    Fractional((/), recip, fromRational),
-    Floating(pi, exp, log, sqrt, (**), logBase, sin, cos, tan,
-             asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh),
-    RealFrac(properFraction, truncate, round, ceiling, floor),
-    RealFloat(floatRadix, floatDigits, floatRange, decodeFloat,
-              encodeFloat, exponent, significand, scaleFloat, isNaN,
-              isInfinite, isDenormalized, isIEEE, isNegativeZero, atan2),
+        -- *** Numeric type classes
+        Num((+), (-), (*), negate, abs, signum, fromInteger),
+        Real(toRational),
+        Integral(quot, rem, div, mod, quotRem, divMod, toInteger),
+        Fractional((/), recip, fromRational),
+        Floating(pi, exp, log, sqrt, (**), logBase, sin, cos, tan,
+                 asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh),
+        RealFrac(properFraction, truncate, round, ceiling, floor),
+        RealFloat(floatRadix, floatDigits, floatRange, decodeFloat,
+                  encodeFloat, exponent, significand, scaleFloat, isNaN,
+                  isInfinite, isDenormalized, isIEEE, isNegativeZero, atan2),
 
-    -- *** Numeric functions
-    subtract, even, odd, gcd, lcm, (^), (^^),
-    fromIntegral, realToFrac,
+        -- *** Numeric functions
+        subtract, even, odd, gcd, lcm, (^), (^^),
+        fromIntegral, realToFrac,
 
-    -- ** Monads and functors
-    Monad((>>=), (>>), return, fail),
-    Functor(fmap),
-    mapM, mapM_, sequence, sequence_, (=<<),
+        -- ** Monads and functors
+        Monad((>>=), (>>), return, fail),
+        Functor(fmap),
+        mapM, mapM_, sequence, sequence_, (=<<),
 
-    -- ** Miscellaneous functions
-    id, const, (.), flip, ($), until,
-    asTypeOf, error, undefined,
-    seq, ($!),
+        -- ** Miscellaneous functions
+        id, const, (.), flip, ($), until,
+        asTypeOf, error, undefined,
+        seq, ($!),
 
-    -- * List operations
-    map, (++), filter,
-    head, last, tail, init, null, length, (!!),
-    reverse,
-    -- ** Reducing lists (folds)
-    foldl, foldl1, foldr, foldr1,
-    -- *** Special folds
-    and, or, any, all,
-    sum, product,
-    concat, concatMap,
-    maximum, minimum,
-    -- ** Building lists
-    -- *** Scans
-    scanl, scanl1, scanr, scanr1,
-    -- *** Infinite lists
-    iterate, repeat, replicate, cycle,
-    -- ** Sublists
-    take, drop, splitAt, takeWhile, dropWhile, span, break,
-    -- ** Searching lists
-    elem, notElem, lookup,
-    -- ** Zipping and unzipping lists
-    zip, zip3, zipWith, zipWith3, unzip, unzip3,
-    -- ** Functions on strings
-    lines, words, unlines, unwords,
+        -- * List operations
+        map, (++), filter,
+        head, last, tail, init, null, length, (!!),
+        reverse,
+        -- ** Reducing lists (folds)
+        foldl, foldl1, foldr, foldr1,
+        -- *** Special folds
+        and, or, any, all,
+        sum, product,
+        concat, concatMap,
+        maximum, minimum,
+        -- ** Building lists
+        -- *** Scans
+        scanl, scanl1, scanr, scanr1,
+        -- *** Infinite lists
+        iterate, repeat, replicate, cycle,
+        -- ** Sublists
+        take, drop, splitAt, takeWhile, dropWhile, span, break,
+        -- ** Searching lists
+        elem, notElem, lookup,
+        -- ** Zipping and unzipping lists
+        zip, zip3, zipWith, zipWith3, unzip, unzip3,
+        -- ** Functions on strings
+        lines, words, unlines, unwords,
 
-    -- * Converting to and from @String@
-    -- ** Converting to @String@
-    ShowS,
-    Show(showsPrec, showList, show),
-    shows,
-    showChar, showString, showParen,
-    -- ** Converting from @String@
-    ReadS,
-    Read(readsPrec, readList),
-    reads, readParen, read, lex,
+        -- * Converting to and from @String@
+        -- ** Converting to @String@
+        ShowS,
+        Show(showsPrec, showList, show),
+        shows,
+        showChar, showString, showParen,
+        -- ** Converting from @String@
+        ReadS,
+        Read(readsPrec, readList),
+        reads, readParen, read, lex,
 
-    -- * Basic Input and output
-    IO,
-    -- ** Simple I\/O operations
-    -- All I/O functions defined here are character oriented.  The
-    -- treatment of the newline character will vary on different systems.
-    -- For example, two characters of input, return and linefeed, may
-    -- read as a single newline character.  These functions cannot be
-    -- used portably for binary I/O.
-    -- *** Output functions
-    putChar,
-    putStr, putStrLn, print,
-    -- *** Input functions
-    getChar,
-    getLine, getContents, interact,
-    -- *** Files
-    FilePath,
-    readFile, writeFile, appendFile, readIO, readLn,
-    -- ** Exception handling in the I\/O monad
-    IOError, ioError, userError, catch
+        -- * Basic Input and output
+        IO,
+        -- ** Simple I\/O operations
+        -- All I/O functions defined here are character oriented.  The
+        -- treatment of the newline character will vary on different systems.
+        -- For example, two characters of input, return and linefeed, may
+        -- read as a single newline character.  These functions cannot be
+        -- used portably for binary I/O.
+        -- *** Output functions
+        putChar,
+        putStr, putStrLn, print,
+        -- *** Input functions
+        getChar,
+        getLine, getContents, interact,
+        -- *** Files
+        FilePath,
+        readFile, writeFile, appendFile, readIO, readLn,
+        -- ** Exception handling in the I\/O monad
+        IOError, ioError, userError, catch
 
-  ) where
+    ) where
 
 #ifndef __HUGS__
 import qualified "base" Control.Exception.Base as New (catch)
diff --git a/Ptr.hs b/Ptr.hs
--- a/Ptr.hs
+++ b/Ptr.hs
@@ -1,2 +1,6 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Ptr (module Foreign.Ptr) where
 import Foreign.Ptr
diff --git a/Random.hs b/Random.hs
--- a/Random.hs
+++ b/Random.hs
@@ -1,7 +1,8 @@
-{-# LANGUAGE CPP #-}
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Trustworthy #-}
+#endif
 
-module Random
-        (
+module Random (
 
         -- $intro
 
@@ -30,7 +31,7 @@
         -- * References
         -- $references
 
-        ) where
+    ) where
 
 import Prelude
 
@@ -81,7 +82,7 @@
    -- generators. This is very useful in functional programs (for example, when
    -- passing a random number generator down to recursive calls), but very
    -- little work has been done on statistically robust implementations of
-   -- 'split' (["System.Random\#Burton", "System.Random\#Hellekalek"]
+   -- 'split' (["Random\#Burton", "Random\#Hellekalek"]
    -- are the only examples we know of).
    split    :: g -> (g, g)
 
@@ -112,7 +113,7 @@
 
 The result of repeatedly using 'next' should be at least as statistically
 robust as the /Minimal Standard Random Number Generator/ described by
-["System.Random\#Park", "System.Random\#Carta"].
+["Random\#Park", "Random\#Carta"].
 Until more is known about implementations of 'split', all we require is
 that 'split' deliver generators that are (a) not identical and
 (b) independently robust in the sense just given.
@@ -228,12 +229,12 @@
   randoms  g      = (\(x,g') -> x : randoms g') (random g)
 
   -- | A variant of 'randomR' that uses the global random number generator
-  -- (see "System.Random#globalrng").
+  -- (see "Random#globalrng").
   randomRIO :: (a,a) -> IO a
   randomRIO range  = getStdRandom (randomR range)
 
   -- | A variant of 'random' that uses the global random number generator
-  -- (see "System.Random#globalrng").
+  -- (see "Random#globalrng").
   randomIO  :: IO a
   randomIO         = getStdRandom random
 
diff --git a/Ratio.hs b/Ratio.hs
--- a/Ratio.hs
+++ b/Ratio.hs
@@ -1,5 +1,9 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Ratio (
-    Ratio, Rational, (%), numerator, denominator, approxRational
-  ) where
+        Ratio, Rational, (%), numerator, denominator, approxRational
+    ) where
 
 import Data.Ratio
diff --git a/StablePtr.hs b/StablePtr.hs
--- a/StablePtr.hs
+++ b/StablePtr.hs
@@ -1,2 +1,6 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module StablePtr (module Foreign.StablePtr) where
 import Foreign.StablePtr
diff --git a/Storable.hs b/Storable.hs
--- a/Storable.hs
+++ b/Storable.hs
@@ -1,2 +1,6 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
 module Storable (module Foreign.Storable) where
 import Foreign.Storable
diff --git a/System.hs b/System.hs
--- a/System.hs
+++ b/System.hs
@@ -1,7 +1,11 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Trustworthy #-}
+#endif
+
 module System (
-    ExitCode(ExitSuccess,ExitFailure),
-    getArgs, getProgName, getEnv, system, exitWith, exitFailure
-  ) where
+        ExitCode(ExitSuccess,ExitFailure),
+        getArgs, getProgName, getEnv, system, exitWith, exitFailure
+    ) where
 
 import System.Exit
 import System.Environment
diff --git a/Time.hs b/Time.hs
--- a/Time.hs
+++ b/Time.hs
@@ -1,15 +1,19 @@
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Trustworthy #-}
+#endif
+
 module Time (
-    ClockTime, 
-    Month(January,February,March,April,May,June,
-          July,August,September,October,November,December),
-    Day(Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday),
-    CalendarTime(CalendarTime, ctYear, ctMonth, ctDay, ctHour, ctMin,
-    		 ctSec, ctPicosec, ctWDay, ctYDay, ctTZName, ctTZ, ctIsDST),
-    TimeDiff(TimeDiff, tdYear, tdMonth, tdDay, tdHour,
- 	     tdMin, tdSec, tdPicosec),
-    getClockTime, addToClockTime, diffClockTimes,
-    toCalendarTime, toUTCTime, toClockTime,
-    calendarTimeToString, formatCalendarTime 
-  ) where
+        ClockTime, 
+        Month(January,February,March,April,May,June,
+              July,August,September,October,November,December),
+        Day(Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday),
+        CalendarTime(CalendarTime, ctYear, ctMonth, ctDay, ctHour, ctMin,
+                     ctSec, ctPicosec, ctWDay, ctYDay, ctTZName, ctTZ, ctIsDST),
+        TimeDiff(TimeDiff, tdYear, tdMonth, tdDay, tdHour,
+                 tdMin, tdSec, tdPicosec),
+        getClockTime, addToClockTime, diffClockTimes,
+        toCalendarTime, toUTCTime, toClockTime,
+        calendarTimeToString, formatCalendarTime 
+    ) where
 
 import System.Time
diff --git a/Word.hs b/Word.hs
--- a/Word.hs
+++ b/Word.hs
@@ -1,2 +1,6 @@
-module Word ( module Data.Word ) where
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
+module Word (module Data.Word) where
 import Data.Word
diff --git a/haskell98.cabal b/haskell98.cabal
--- a/haskell98.cabal
+++ b/haskell98.cabal
@@ -1,5 +1,5 @@
 name:		haskell98
-version:	2.0.0.0
+version:	2.0.0.1
 license:	BSD3
 license-file:	LICENSE
 maintainer:	libraries@haskell.org
@@ -19,11 +19,11 @@
 Library
     build-depends:	base        >= 3   && < 5,
                     directory   >= 1.1 && < 1.2,
-                    old-time    >= 1.0 && < 1.1,
+                    old-time    >= 1.0 && < 1.2,
                     old-locale  >= 1.0 && < 1.1,
                     process     >= 1.0 && < 1.2,
-                    array       >= 0.3 && < 0.4,
-                    time        >= 1.2 && < 1.3
+                    array       >= 0.3 && < 0.5,
+                    time        >= 1.2 && < 1.5
     exposed-modules:
         -- Haskell 98
         Prelude, Array, CPUTime, Char, Complex, Directory, IO,
@@ -34,6 +34,7 @@
         MarshalAlloc, MarshalArray, MarshalError, MarshalUtils, Ptr,
         StablePtr, Storable, Word
     exposed: False
+    extensions: CPP
 
 source-repository head
     type:     git