haskell98 1.1.0.1 → 2.0.0.0

raw patch · 6 files changed

+728/−18 lines, 6 filesdep +timedep −randomdep ~basedep ~processPVP ok

version bump matches the API change (PVP)

Dependencies added: time

Dependencies removed: random

Dependency ranges changed: base, process

API changes (from Hackage documentation)

Files

• IO.hs +15/−1
• List.hs +1/−1
• Numeric.hs +45/−0
• Prelude.hs +240/−0
• Random.hs +416/−7
• haskell98.cabal +11/−9

@@ -1,3 +1,6 @@++{-# OPTIONS_GHC -fno-warn-deprecations #-}+ module IO (     Handle, HandlePosn,     IOMode(ReadMode,WriteMode,AppendMode,ReadWriteMode),@@ -23,7 +26,7 @@   ) where  import System.IO-import System.IO.Error+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@@ -56,3 +59,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)+

@@ -26,4 +26,4 @@     zip, zip3, zipWith, zipWith3, unzip, unzip3   ) where -import Data.List hiding (foldl')+import Data.List hiding (foldl', splitAt)

@@ -0,0 +1,45 @@+{-# LANGUAGE PackageImports #-}++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

@@ -0,0 +1,240 @@+{-# LANGUAGE CPP, NoImplicitPrelude, BangPatterns, PackageImports #-}++-- |+-- 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,++#if defined(__NHC__)+    []((:), []),        -- Not legal Haskell 98;+                        -- ... available through built-in syntax+    module Data.Tuple,  -- Includes tuple types+    ()(..),             -- Not legal Haskell 98+    (->),               -- ... available through built-in syntax+#endif+#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+import GHC.Err   ( undefined )+#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

@@ -1,8 +1,417 @@-module Random (-   RandomGen(next, split, genRange),-   StdGen, mkStdGen,-   Random( random,   randomR, randoms,  randomRs, randomIO, randomRIO ),-   getStdRandom, getStdGen, setStdGen, newStdGen-  ) where+{-# LANGUAGE CPP #-} -import System.Random+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' (["System.Random\#Burton", "System.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+["System.Random\#Park", "System.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 "System.Random#globalrng").+  randomRIO :: (a,a) -> IO a+  randomRIO range  = getStdRandom (randomR range)++  -- | A variant of 'random' that uses the global random number generator+  -- (see "System.Random#globalrng").+  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.++-}

@@ -1,5 +1,5 @@ name:		haskell98-version:	1.1.0.1+version:	2.0.0.0 license:	BSD3 license-file:	LICENSE maintainer:	libraries@haskell.org@@ -19,21 +19,23 @@ 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+                    process     >= 1.0 && < 1.2,+                    array       >= 0.3 && < 0.4,+                    time        >= 1.2 && < 1.3     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,+        -- Haskell 98+        Prelude, 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+    exposed: False  source-repository head-    type:     darcs-    location: http://darcs.haskell.org/packages/haskell98/+    type:     git+    location: http://darcs.haskell.org/packages/haskell98.git/