Ticket #4315: GeneralizeRandomAndRandomGen.patch

1 patch for repository /home/tommd/dev/Haskell/HaskellCommunity/random:

Tue Sep 14 16:30:58 PDT 2010  thomas.dubuisson@gmail.com
  * Generalize RandomGen and Random by generated type

New patches:

[Generalize RandomGen and Random by generated type
thomas.dubuisson@gmail.com**20100914233058
 Ignore-this: 19d665fd3764ed8652827da9f666f78e
] {
hunk ./System/Random.hs 1
+{-# LANGUAGE MultiParamTypeClasses, FlexibleContexts, FunctionalDependencies #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  System.Random
hunk ./System/Random.hs 62
 
        -- * Random values of various types
        , Random ( random,   randomR,
-                  randoms,  randomRs,
-                  randomIO, randomRIO )
+                  randoms,  randomRs )
+       , randomIO
+       , randomRIO
 
        -- * References
        -- $references
hunk ./System/Random.hs 106
 
 -- | The class 'RandomGen' provides a common interface to random number
 -- generators.
---
--- Minimal complete definition: 'next'.
 
hunk ./System/Random.hs 107
-class RandomGen g where
+class RandomGen g v | g -> v where
 
hunk ./System/Random.hs 109
-   -- |The 'next' operation returns an 'Int' that is uniformly distributed
+   -- |The 'next' operation returns a value that is uniformly distributed
    -- in the range returned by 'genRange' (including both end points),
    -- and a new generator.
hunk ./System/Random.hs 112
-   next     :: g -> (Int, g)
+   next     :: g -> (v, g)
 
    -- |The 'genRange' operation yields the range of values returned by
    -- the generator.
hunk ./System/Random.hs 119
    --
    -- It is required that:
    --
-   -- * If @(a,b) = 'genRange' g@, then @a < b@.
+   -- * If @(a,b) = 'genRange' g@ and v is of the Ord class, then @a < b@.
    --
hunk ./System/Random.hs 121
-   -- * 'genRange' always returns a pair of defined 'Int's.
+   -- * 'genRange' always returns a pair of defined values.
    --
    -- The second condition ensures that 'genRange' cannot examine its
    -- argument, and hence the value it returns can be determined only by the
hunk ./System/Random.hs 129
    -- 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)
+   genRange :: g -> (v,v)
 
 -- | The class 'SplittableGen' proivides a way to specify a random number
 -- generator that can be split into two new generators.
hunk ./System/Random.hs 171
 data StdGen 
  = StdGen Int32 Int32
 
-instance RandomGen StdGen where
+instance RandomGen StdGen Int where
   next  = stdNext
   genRange _ = stdRange
 
hunk ./System/Random.hs 227
 -- 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.
+With a source of random values (of type v) supply in hand, the 'Random' class allows the
+programmer to coerce the v values into values of type a.
 
 Minimal complete definition: 'randomR' and 'random'.
 
hunk ./System/Random.hs 234
 -}
 
-class Random a where
+class Random a v 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
hunk ./System/Random.hs 241
   -- 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)
+  randomR :: RandomGen g v => (a,a) -> g -> (a,g)
 
   -- | The same as 'randomR', but using a default range determined by the type:
   --
hunk ./System/Random.hs 252
   -- @[0,1)@.
   --
   -- * For 'Integer', the range is (arbitrarily) the range of 'Int'.
-  random  :: RandomGen g => g -> (a, g)
+  random  :: RandomGen g v => g -> (a, g)
 
   -- | Plural variant of 'randomR', producing an infinite list of
   -- random values instead of returning a new generator.
hunk ./System/Random.hs 256
-  randomRs :: RandomGen g => (a,a) -> g -> [a]
+  randomRs :: RandomGen g v => (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
hunk ./System/Random.hs 261
   -- random values instead of returning a new generator.
-  randoms  :: RandomGen g => g -> [a]
+  randoms  :: RandomGen g v => g -> [a]
   randoms  g      = (\(x,g') -> x : randoms g') (random g)
 
hunk ./System/Random.hs 264
-  -- | 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 'randomR' that uses the global random number generator
+-- (see "System.Random#globalrng").
+randomRIO :: (Random a Int) => (a,a) -> IO a
+randomRIO range  = getStdRandom (randomR range)
 
hunk ./System/Random.hs 269
-  -- | A variant of 'random' that uses the global random number generator
-  -- (see "System.Random#globalrng").
-  randomIO  :: IO a
-  randomIO        = getStdRandom random
+-- | A variant of 'random' that uses the global random number generator
+-- (see "System.Random#globalrng").
+randomIO  :: (Random a Int) => IO a
+randomIO          = getStdRandom random
 
 
hunk ./System/Random.hs 275
-instance Random Int where
+instance Random Int Int where
   randomR (a,b) g = randomIvalInteger (toInteger a, toInteger b) g
   random g        = randomR (minBound,maxBound) g
 
hunk ./System/Random.hs 279
-instance Random Char where
+instance Random Char Int where
   randomR (a,b) g = 
       case (randomIvalInteger (toInteger (ord a), toInteger (ord b)) g) of
         (x,g') -> (chr x, g')
hunk ./System/Random.hs 285
   random g       = randomR (minBound,maxBound) g
 
-instance Random Bool where
+instance Random Bool Int where
   randomR (a,b) g = 
       case (randomIvalInteger (bool2Int a, bool2Int b) g) of
         (x, g') -> (int2Bool x, g')
hunk ./System/Random.hs 300
 
   random g       = randomR (minBound,maxBound) g
  
-instance Random Integer where
+instance Random Integer Int where
   randomR ival g = randomIvalInteger ival g
   random g      = randomR (toInteger (minBound::Int), toInteger (maxBound::Int)) g
 
hunk ./System/Random.hs 304
-instance Random Double where
+instance Random Double Int where
   randomR ival g = randomIvalDouble ival id g
   random g       = randomR (0::Double,1) g
   
hunk ./System/Random.hs 309
 -- hah, so you thought you were saving cycles by using Float?
-instance Random Float where
+instance Random Float Int where
   random g        = randomIvalDouble (0::Double,1) realToFrac g
   randomR (a,b) g = randomIvalDouble (realToFrac a, realToFrac b) realToFrac g
 
hunk ./System/Random.hs 319
     (sec, psec) <- getTime
     return (createStdGen (sec * 12345 + psec + ct + o))
 
-randomIvalInteger :: (RandomGen g, Num a) => (Integer, Integer) -> g -> (a, g)
+randomIvalInteger :: (RandomGen g Int, 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')
hunk ./System/Random.hs 335
          in
          f (n' - 1) (fromIntegral x + acc * b) g'
 
-randomIvalDouble :: (RandomGen g, Fractional a) => (Double, Double) -> (Double -> a) -> g -> (a, g)
+randomIvalDouble :: (RandomGen g Int, Fractional a) => (Double, Double) -> (Double -> a) -> g -> (a, g)
 randomIvalDouble (l,h) fromDouble rng 
   | l > h     = randomIvalDouble (h,l) fromDouble rng
   | otherwise = 
}

Context:

[Move "split" into its own class
thomas.dubuisson@gmail.com**20100914232945
 Ignore-this: 588e2a321823c206962b77c12cdb652a
] 
[Fix randomIvalDouble so that it will not produce values more than a few ULPs below the requested lower bound
James Cook <james.cook@usma.edu>**20100412132638
 Ignore-this: 35a65dae123bbf5f812ebd0aac7aa3b1
] 
[Bump version to 1.0.0.2
Ian Lynagh <igloo@earth.li>**20090920141953] 
[use explicit import list for Data.Sequence, in preparation for an expanded interface
Ross Paterson <ross@soi.city.ac.uk>**20090913230910
 Ignore-this: d6f37ea56cff7c7f4edcafb89b2a9f
] 
[Fix "Cabal check" warnings
Ian Lynagh <igloo@earth.li>**20090811215920] 
[change dependency from old-time to time
Laszlo Nagy <rizsotto@gmail.com>**20090709091417
 Ignore-this: de203b243bd2f4035661c91971bd49cc
] 
[TAG 2009-06-25
Ian Lynagh <igloo@earth.li>**20090625160406] 
Patch bundle hash:
fe3fd8c03e81aaf4e9a7d98e3911905619ecd598