haskell98libraries (empty) → 2.0.0.2

raw patch · 33 files changed

+911/−0 lines, 33 filesdep +arraydep +basedep +directorysetup-changed

Dependencies added: array, base, directory, old-locale, old-time, process, time

Files

• Array.hs +12/−0
• Bits.hs +7/−0
• CError.hs +7/−0
• CForeign.hs +6/−0
• CPUTime.hs +8/−0
• CString.hs +6/−0
• CTypes.hs +6/−0
• Char.hs +17/−0
• Complex.hs +10/−0
• Directory.hs +54/−0
• ForeignPtr.hs +6/−0
• IO.hs +77/−0
• Int.hs +6/−0
• Ix.hs +9/−0
• LICENSE +28/−0
• List.hs +33/−0
• Locale.hs +14/−0
• MarshalAlloc.hs +6/−0
• MarshalArray.hs +6/−0
• MarshalError.hs +21/−0
• MarshalUtils.hs +6/−0
• Maybe.hs +15/−0
• Monad.hs +18/−0
• Ptr.hs +6/−0
• Random.hs +418/−0
• Ratio.hs +9/−0
• Setup.hs +6/−0
• StablePtr.hs +6/−0
• Storable.hs +6/−0
• System.hs +12/−0
• Time.hs +19/−0
• Word.hs +6/−0
• haskell98libraries.cabal +45/−0

@@ -0,0 +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++import Ix+import Data.Array

@@ -0,0 +1,7 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module Bits (module Data.Bits) where+import Data.Bits+

@@ -0,0 +1,7 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module CError (module Foreign.C.Error) where+import Foreign.C.Error+

@@ -0,0 +1,6 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module CForeign (module Foreign.C) where+import Foreign.C

@@ -0,0 +1,8 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module CPUTime (+        getCPUTime, cpuTimePrecision +    ) where+import System.CPUTime

@@ -0,0 +1,6 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module CString (module Foreign.C.String) where+import Foreign.C.String

@@ -0,0 +1,6 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module CTypes (module Foreign.C.Types) where+import Foreign.C.Types

@@ -0,0 +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,++        -- ...and what the Prelude exports+        Char, String+    ) where++import Data.Char

@@ -0,0 +1,10 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module Complex (+        Complex((:+)), realPart, imagPart, conjugate, +        mkPolar, cis, polar, magnitude, phase +    ) where++import Data.Complex

@@ -0,0 +1,54 @@+#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++import System.Directory hiding (Permissions,+                                readable, writable, executable, searchable,+                                getPermissions, setPermissions,+                                getModificationTime)+import qualified System.Directory as SD+import System.Time(ClockTime(..))+#ifdef UTCTIME_IN_DIRECTORY+import Data.Time.Clock.POSIX(utcTimeToPOSIXSeconds)++getModificationTime = fmap toClockTime . SD.getModificationTime+toClockTime = flip TOD 0 . floor . realToFrac . utcTimeToPOSIXSeconds++#else+getModificationTime = SD.getModificationTime+#endif+getModificationTime :: FilePath -> IO ClockTime++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)

@@ -0,0 +1,6 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Trustworthy #-}+#endif++module ForeignPtr (module Foreign.ForeignPtr) where+import Foreign.ForeignPtr

@@ -0,0 +1,77 @@+{-# 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_,++        -- ...and what the Prelude exports+        IO, FilePath, IOError, ioError, userError, IO.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)++-- | The 'bracket' function captures a common allocate, compute, deallocate+-- idiom in which the deallocation step must occur even in the case of an+-- error during computation. This is similar to try-catch-finally in Java.+--+-- This version handles only IO errors, as defined by Haskell 98.+-- The version of @bracket@ in "Control.Exception" handles all exceptions,+-- and should be used instead.++bracket        :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c+bracket before after m = do+        x  <- before+        rs <- try (m x)+        _ <- after x+        case rs of+           Right r -> return r+           Left  e -> ioError e++-- | A variant of 'bracket' where the middle computation doesn't want @x@.+--+-- This version handles only IO errors, as defined by Haskell 98.+-- The version of @bracket_@ in "Control.Exception" handles all exceptions,+-- and should be used instead.++bracket_        :: IO a -> (a -> IO b) -> IO c -> IO c+bracket_ before after m = do+         x  <- before+         rs <- try m+         _ <- after x+         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   =  catchIOError+                 (do r <- f+                     return (Right r))+                 (return . Left)++catch :: IO a -> (IOError -> IO a) -> IO a+catch = catchIOError

@@ -0,0 +1,6 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module Int (module Data.Int) where+import Data.Int

@@ -0,0 +1,9 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module Ix (+        Ix(range, index, inRange), rangeSize+    ) where++import Data.Ix

@@ -0,0 +1,28 @@+Code derived from the document "Report on the Programming Language+Haskell 98", is distributed under the following license:++  Copyright (c) 2002 Simon Peyton Jones++  The authors intend this Report to belong to the entire Haskell+  community, and so we grant permission to copy and distribute it for+  any purpose, provided that it is reproduced in its entirety,+  including this Notice.  Modified versions of this Report may also be+  copied and distributed for any purpose, provided that the modified+  version is clearly presented as such, and that it does not claim to+  be a definition of the Haskell 98 Language.++-----------------------------------------------------------------------------++Code derived from the document "The Haskell 98 Foreign Function+Interface, An Addendum to the Haskell 98 Report" is distributed under+the following license:++  Copyright (c) 2002 Manuel M. T. Chakravarty++  The authors intend this Report to belong to the entire Haskell+  community, and so we grant permission to copy and distribute it for+  any purpose, provided that it is reproduced in its entirety,+  including this Notice.  Modified versions of this Report may also be+  copied and distributed for any purpose, provided that the modified+  version is clearly presented as such, and that it does not claim to+  be a definition of the Haskell 98 Foreign Function Interface.

@@ -0,0 +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,++        -- ...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)

@@ -0,0 +1,14 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Trustworthy #-}+#endif++module Locale (+        TimeLocale(..), defaultTimeLocale+    ) where++import System.Locale ( +	-- just the bits that are specified by Haskell 98+	TimeLocale(TimeLocale,wDays,months,amPm,dateTimeFmt,+		   dateFmt,timeFmt,time12Fmt),+        defaultTimeLocale+    )

@@ -0,0 +1,6 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module MarshalAlloc (module Foreign.Marshal.Alloc) where+import Foreign.Marshal.Alloc

@@ -0,0 +1,6 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module MarshalArray (module Foreign.Marshal.Array) where+import Foreign.Marshal.Array

@@ -0,0 +1,21 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module MarshalError (+  	module Foreign.Marshal.Error,+	IOErrorType,+	mkIOError,+	alreadyExistsErrorType,+	doesNotExistErrorType,+	alreadyInUseErrorType,+	fullErrorType,+	eofErrorType,+	illegalOperationErrorType,+	permissionErrorType,+	userErrorType,+	annotateIOError+  ) where++import System.IO.Error+import Foreign.Marshal.Error

@@ -0,0 +1,6 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module MarshalUtils (module Foreign.Marshal.Utils) where+import Foreign.Marshal.Utils

@@ -0,0 +1,15 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module Maybe (+        isJust, isNothing,+        fromJust, fromMaybe, listToMaybe, maybeToList,+        catMaybes, mapMaybe,++        -- ...and what the Prelude exports+        Maybe(Nothing, Just),+        maybe+    ) where++import Data.Maybe

@@ -0,0 +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,++        -- ...and what the Prelude exports+        Monad((>>=), (>>), return, fail),+        Functor(fmap),+        mapM, mapM_, sequence, sequence_, (=<<), +    ) where++import Control.Monad

@@ -0,0 +1,6 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module Ptr (module Foreign.Ptr) where+import Foreign.Ptr

@@ -0,0 +1,418 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Trustworthy #-}+#endif++module 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++#ifdef __NHC__+import CPUTime          ( getCPUTime )+import Foreign.Ptr      ( Ptr, nullPtr )+import Foreign.C        ( CTime, CUInt )+#else+import System.CPUTime   ( getCPUTime )+import Data.Time        ( getCurrentTime, UTCTime(..) )+import Data.Ratio       ( numerator, denominator )+#endif+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.+#ifdef __NHC__+foreign import ccall "time.h time" readtime :: Ptr CTime -> IO CTime+getTime :: IO (Integer, Integer)+getTime = do CTime t <- readtime nullPtr;  return (toInteger t, 0)+#else+getTime :: IO (Integer, Integer)+getTime = do+  utc <- getCurrentTime+  let daytime = toRational $ utctDayTime utc+  return $ quotRem (numerator daytime) (denominator daytime)+#endif++-- | 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.++-}

@@ -0,0 +1,9 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module Ratio (+        Ratio, Rational, (%), numerator, denominator, approxRational+    ) where++import Data.Ratio

@@ -0,0 +1,6 @@+module Main (main) where++import Distribution.Simple++main :: IO ()+main = defaultMain

@@ -0,0 +1,6 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module StablePtr (module Foreign.StablePtr) where+import Foreign.StablePtr

@@ -0,0 +1,6 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module Storable (module Foreign.Storable) where+import Foreign.Storable

@@ -0,0 +1,12 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Trustworthy #-}+#endif++module System (+        ExitCode(ExitSuccess,ExitFailure),+        getArgs, getProgName, getEnv, system, exitWith, exitFailure+    ) where++import System.Exit+import System.Environment+import System.Cmd

@@ -0,0 +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++import System.Time

@@ -0,0 +1,6 @@+#if __GLASGOW_HASKELL__ >= 701+{-# LANGUAGE Safe #-}+#endif++module Word (module Data.Word) where+import Data.Word

@@ -0,0 +1,45 @@+name:		haskell98libraries+version:	2.0.0.2+license:	BSD3+license-file:	LICENSE+maintainer:	hallgren@chalmers.se+synopsis:	Compatibility with Haskell 98+category:   Haskell98+description:+	This package provides compatibility with the library 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/+build-type:     Simple+Cabal-Version: >= 1.6++Flag utctime-in-directory+  Description: Does System.Directory use UTCTime instead of ClockTime?+  Default:     True++Library+    build-depends:  base        >= 3   && < 5,+                    old-time    >= 1.0 && < 1.2,+                    old-locale  >= 1.0 && < 1.1,+                    process     >= 1.0 && < 1.2,+                    array       >= 0.3 && < 0.5,+                    time        >= 1.2 && < 1.5+    if flag(utctime-in-directory)+      cpp-options: -DUTCTIME_IN_DIRECTORY+      build-depends: directory >= 1.2 && < 1.3+    else+      build-depends: directory >= 1.1 && < 1.2++    exposed-modules:+        -- Haskell 98+      --Prelude, Numeric,+        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+    exposed: True+    extensions: CPP