Use a newtype for Seed

Author: hdgarrood

docs/Test/QuickCheck.md

@@ -49,7 +49,7 @@ representing the number of tests which should be run.
 #### `quickCheckPure`
 
 ``` purescript
-quickCheckPure :: forall prop. (Testable prop) => Int -> Int -> prop -> List Result
+quickCheckPure :: forall prop. (Testable prop) => Seed -> Int -> prop -> List Result
 ```
 
 Test a property, returning all test results as an array.

docs/Test/QuickCheck/LCG.md

@@ -1,11 +1,5 @@
 ## Module Test.QuickCheck.LCG
 
-#### `Seed`
-
-``` purescript
-type Seed = Int
-```
-
 #### `lcgM`
 
 ``` purescript
@@ -28,12 +22,15 @@ The *increment*: a magic constant for the linear congruential generator
 lcgN :: Int
 ```
 
-The *modulus*: a magic constant for the linear congruential generator
+The *modulus*: a magic constant for the linear congruential generator.
+It is equal to 2^31 - 1, a Mersenne prime. It is useful for this value to
+be prime, because then the requirement of the initial seed being coprime
+to the modulus is satisfied when the seed is between 1 and lcgN - 1.
 
 #### `lcgNext`
 
 ``` purescript
-lcgNext :: Int -> Int
+lcgNext :: Seed -> Seed
 ```
 
 Step the linear congruential generator
@@ -46,4 +43,32 @@ randomSeed :: forall e. Eff (random :: RANDOM | e) Seed
 
 Create a random seed
 
+#### `Seed`
+
+``` purescript
+newtype Seed
+```
+
+A seed for the linear congruential generator. We omit a `Semiring`
+instance because there is no `zero` value, as 0 is not an acceptable
+seed for the generator.
+
+##### Instances
+``` purescript
+instance showSeed :: Show Seed
+instance eqSeed :: Eq Seed
+```
+
+#### `mkSeed`
+
+``` purescript
+mkSeed :: Int -> Seed
+```
+
+#### `runSeed`
+
+``` purescript
+runSeed :: Seed -> Int
+```
+
 

src/Test/QuickCheck.purs

@@ -65,7 +65,7 @@ quickCheck' n prop = do
 -- |
 -- | The first argument is the _random seed_ to be passed to the random generator.
 -- | The second argument is the number of tests to run.
-quickCheckPure :: forall prop. (Testable prop) => Int -> Int -> prop -> List Result
+quickCheckPure :: forall prop. (Testable prop) => Seed -> Int -> prop -> List Result
 quickCheckPure s n prop = evalGen (replicateM n (test prop)) { newSeed: s, size: 10 }
 
 -- | The `Testable` class represents _testable properties_.

src/Test/QuickCheck/Gen.purs

@@ -165,7 +165,7 @@ randomSample = randomSample' 10
 -- | A random generator which simply outputs the current seed
 lcgStep :: Gen Int
 lcgStep = Gen f where
-  f s = { value: s.newSeed, state: s { newSeed = lcgNext s.newSeed } }
+  f s = { value: runSeed s.newSeed, state: s { newSeed = lcgNext s.newSeed } }
 
 -- | A random generator which approximates a uniform random variable on `[0, 1]`
 uniform :: Gen Number
@@ -175,7 +175,9 @@ foreign import float32ToInt32 :: Number -> Int
 
 -- | Perturb a random generator by modifying the current seed
 perturbGen :: forall a. Number -> Gen a -> Gen a
-perturbGen n (Gen f) = Gen $ \s -> f (s { newSeed = lcgNext (float32ToInt32 n) + s.newSeed })
+perturbGen n (Gen f) = Gen $ \s -> f (s { newSeed = perturb s.newSeed })
+  where
+  perturb oldSeed = mkSeed (runSeed (lcgNext (mkSeed (float32ToInt32 n))) + runSeed oldSeed)
 
 instance functorGen :: Functor Gen where
   map f (Gen g) = Gen $ \s -> case g s of

src/Test/QuickCheck/LCG.purs

@@ -1,5 +1,7 @@
 module Test.QuickCheck.LCG
   ( Seed()
+  , mkSeed
+  , runSeed
   , lcgM
   , lcgC
   , lcgN
@@ -16,8 +18,6 @@ import Data.Int (fromNumber, toNumber)
 import Data.Int.Bits (shl)
 import qualified Data.Maybe.Unsafe as U
 
-type Seed = Int
-
 -- | The *multiplier*: a magic constant for the linear congruential generator
 lcgM :: Int
 lcgM = 48271
@@ -34,26 +34,41 @@ lcgN :: Int
 lcgN = 2147483647
 
 -- | Step the linear congruential generator
-lcgNext :: Int -> Int
-lcgNext n = U.fromJust $ fromNumber $ (toNumber lcgM * n' + toNumber lcgC) % toNumber lcgN
+lcgNext :: Seed -> Seed
+lcgNext = Seed <<< go <<< runSeed
   where
-  -- Ensure that the input is between seedMin and seedMax; the LCG will not
-  -- work well for other inputs.
-  n' = ensureBetween (toNumber seedMin) (toNumber seedMax) (toNumber n)
-
-ensureBetween :: Number -> Number -> Number -> Number
-ensureBetween min max n =
-  let rangeSize = max - min
-  in (((n % rangeSize) + rangeSize) % rangeSize) + min
+  go n = U.fromJust $ fromNumber $ (toNumber lcgM * toNumber n + toNumber lcgC) % toNumber lcgN
 
 -- | Create a random seed
 randomSeed :: forall e. Eff (random :: RANDOM | e) Seed
-randomSeed = randomInt seedMin seedMax
+randomSeed = mkSeed <$> randomInt seedMin seedMax
 
 -- | The minimum permissible Seed value.
-seedMin :: Seed
+seedMin :: Int
 seedMin = 1
 
 -- | The maximum permissible Seed value.
-seedMax :: Seed
+seedMax :: Int
 seedMax = lcgM - 1
+
+-- | A seed for the linear congruential generator. We omit a `Semiring`
+-- | instance because there is no `zero` value, as 0 is not an acceptable
+-- | seed for the generator.
+newtype Seed = Seed Int
+
+mkSeed :: Int -> Seed
+mkSeed x = Seed (ensureBetween seedMin seedMax x)
+
+runSeed :: Seed -> Int
+runSeed (Seed x) = x
+
+ensureBetween :: Int -> Int -> Int -> Int
+ensureBetween min max n =
+  let rangeSize = max - min
+  in (((n `mod` rangeSize) + rangeSize) `mod` rangeSize) + min
+
+instance showSeed :: Show Seed where
+  show (Seed x) = "Seed " <> show x
+
+instance eqSeed :: Eq Seed where
+  eq (Seed x) (Seed y) = eq x y