haskell98 1.0.1.1 → 2.0.0.3
raw patch · 34 files changed
Files
- Array.hs +9/−4
- Bits.hs +5/−0
- CError.hs +6/−0
- CForeign.hs +6/−1
- CPUTime.hs +7/−3
- CString.hs +5/−0
- CTypes.hs +5/−0
- Char.hs +14/−9
- Complex.hs +8/−3
- Directory.hs +42/−9
- ForeignPtr.hs +5/−0
- IO.hs +37/−21
- Int.hs +6/−1
- Ix.hs +7/−2
- List.hs +31/−26
- Locale.hs +11/−6
- MarshalAlloc.hs +5/−0
- MarshalArray.hs +5/−0
- MarshalError.hs +17/−12
- MarshalUtils.hs +5/−0
- Maybe.hs +12/−7
- Monad.hs +15/−10
- Numeric.hs +48/−0
- Prelude.hs +235/−0
- Ptr.hs +5/−0
- Random.hs +405/−6
- Ratio.hs +7/−2
- StablePtr.hs +5/−0
- Storable.hs +5/−0
- System.hs +9/−4
- Time.hs +17/−12
- Word.hs +6/−1
- changelog.md +11/−0
- haskell98.cabal +88/−30
Array.hs view
@@ -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
Bits.hs view
@@ -1,3 +1,8 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif+ module Bits (module Data.Bits) where import Data.Bits
CError.hs view
@@ -1,2 +1,8 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif+ module CError (module Foreign.C.Error) where import Foreign.C.Error+
CForeign.hs view
@@ -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
CPUTime.hs view
@@ -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
CString.hs view
@@ -1,2 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif+ module CString (module Foreign.C.String) where import Foreign.C.String
CTypes.hs view
@@ -1,2 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif+ module CTypes (module Foreign.C.Types) where import Foreign.C.Types
Char.hs view
@@ -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
Complex.hs view
@@ -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
Directory.hs view
@@ -1,11 +1,44 @@+{-# 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+import System.Directory hiding (Permissions,+ readable, writable, executable, searchable,+ getPermissions, setPermissions)+import qualified System.Directory as SD++data Permissions = Permissions {+ readable :: Bool,+ writable :: Bool,+ executable :: Bool,+ searchable :: Bool+ }+ deriving (Eq, Ord, Read, Show)++getPermissions :: FilePath -> IO Permissions+getPermissions fp = do perm <- SD.getPermissions fp+ return $ Permissions {+ readable = SD.readable perm,+ writable = SD.writable perm,+ executable = SD.executable perm,+ searchable = SD.searchable perm+ }++setPermissions :: FilePath -> Permissions -> IO ()+setPermissions fp perm = let mkPerm = setOwnerReadable (readable perm)+ . setOwnerWritable (writable perm)+ . setOwnerExecutable (executable perm)+ . setOwnerSearchable (searchable perm)+ in SD.setPermissions fp (mkPerm emptyPermissions)+
ForeignPtr.hs view
@@ -1,2 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Trustworthy #-}+#endif+ module ForeignPtr (module Foreign.ForeignPtr) where import Foreign.ForeignPtr
IO.hs view
@@ -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)+
Int.hs view
@@ -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
Ix.hs view
@@ -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
List.hs view
@@ -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)
Locale.hs view
@@ -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 )
MarshalAlloc.hs view
@@ -1,2 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif+ module MarshalAlloc (module Foreign.Marshal.Alloc) where import Foreign.Marshal.Alloc
MarshalArray.hs view
@@ -1,2 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif+ module MarshalArray (module Foreign.Marshal.Array) where import Foreign.Marshal.Array
MarshalError.hs view
@@ -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
MarshalUtils.hs view
@@ -1,2 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif+ module MarshalUtils (module Foreign.Marshal.Utils) where import Foreign.Marshal.Utils
Maybe.hs view
@@ -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
Monad.hs view
@@ -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
+ Numeric.hs view
@@ -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
+ Prelude.hs view
@@ -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 <http://www.haskell.org/onlinereport/>.++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
Ptr.hs view
@@ -1,2 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif+ module Ptr (module Foreign.Ptr) where import Foreign.Ptr
Random.hs view
@@ -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,+<http://random.mat.sbg.ac.at/~peter/pads98.ps>, 1998.++5. Pierre #LEcuyer# L'Ecuyer, /Efficient and portable combined random+number generators/, Comm ACM, 31(6), Jun 1988, pp742-749.++The Web site <http://random.mat.sbg.ac.at/> is a great source of information.++-}
Ratio.hs view
@@ -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
StablePtr.hs view
@@ -1,2 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif+ module StablePtr (module Foreign.StablePtr) where import Foreign.StablePtr
Storable.hs view
@@ -1,2 +1,7 @@+{-# LANGUAGE CPP #-}+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif+ module Storable (module Foreign.Storable) where import Foreign.Storable
System.hs view
@@ -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
Time.hs view
@@ -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
Word.hs view
@@ -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
+ changelog.md view
@@ -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
haskell98.cabal view
@@ -1,36 +1,94 @@-name: haskell98-version: 1.0.1.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-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, random, old-time, old-locale, process, array+ 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- -- We need to set the package name to haskell98 (without a version number)- -- as it's magic.- ghc-options: -package-name haskell98+ -- 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