Merge pull request #57 from natefaubion/2.0

Updates for 2.0

Author: garyb

bower.json

@@ -20,13 +20,13 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-arrays": "^1.0.0",
-    "purescript-console": "^1.0.0",
-    "purescript-either": "^1.0.0",
-    "purescript-exceptions": "^1.0.0",
-    "purescript-lists": "^1.0.0",
-    "purescript-random": "^1.0.0",
-    "purescript-strings": "^1.0.0",
-    "purescript-transformers": "^1.0.0"
+    "purescript-arrays": "^3.0.0",
+    "purescript-console": "^2.0.0",
+    "purescript-either": "^2.0.0",
+    "purescript-exceptions": "^2.0.0",
+    "purescript-lists": "^2.0.0",
+    "purescript-random": "^2.0.0",
+    "purescript-strings": "^2.0.0",
+    "purescript-transformers": "^2.0.0"
   }
 }

src/Test/QuickCheck.purs

@@ -15,7 +15,21 @@
 -- | ```purescript
 -- | main = quickCheck \n -> n + 1 > n
 -- | ```
-module Test.QuickCheck where
+module Test.QuickCheck
+  ( QC
+  , quickCheck
+  , quickCheck'
+  , quickCheckPure
+  , class Testable
+  , test
+  , Result(..)
+  , withHelp
+  , (<?>)
+  , assertEquals
+  , (===)
+  , assertNotEquals
+  , (/==)
+  ) where
 
 import Prelude
 

src/Test/QuickCheck/Arbitrary.purs

@@ -1,4 +1,9 @@
-module Test.QuickCheck.Arbitrary where
+module Test.QuickCheck.Arbitrary
+  ( class Arbitrary
+  , arbitrary
+  , class Coarbitrary
+  , coarbitrary
+  ) where
 
 import Prelude
 
@@ -10,6 +15,7 @@ import Data.Int (toNumber)
 import Data.Lazy (Lazy, defer, force)
 import Data.List (List)
 import Data.Maybe (Maybe(..))
+import Data.Newtype (wrap)
 import Data.String (charCodeAt, fromCharArray, split)
 import Data.Tuple (Tuple(..))
 
@@ -60,7 +66,7 @@ instance arbString :: Arbitrary String where
   arbitrary = fromCharArray <$> arbitrary
 
 instance coarbString :: Coarbitrary String where
-  coarbitrary s = coarbitrary $ (charCodeAt zero <$> split "" s)
+  coarbitrary s = coarbitrary $ (charCodeAt zero <$> split (wrap "") s)
 
 instance arbChar :: Arbitrary Char where
   arbitrary = fromCharCode <$> chooseInt 0 65536

src/Test/QuickCheck/Data/AlphaNumString.purs

@@ -1,7 +1,10 @@
-module Test.QuickCheck.Data.AlphaNumString where
+module Test.QuickCheck.Data.AlphaNumString
+  ( AlphaNumString(..)
+  ) where
 
 import Prelude
 
+import Data.Newtype (class Newtype)
 import Data.String (fromCharArray, toCharArray)
 
 import Test.QuickCheck.Gen (Gen, arrayOf, oneOf)
@@ -11,8 +14,7 @@ import Test.QuickCheck.Arbitrary (class Coarbitrary, class Arbitrary, coarbitrar
 -- | alphanumeric strings.
 newtype AlphaNumString = AlphaNumString String
 
-runAlphaNumString :: AlphaNumString -> String
-runAlphaNumString (AlphaNumString s) = s
+derive instance newtypeAlphaNumString :: Newtype AlphaNumString _
 
 instance arbAlphaNumString :: Arbitrary AlphaNumString where
   arbitrary = AlphaNumString <<< fromCharArray <$> arrayOf anyChar

src/Test/QuickCheck/Data/ApproxNumber.purs

@@ -2,6 +2,7 @@
 -- | module, as well as helper functions for constructing random generators.
 module Test.QuickCheck.Gen
   ( Gen
+  , unGen
   , GenState
   , Size
   , repeatable
@@ -29,19 +30,22 @@ module Test.QuickCheck.Gen
 
 import Prelude
 
+import Control.Alt (class Alt)
 import Control.Monad.Eff (Eff)
 import Control.Monad.Eff.Random (RANDOM)
-import Control.Monad.Rec.Class (class MonadRec, tailRecM)
+import Control.Monad.Rec.Class (class MonadRec, Step(..), tailRecM)
 import Control.Monad.State (State, runState, evalState)
 import Control.Monad.State.Class (state, modify)
+import Control.Monad.State.Trans (StateT)
 
 import Data.Array ((!!), length)
-import Data.Either (Either(..))
 import Data.Foldable (fold)
+import Data.Identity (Identity)
 import Data.Int (toNumber)
 import Data.List (List(..), toUnfoldable)
 import Data.Maybe (fromMaybe)
-import Data.Monoid.Additive (Additive(..), runAdditive)
+import Data.Monoid.Additive (Additive(..))
+import Data.Newtype (unwrap)
 import Data.Tuple (Tuple(..), fst, snd)
 
 import Math as M
@@ -58,27 +62,39 @@ type GenState = { newSeed :: Seed, size :: Size }
 -- | The random generator monad
 -- |
 -- | `Gen` is a state monad which encodes a linear congruential generator.
-type Gen a = State GenState a
+newtype Gen a = Gen (StateT GenState Identity a)
+
+derive newtype instance functorGen :: Functor Gen
+derive newtype instance applyGen :: Apply Gen
+derive newtype instance applicativeGen :: Applicative Gen
+derive newtype instance bindGen :: Bind Gen
+derive newtype instance monadGen :: Monad Gen
+derive newtype instance altGen :: Alt Gen
+derive newtype instance monadRecGen :: MonadRec Gen
+
+-- | Exposes the underlying State implementation.
+unGen :: forall a. Gen a -> State GenState a
+unGen (Gen st) = st
 
 -- | Create a random generator for a function type.
 repeatable :: forall a b. (a -> Gen b) -> Gen (a -> b)
-repeatable f = state $ \s -> Tuple (\a -> fst (runGen (f a) s)) (s { newSeed = lcgNext s.newSeed })
+repeatable f = Gen $ state \s -> Tuple (\a -> fst (runGen (f a) s)) (s { newSeed = lcgNext s.newSeed })
 
 -- | Create a random generator which uses the generator state explicitly.
 stateful :: forall a. (GenState -> Gen a) -> Gen a
-stateful f = state $ \s -> runGen (f s) s
+stateful f = Gen $ state \s -> runGen (f s) s
 
 -- | Modify a random generator by setting a new random seed.
 variant :: forall a. Seed -> Gen a -> Gen a
-variant n g = state $ \s -> runGen g s { newSeed = n }
+variant n g = Gen $ state \s -> runGen g s { newSeed = n }
 
 -- | Create a random generator which depends on the size parameter.
 sized :: forall a. (Size -> Gen a) -> Gen a
 sized f = stateful (\s -> f s.size)
 
 -- | Modify a random generator by setting a new size parameter.
 resize :: forall a. Size -> Gen a -> Gen a
-resize sz g = state $ \s -> runGen g s { size = sz }
+resize sz g = Gen $ state \s -> runGen g s { size = sz }
 
 -- | Create a random generator which samples a range of `Number`s i
 -- | with uniform probability.
@@ -109,7 +125,7 @@ oneOf x xs = do
 frequency :: forall a. Tuple Number (Gen a) -> List (Tuple Number (Gen a)) -> Gen a
 frequency x xs = let
     xxs   = Cons x xs
-    total = runAdditive $ fold (map (Additive <<< fst) xxs :: List (Additive Number))
+    total = unwrap $ fold (map (Additive <<< fst) xxs :: List (Additive Number))
     pick n d Nil = d
     pick n d (Cons (Tuple k x) xs) = if n <= k then x else pick (n - k) d xs
   in do
@@ -134,9 +150,9 @@ replicateMRec :: forall m a. MonadRec m => Int -> m a -> m (List a)
 replicateMRec k _ | k <= 0 = pure Nil
 replicateMRec k gen = tailRecM go (Tuple Nil k)
   where
-  go :: (Tuple (List a) Int) -> m (Either (Tuple (List a) Int) (List a))
-  go (Tuple acc 0) = pure $ Right acc
-  go (Tuple acc n) = gen <#> \x -> Left (Tuple (Cons x acc) (n - 1))
+  go :: (Tuple (List a) Int) -> m (Step (Tuple (List a) Int) (List a))
+  go (Tuple acc 0) = pure $ Done acc
+  go (Tuple acc n) = gen <#> \x -> Loop (Tuple (Cons x acc) (n - 1))
 
 -- | Create a random generator which generates a list of random values of the specified size.
 listOf :: forall a. Int -> Gen a -> Gen (List a)
@@ -155,11 +171,11 @@ elements x xs = do
 
 -- | Run a random generator
 runGen :: forall a. Gen a -> GenState -> Tuple a GenState
-runGen = runState
+runGen = runState <<< unGen
 
 -- | Run a random generator, keeping only the randomly-generated result
 evalGen :: forall a. Gen a -> GenState -> a
-evalGen = evalState
+evalGen = evalState <<< unGen
 
 -- | Sample a random generator
 sample :: forall a. Seed -> Size -> Gen a -> Array a
@@ -177,7 +193,7 @@ randomSample = randomSample' 10
 
 -- | A random generator which simply outputs the current seed
 lcgStep :: Gen Int
-lcgStep = state f where
+lcgStep = Gen $ state f where
   f s = Tuple (runSeed s.newSeed) (s { newSeed = lcgNext s.newSeed })
 
 -- | A random generator which approximates a uniform random variable on `[0, 1]`
@@ -188,6 +204,6 @@ 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 = do
+perturbGen n gen = Gen do
   modify \s -> s { newSeed = lcgPerturb (toNumber (float32ToInt32 n)) s.newSeed }
-  gen
+  unGen gen