diff --git a/Array.hs b/Array.hs
--- a/Array.hs
+++ b/Array.hs
@@ -1,8 +1,13 @@
+{-# LANGUAGE CPP #-}
+#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,8 @@
+{-# LANGUAGE CPP #-}
+#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,8 @@
+{-# LANGUAGE CPP #-}
+#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,7 @@
-module CForeign ( module Foreign.C ) where
+{-# LANGUAGE CPP #-}
+#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,9 @@
-module CPUTime (
- getCPUTime, cpuTimePrecision
- ) where
+{-# LANGUAGE CPP #-}
+#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,7 @@
+{-# LANGUAGE CPP #-}
+#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,7 @@
+{-# LANGUAGE CPP #-}
+#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,18 @@
+{-# LANGUAGE CPP #-}
+#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,11 @@
+{-# LANGUAGE CPP #-}
+#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,17 @@
+{-# LANGUAGE CPP #-}
+#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,7 @@
+{-# LANGUAGE CPP #-}
+#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,26 +1,31 @@
+{-# LANGUAGE CPP #-}
+#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
@@ -56,3 +61,14 @@
case rs of
Right r -> return r
Left e -> ioError e
+
+-- | The construct 'try' @comp@ exposes IO errors which occur within a
+-- computation, and which are not fully handled.
+--
+-- Non-I\/O exceptions are not caught by this variant; to catch all
+-- exceptions, use 'Control.Exception.try' from "Control.Exception".
+try :: IO a -> IO (Either IOError a)
+try f = catch (do r <- f
+ return (Right r))
+ (return . Left)
+
diff --git a/Int.hs b/Int.hs
--- a/Int.hs
+++ b/Int.hs
@@ -1,2 +1,7 @@
-module Int ( module Data.Int ) where
+{-# LANGUAGE CPP #-}
+#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,10 @@
+{-# LANGUAGE CPP #-}
+#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,34 @@
+{-# LANGUAGE CPP #-}
+#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')
+import Data.List hiding (foldl', splitAt)
diff --git a/Locale.hs b/Locale.hs
--- a/Locale.hs
+++ b/Locale.hs
@@ -1,10 +1,15 @@
+{-# LANGUAGE CPP #-}
+#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
- TimeLocale(TimeLocale,wDays,months,amPm,dateTimeFmt,
- dateFmt,timeFmt,time12Fmt),
+import System.Locale (
+ -- just the bits that are specified by Haskell 98
+ TimeLocale(TimeLocale,wDays,months,amPm,dateTimeFmt,
+ dateFmt,timeFmt,time12Fmt),
defaultTimeLocale
)
diff --git a/MarshalAlloc.hs b/MarshalAlloc.hs
--- a/MarshalAlloc.hs
+++ b/MarshalAlloc.hs
@@ -1,2 +1,7 @@
+{-# LANGUAGE CPP #-}
+#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,7 @@
+{-# LANGUAGE CPP #-}
+#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,16 +1,21 @@
+{-# LANGUAGE CPP #-}
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
module MarshalError (
- module Foreign.Marshal.Error,
- IOErrorType,
- mkIOError,
- alreadyExistsErrorType,
- doesNotExistErrorType,
- alreadyInUseErrorType,
- fullErrorType,
- eofErrorType,
- illegalOperationErrorType,
- permissionErrorType,
- userErrorType,
- annotateIOError
+ module Foreign.Marshal.Error,
+ IOErrorType,
+ mkIOError,
+ alreadyExistsErrorType,
+ doesNotExistErrorType,
+ alreadyInUseErrorType,
+ fullErrorType,
+ eofErrorType,
+ illegalOperationErrorType,
+ permissionErrorType,
+ userErrorType,
+ annotateIOError
) where
import System.IO.Error
diff --git a/MarshalUtils.hs b/MarshalUtils.hs
--- a/MarshalUtils.hs
+++ b/MarshalUtils.hs
@@ -1,2 +1,7 @@
+{-# LANGUAGE CPP #-}
+#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,16 @@
+{-# LANGUAGE CPP #-}
+#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,19 @@
+{-# LANGUAGE CPP #-}
+#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
new file mode 100644
--- /dev/null
+++ b/Numeric.hs
@@ -0,0 +1,48 @@
+{-# LANGUAGE CPP, PackageImports #-}
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
+module Numeric (
+
+ -- * Showing
+
+ showSigned, -- :: (Real a) => (a -> ShowS) -> Int -> a -> ShowS
+
+ showIntAtBase, -- :: Integral a => a -> (a -> Char) -> a -> ShowS
+ showInt, -- :: Integral a => a -> ShowS
+ showHex, -- :: Integral a => a -> ShowS
+ showOct, -- :: Integral a => a -> ShowS
+
+ showEFloat, -- :: (RealFloat a) => Maybe Int -> a -> ShowS
+ showFFloat, -- :: (RealFloat a) => Maybe Int -> a -> ShowS
+ showGFloat, -- :: (RealFloat a) => Maybe Int -> a -> ShowS
+ showFloat, -- :: (RealFloat a) => a -> ShowS
+
+ floatToDigits, -- :: (RealFloat a) => Integer -> a -> ([Int], Int)
+
+ -- * Reading
+
+ -- | /NB:/ 'readInt' is the \'dual\' of 'showIntAtBase',
+ -- and 'readDec' is the \`dual\' of 'showInt'.
+ -- The inconsistent naming is a historical accident.
+
+ readSigned, -- :: (Real a) => ReadS a -> ReadS a
+
+ readInt, -- :: (Integral a) => a -> (Char -> Bool)
+ -- -> (Char -> Int) -> ReadS a
+ readDec, -- :: (Integral a) => ReadS a
+ readOct, -- :: (Integral a) => ReadS a
+ readHex, -- :: (Integral a) => ReadS a
+
+ readFloat, -- :: (RealFloat a) => ReadS a
+
+ lexDigits, -- :: ReadS String
+
+ -- * Miscellaneous
+
+ fromRat, -- :: (RealFloat a) => Rational -> a
+
+ ) where
+
+import "base" Numeric
diff --git a/Prelude.hs b/Prelude.hs
new file mode 100644
--- /dev/null
+++ b/Prelude.hs
@@ -0,0 +1,235 @@
+{-# LANGUAGE BangPatterns, CPP, NoImplicitPrelude, PackageImports #-}
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Trustworthy #-}
+#endif
+
+-- |
+-- The Haskell 98 Prelude: a standard module imported by default
+-- into all Haskell modules. For more documentation, see the Haskell 98
+-- Report .
+
+module Prelude (
+
+ -- * Standard types, classes and related functions
+
+ -- ** Basic data types
+ Bool(False, True),
+ (&&), (||), not, otherwise,
+
+ Maybe(Nothing, Just),
+ maybe,
+
+ Either(Left, Right),
+ either,
+
+ Ordering(LT, EQ, GT),
+ Char, String,
+
+ -- *** Tuples
+ fst, snd, curry, uncurry,
+
+#ifdef __HUGS__
+ (:), -- 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),
+
+ -- ** Numbers
+
+ -- *** 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 functions
+ subtract, even, odd, gcd, lcm, (^), (^^),
+ fromIntegral, realToFrac,
+
+ -- ** Monads and functors
+ Monad((>>=), (>>), return, fail),
+ Functor(fmap),
+ mapM, mapM_, sequence, sequence_, (=<<),
+
+ -- ** 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,
+
+ -- * 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
+
+ ) where
+
+#ifndef __HUGS__
+import qualified "base" Control.Exception.Base as New (catch)
+import "base" Control.Monad
+import "base" System.IO
+import "base" System.IO.Error (IOError, ioError, userError)
+import "base" Data.List hiding ( splitAt )
+import "base" Data.Either
+import "base" Data.Maybe
+import "base" Data.Tuple
+#endif
+
+#ifdef __GLASGOW_HASKELL__
+import GHC.Base
+-- import GHC.IO
+-- import GHC.IO.Exception
+import Text.Read
+import GHC.Enum
+import GHC.Num
+import GHC.Real hiding ( gcd )
+import qualified GHC.Real ( gcd )
+import GHC.Float
+import GHC.Show
+#endif
+
+#ifdef __HUGS__
+import Hugs.Prelude
+#endif
+
+#ifndef __HUGS__
+infixr 0 $!
+#endif
+
+-- -----------------------------------------------------------------------------
+-- Miscellaneous functions
+
+-- | Strict (call-by-value) application, defined in terms of 'seq'.
+($!) :: (a -> b) -> a -> b
+#ifdef __GLASGOW_HASKELL__
+f $! x = let !vx = x in f vx -- see #2273
+#elif !defined(__HUGS__)
+f $! x = x `seq` f x
+#endif
+
+#ifdef __HADDOCK__
+-- | The value of @'seq' a b@ is bottom if @a@ is bottom, and otherwise
+-- equal to @b@. 'seq' is usually introduced to improve performance by
+-- avoiding unneeded laziness.
+seq :: a -> b -> b
+seq _ y = y
+#endif
+
+-- | The 'catch' function establishes a handler that receives any
+-- 'IOError' raised in the action protected by 'catch'.
+-- An 'IOError' is caught by
+-- the most recent handler established by one of the exception handling
+-- functions. These handlers are
+-- not selective: all 'IOError's are caught. Exception propagation
+-- must be explicitly provided in a handler by re-raising any unwanted
+-- exceptions. For example, in
+--
+-- > f = catch g (\e -> if IO.isEOFError e then return [] else ioError e)
+--
+-- the function @f@ returns @[]@ when an end-of-file exception
+-- (cf. 'System.IO.Error.isEOFError') occurs in @g@; otherwise, the
+-- exception is propagated to the next outer handler.
+--
+-- When an exception propagates outside the main program, the Haskell
+-- system prints the associated 'IOError' value and exits the program.
+--
+-- Non-I\/O exceptions are not caught by this variant; to catch all
+-- exceptions, use 'Control.Exception.catch' from "Control.Exception".
+catch :: IO a -> (IOError -> IO a) -> IO a
+catch = New.catch
+
+#ifdef __GLASGOW_HASKELL__
+-- | @'gcd' x y@ is the greatest (positive) integer that divides both @x@
+-- and @y@; for example @'gcd' (-3) 6@ = @3@, @'gcd' (-3) (-6)@ = @3@,
+-- @'gcd' 0 4@ = @4@. @'gcd' 0 0@ raises a runtime error.
+gcd :: (Integral a) => a -> a -> a
+gcd 0 0 = error "Prelude.gcd: gcd 0 0 is undefined"
+gcd x y = GHC.Real.gcd x y
+#endif
+
+#ifndef __HUGS__
+-- The GHC's version of 'splitAt' is too strict in 'n' compared to
+-- Haskell98/2010 version. Ticket #1182.
+
+-- | 'splitAt' @n xs@ returns a tuple where first element is @xs@ prefix of
+-- length @n@ and second element is the remainder of the list:
+--
+-- > splitAt 6 "Hello World!" == ("Hello ","World!")
+-- > splitAt 3 [1,2,3,4,5] == ([1,2,3],[4,5])
+-- > splitAt 1 [1,2,3] == ([1],[2,3])
+-- > splitAt 3 [1,2,3] == ([1,2,3],[])
+-- > splitAt 4 [1,2,3] == ([1,2,3],[])
+-- > splitAt 0 [1,2,3] == ([],[1,2,3])
+-- > splitAt (-1) [1,2,3] == ([],[1,2,3])
+--
+-- It is equivalent to @('take' n xs, 'drop' n xs)@.
+-- 'splitAt' is an instance of the more general 'Data.List.genericSplitAt',
+-- in which @n@ may be of any integral type.
+splitAt :: Int -> [a] -> ([a],[a])
+splitAt n xs = (take n xs, drop n xs)
+#endif
diff --git a/Ptr.hs b/Ptr.hs
--- a/Ptr.hs
+++ b/Ptr.hs
@@ -1,2 +1,7 @@
+{-# LANGUAGE CPP #-}
+#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,8 +1,407 @@
+{-# LANGUAGE CPP #-}
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Trustworthy #-}
+#endif
+
module Random (
- RandomGen(next, split, genRange),
- StdGen, mkStdGen,
- Random( random, randomR, randoms, randomRs, randomIO, randomRIO ),
- getStdRandom, getStdGen, setStdGen, newStdGen
- ) where
-import System.Random
+ -- $intro
+
+ -- * Random number generators
+
+ RandomGen(next, split, genRange)
+
+ -- ** Standard random number generators
+ , StdGen
+ , mkStdGen
+
+ -- ** The global random number generator
+
+ -- $globalrng
+
+ , getStdRandom
+ , getStdGen
+ , setStdGen
+ , newStdGen
+
+ -- * Random values of various types
+ , Random ( random, randomR,
+ randoms, randomRs,
+ randomIO, randomRIO )
+
+ -- * References
+ -- $references
+
+ ) where
+
+import Prelude
+
+import Data.Int
+
+import System.CPUTime ( getCPUTime )
+import Data.Time ( getCurrentTime, UTCTime(..) )
+import Data.Ratio ( numerator, denominator )
+import Data.Char ( isSpace, chr, ord )
+import System.IO.Unsafe ( unsafePerformIO )
+import Data.IORef
+import Numeric ( readDec )
+
+-- The standard nhc98 implementation of Time.ClockTime does not match
+-- the extended one expected in this module, so we lash-up a quick
+-- replacement here.
+getTime :: IO (Integer, Integer)
+getTime = do
+ utc <- getCurrentTime
+ let daytime = toRational $ utctDayTime utc
+ return $ quotRem (numerator daytime) (denominator daytime)
+
+-- | The class 'RandomGen' provides a common interface to random number
+-- generators.
+--
+-- Minimal complete definition: 'next' and 'split'.
+
+class RandomGen g where
+
+ -- |The 'next' operation returns an 'Int' that is uniformly distributed
+ -- in the range returned by 'genRange' (including both end points),
+ -- and a new generator.
+ next :: g -> (Int, g)
+
+ -- |The 'split' operation allows one to obtain two distinct random number
+ -- 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' (["Random\#Burton", "Random\#Hellekalek"]
+ -- are the only examples we know of).
+ split :: g -> (g, g)
+
+ -- |The 'genRange' operation yields the range of values returned by
+ -- the generator.
+ --
+ -- It is required that:
+ --
+ -- * If @(a,b) = 'genRange' g@, then @a < b@.
+ --
+ -- * 'genRange' always returns a pair of defined 'Int's.
+ --
+ -- The second condition ensures that 'genRange' cannot examine its
+ -- argument, and hence the value it returns can be determined only by the
+ -- instance of 'RandomGen'. That in turn allows an implementation to make
+ -- a single call to 'genRange' to establish a generator's range, without
+ -- being concerned that the generator returned by (say) 'next' might have
+ -- a different range to the generator passed to 'next'.
+ --
+ -- The default definition spans the full range of 'Int'.
+ genRange :: g -> (Int,Int)
+
+ -- default method
+ genRange _ = (minBound, maxBound)
+
+{- |
+The 'StdGen' instance of 'RandomGen' has a 'genRange' of at least 30 bits.
+
+The result of repeatedly using 'next' should be at least as statistically
+robust as the /Minimal Standard Random Number Generator/ described by
+["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.
+
+The 'Show' and 'Read' instances of 'StdGen' provide a primitive way to save the
+state of a random number generator.
+It is required that @'read' ('show' g) == g@.
+
+In addition, 'reads' may be used to map an arbitrary string (not necessarily one
+produced by 'show') onto a value of type 'StdGen'. In general, the 'Read'
+instance of 'StdGen' has the following properties:
+
+* It guarantees to succeed on any string.
+
+* It guarantees to consume only a finite portion of the string.
+
+* Different argument strings are likely to result in different results.
+
+-}
+
+data StdGen
+ = StdGen Int32 Int32
+
+instance RandomGen StdGen where
+ next = stdNext
+ split = stdSplit
+ genRange _ = stdRange
+
+instance Show StdGen where
+ showsPrec p (StdGen s1 s2) =
+ showsPrec p s1 .
+ showChar ' ' .
+ showsPrec p s2
+
+instance Read StdGen where
+ readsPrec _p = \ r ->
+ case try_read r of
+ r'@[_] -> r'
+ _ -> [stdFromString r] -- because it shouldn't ever fail.
+ where
+ try_read r = do
+ (s1, r1) <- readDec (dropWhile isSpace r)
+ (s2, r2) <- readDec (dropWhile isSpace r1)
+ return (StdGen s1 s2, r2)
+
+{-
+ If we cannot unravel the StdGen from a string, create
+ one based on the string given.
+-}
+stdFromString :: String -> (StdGen, String)
+stdFromString s = (mkStdGen num, rest)
+ where (cs, rest) = splitAt 6 s
+ num = foldl (\a x -> x + 3 * a) 1 (map ord cs)
+
+
+{- |
+The function 'mkStdGen' provides an alternative way of producing an initial
+generator, by mapping an 'Int' into a generator. Again, distinct arguments
+should be likely to produce distinct generators.
+-}
+mkStdGen :: Int -> StdGen -- why not Integer ?
+mkStdGen s = mkStdGen32 $ fromIntegral s
+
+mkStdGen32 :: Int32 -> StdGen
+mkStdGen32 s
+ | s < 0 = mkStdGen32 (-s)
+ | otherwise = StdGen (s1+1) (s2+1)
+ where
+ (q, s1) = s `divMod` 2147483562
+ s2 = q `mod` 2147483398
+
+createStdGen :: Integer -> StdGen
+createStdGen s = mkStdGen32 $ fromIntegral s
+
+-- FIXME: 1/2/3 below should be ** (vs@30082002) XXX
+
+{- |
+With a source of random number supply in hand, the 'Random' class allows the
+programmer to extract random values of a variety of types.
+
+Minimal complete definition: 'randomR' and 'random'.
+
+-}
+
+class Random a where
+ -- | Takes a range /(lo,hi)/ and a random number generator
+ -- /g/, and returns a random value uniformly distributed in the closed
+ -- interval /[lo,hi]/, together with a new generator. It is unspecified
+ -- what happens if /lo>hi/. For continuous types there is no requirement
+ -- that the values /lo/ and /hi/ are ever produced, but they may be,
+ -- depending on the implementation and the interval.
+ randomR :: RandomGen g => (a,a) -> g -> (a,g)
+
+ -- | The same as 'randomR', but using a default range determined by the type:
+ --
+ -- * For bounded types (instances of 'Bounded', such as 'Char'),
+ -- the range is normally the whole type.
+ --
+ -- * For fractional types, the range is normally the semi-closed interval
+ -- @[0,1)@.
+ --
+ -- * For 'Integer', the range is (arbitrarily) the range of 'Int'.
+ random :: RandomGen g => g -> (a, g)
+
+ -- | Plural variant of 'randomR', producing an infinite list of
+ -- random values instead of returning a new generator.
+ randomRs :: RandomGen g => (a,a) -> g -> [a]
+ randomRs ival g = x : randomRs ival g' where (x,g') = randomR ival g
+
+ -- | Plural variant of 'random', producing an infinite list of
+ -- random values instead of returning a new generator.
+ randoms :: RandomGen g => g -> [a]
+ randoms g = (\(x,g') -> x : randoms g') (random g)
+
+ -- | A variant of 'randomR' that uses the global random number generator
+ -- (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 "Random#globalrng").
+ randomIO :: IO a
+ randomIO = getStdRandom random
+
+
+instance Random Int where
+ randomR (a,b) g = randomIvalInteger (toInteger a, toInteger b) g
+ random g = randomR (minBound,maxBound) g
+
+instance Random Char where
+ randomR (a,b) g =
+ case (randomIvalInteger (toInteger (ord a), toInteger (ord b)) g) of
+ (x,g') -> (chr x, g')
+ random g = randomR (minBound,maxBound) g
+
+instance Random Bool where
+ randomR (a,b) g =
+ case (randomIvalInteger (bool2Int a, bool2Int b) g) of
+ (x, g') -> (int2Bool x, g')
+ where
+ bool2Int :: Bool -> Integer
+ bool2Int False = 0
+ bool2Int True = 1
+
+ int2Bool :: Int -> Bool
+ int2Bool 0 = False
+ int2Bool _ = True
+
+ random g = randomR (minBound,maxBound) g
+
+instance Random Integer where
+ randomR ival g = randomIvalInteger ival g
+ random g = randomR (toInteger (minBound::Int), toInteger (maxBound::Int)) g
+
+instance Random Double where
+ randomR ival g = randomIvalDouble ival id g
+ random g = randomR (0::Double,1) g
+
+-- hah, so you thought you were saving cycles by using Float?
+instance Random Float where
+ random g = randomIvalDouble (0::Double,1) realToFrac g
+ randomR (a,b) g = randomIvalDouble (realToFrac a, realToFrac b) realToFrac g
+
+mkStdRNG :: Integer -> IO StdGen
+mkStdRNG o = do
+ ct <- getCPUTime
+ (sec, psec) <- getTime
+ return (createStdGen (sec * 12345 + psec + ct + o))
+
+randomIvalInteger :: (RandomGen g, Num a) => (Integer, Integer) -> g -> (a, g)
+randomIvalInteger (l,h) rng
+ | l > h = randomIvalInteger (h,l) rng
+ | otherwise = case (f n 1 rng) of (v, rng') -> (fromInteger (l + v `mod` k), rng')
+ where
+ k = h - l + 1
+ b = 2147483561
+ n = iLogBase b k
+
+ f 0 acc g = (acc, g)
+ f n' acc g =
+ let
+ (x,g') = next g
+ in
+ f (n' - 1) (fromIntegral x + acc * b) g'
+
+randomIvalDouble :: (RandomGen g, Fractional a) => (Double, Double) -> (Double -> a) -> g -> (a, g)
+randomIvalDouble (l,h) fromDouble rng
+ | l > h = randomIvalDouble (h,l) fromDouble rng
+ | otherwise =
+ case (randomIvalInteger (toInteger (minBound::Int32), toInteger (maxBound::Int32)) rng) of
+ (x, rng') ->
+ let
+ scaled_x =
+ fromDouble ((l+h)/2) +
+ fromDouble ((h-l) / realToFrac int32Count) *
+ fromIntegral (x::Int32)
+ in
+ (scaled_x, rng')
+
+int32Count :: Integer
+int32Count = toInteger (maxBound::Int32) - toInteger (minBound::Int32) + 1
+
+iLogBase :: Integer -> Integer -> Integer
+iLogBase b i = if i < b then 1 else 1 + iLogBase b (i `div` b)
+
+stdRange :: (Int,Int)
+stdRange = (0, 2147483562)
+
+stdNext :: StdGen -> (Int, StdGen)
+-- Returns values in the range stdRange
+stdNext (StdGen s1 s2) = (fromIntegral z', StdGen s1'' s2'')
+ where z' = if z < 1 then z + 2147483562 else z
+ z = s1'' - s2''
+
+ k = s1 `quot` 53668
+ s1' = 40014 * (s1 - k * 53668) - k * 12211
+ s1'' = if s1' < 0 then s1' + 2147483563 else s1'
+
+ k' = s2 `quot` 52774
+ s2' = 40692 * (s2 - k' * 52774) - k' * 3791
+ s2'' = if s2' < 0 then s2' + 2147483399 else s2'
+
+stdSplit :: StdGen -> (StdGen, StdGen)
+stdSplit std@(StdGen s1 s2)
+ = (left, right)
+ where
+ -- no statistical foundation for this!
+ left = StdGen new_s1 t2
+ right = StdGen t1 new_s2
+
+ new_s1 | s1 == 2147483562 = 1
+ | otherwise = s1 + 1
+
+ new_s2 | s2 == 1 = 2147483398
+ | otherwise = s2 - 1
+
+ StdGen t1 t2 = snd (next std)
+
+-- The global random number generator
+
+{- $globalrng #globalrng#
+
+There is a single, implicit, global random number generator of type
+'StdGen', held in some global variable maintained by the 'IO' monad. It is
+initialised automatically in some system-dependent fashion, for example, by
+using the time of day, or Linux's kernel random number generator. To get
+deterministic behaviour, use 'setStdGen'.
+-}
+
+-- |Sets the global random number generator.
+setStdGen :: StdGen -> IO ()
+setStdGen sgen = writeIORef theStdGen sgen
+
+-- |Gets the global random number generator.
+getStdGen :: IO StdGen
+getStdGen = readIORef theStdGen
+
+theStdGen :: IORef StdGen
+theStdGen = unsafePerformIO $ do
+ rng <- mkStdRNG 0
+ newIORef rng
+
+-- |Applies 'split' to the current global random generator,
+-- updates it with one of the results, and returns the other.
+newStdGen :: IO StdGen
+newStdGen = atomicModifyIORef theStdGen split
+
+{- |Uses the supplied function to get a value from the current global
+random generator, and updates the global generator with the new generator
+returned by the function. For example, @rollDice@ gets a random integer
+between 1 and 6:
+
+> rollDice :: IO Int
+> rollDice = getStdRandom (randomR (1,6))
+
+-}
+
+getStdRandom :: (StdGen -> (a,StdGen)) -> IO a
+getStdRandom f = atomicModifyIORef theStdGen (swap . f)
+ where swap (v,g) = (g,v)
+
+{- $references
+
+1. FW #Burton# Burton and RL Page, /Distributed random number generation/,
+Journal of Functional Programming, 2(2):203-212, April 1992.
+
+2. SK #Park# Park, and KW Miller, /Random number generators -
+good ones are hard to find/, Comm ACM 31(10), Oct 1988, pp1192-1201.
+
+3. DG #Carta# Carta, /Two fast implementations of the minimal standard
+random number generator/, Comm ACM, 33(1), Jan 1990, pp87-88.
+
+4. P #Hellekalek# Hellekalek, /Don\'t trust parallel Monte Carlo/,
+Department of Mathematics, University of Salzburg,
+, 1998.
+
+5. Pierre #LEcuyer# L'Ecuyer, /Efficient and portable combined random
+number generators/, Comm ACM, 31(6), Jun 1988, pp742-749.
+
+The Web site is a great source of information.
+
+-}
diff --git a/Ratio.hs b/Ratio.hs
--- a/Ratio.hs
+++ b/Ratio.hs
@@ -1,5 +1,10 @@
+{-# LANGUAGE CPP #-}
+#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,7 @@
+{-# LANGUAGE CPP #-}
+#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,7 @@
+{-# LANGUAGE CPP #-}
+#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,8 +1,13 @@
+{-# LANGUAGE CPP #-}
+#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
-import System.Cmd
+import System.Process
diff --git a/Time.hs b/Time.hs
--- a/Time.hs
+++ b/Time.hs
@@ -1,15 +1,20 @@
+{-# LANGUAGE CPP #-}
+#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,7 @@
-module Word ( module Data.Word ) where
+{-# LANGUAGE CPP #-}
+#if __GLASGOW_HASKELL__ >= 701
+{-# LANGUAGE Safe #-}
+#endif
+
+module Word (module Data.Word) where
import Data.Word
diff --git a/changelog.md b/changelog.md
new file mode 100644
--- /dev/null
+++ b/changelog.md
@@ -0,0 +1,11 @@
+# Changelog for [`haskell98` package](http://hackage.haskell.org/package/haskell98)
+
+## 2.0.0.3 *Mar 2014*
+
+ - Bundled with GHC 7.8.1
+
+ - Remove NHC98-specific code
+
+ - Adapt to changes in GHC 7.8's core-libaries
+
+ - Update to Cabal format 1.10
diff --git a/haskell98.cabal b/haskell98.cabal
--- a/haskell98.cabal
+++ b/haskell98.cabal
@@ -1,39 +1,94 @@
-name: haskell98
-version: 1.1.0.1
-license: BSD3
-license-file: LICENSE
-maintainer: libraries@haskell.org
-bug-reports: http://hackage.haskell.org/trac/ghc/newticket?component=libraries/haskell98
-synopsis: Compatibility with Haskell 98
-category: Haskell98
-description:
- This package provides compatibility with the modules of Haskell
- 98 and the FFI addendum, by means of wrappers around modules from
- the base package (which in many cases have additional features).
- However Prelude, Numeric and Foreign are provided directly by
- the base package.
-homepage: http://www.haskell.org/definition/
+name: haskell98
+version: 2.0.0.3
+-- GHC 7.6.1 released with 2.0.0.2
+license: BSD3
+license-file: LICENSE
+maintainer: libraries@haskell.org
+bug-reports: http://ghc.haskell.org/trac/ghc/newticket?component=libraries/haskell98
+synopsis: Compatibility with Haskell 98
+category: Haskell98, Prelude
+homepage: http://www.haskell.org/definition/
build-type: Simple
-Cabal-Version: >= 1.6
+cabal-version: >=1.10
+description:
+ This package provides compatibility with the modules of Haskell
+ 98 and the FFI addendum, by means of wrappers around modules from
+ the base package (which in many cases have additional features).
+ However "Prelude", "Numeric" and "Foreign" are provided directly by
+ the @base@ package.
+extra-source-files:
+ changelog.md
+
+source-repository head
+ type: git
+ location: http://git.haskell.org/packages/haskell98.git
+
+source-repository this
+ type: git
+ location: http://git.haskell.org/packages/haskell98.git
+ tag: haskell98-2.0.0.3-release
+
Library
- build-depends: base >= 3 && < 5,
- directory >= 1.1 && < 1.2,
- random >= 1.0 && < 1.1,
- old-time >= 1.0 && < 1.1,
- old-locale >= 1.0 && < 1.1,
- process >= 1.0 && < 1.1,
- array >= 0.3 && < 0.4
+ default-language: Haskell98
+ other-extensions:
+ BangPatterns
+ CPP
+ NoImplicitPrelude
+ PackageImports
+ if impl(ghc)
+ other-extensions:
+ Safe
+ Trustworthy
+
+ build-depends:
+ array >= 0.5 && < 0.6,
+ base >= 4.7 && < 4.8,
+ directory >= 1.2 && < 1.3,
+ old-locale >= 1.0 && < 1.1,
+ old-time >= 1.1 && < 1.2,
+ process >= 1.2 && < 1.3,
+ time >= 1.4 && < 1.5
+
+ -- haskell98 is a "hidden" package
+ exposed: False
+
exposed-modules:
- -- Haskell 98 (Prelude and Numeric are in the base package)
- Array, CPUTime, Char, Complex, Directory, IO, Ix, List, Locale,
- Maybe, Monad, Random, Ratio, System, Time,
- -- FFI addendum (Foreign is in the base package)
- Bits, CError, CForeign, CString, CTypes, ForeignPtr, Int,
- MarshalAlloc, MarshalArray, MarshalError, MarshalUtils, Ptr,
- StablePtr, Storable, Word
+ -- Haskell 98
+ Prelude
-source-repository head
- type: darcs
- location: http://darcs.haskell.org/packages/haskell98/
+ Array
+ CPUTime
+ Char
+ Complex
+ Directory
+ IO
+ Ix
+ List
+ Locale
+ Maybe
+ Monad
+ Numeric
+ Random
+ Ratio
+ System
+ Time
+ -- FFI addendum (Foreign is in the base package)
+ Bits
+ CError
+ CForeign
+ CString
+ CTypes
+ ForeignPtr
+ Int
+ MarshalAlloc
+ MarshalArray
+ MarshalError
+ MarshalUtils
+ Ptr
+ StablePtr
+ Storable
+ Word
+
+ ghc-options: -Wall