Merge pull request #50 from telser/purescript-0.8-warnings

Fix warnings generated by purescript-0.8.0

Author: garyb

src/Test/QuickCheck.purs

@@ -17,16 +17,16 @@
 -- | ```
 module Test.QuickCheck where
 
-import Prelude
+import Prelude (class Show, class Eq, Unit, show, (++), (/=), (==), (<<<), (>>=), return, ($), one, bind, (+), zero, unit)
 
 import Control.Monad.Eff (Eff())
 import Control.Monad.Eff.Console (CONSOLE(), log)
 import Control.Monad.Eff.Exception (EXCEPTION(), throwException, error)
 import Control.Monad.Eff.Random (RANDOM())
 import Data.List (List(..), replicateM)
-import Test.QuickCheck.Arbitrary
-import Test.QuickCheck.Gen
-import Test.QuickCheck.LCG
+import Test.QuickCheck.Arbitrary (class Arbitrary, arbitrary)
+import Test.QuickCheck.Gen (Gen, evalGen)
+import Test.QuickCheck.LCG (Seed, randomSeed)
 
 -- | A type synonym which represents the effects used by the `quickCheck` function.
 type QC eff a = Eff (console :: CONSOLE, random :: RANDOM, err :: EXCEPTION | eff) a
@@ -100,14 +100,20 @@ instance showResult :: Show Result where
 -- | ```purescript
 -- | test x = myProperty x <?> ("myProperty did not hold for " <> show x)
 -- | ```
-(<?>) :: Boolean -> String -> Result
-(<?>) true _ = Success
-(<?>) false msg = Failed msg
+withHelp :: Boolean -> String -> Result
+withHelp true _ = Success
+withHelp false msg = Failed msg
+
+infix 2 withHelp as <?>
 
 -- | Self-documenting equality assertion
-(===) :: forall a. (Eq a, Show a) => a -> a -> Result
-(===) a b = a == b <?> show a ++ " /= " ++ show b
+assertEquals :: forall a. (Eq a, Show a) => a -> a -> Result
+assertEquals a b = a == b <?> show a ++ " /= " ++ show b
+
+infix 2 assertEquals as ===
 
 -- | Self-documenting inequality assertion
-(/==) :: forall a. (Eq a, Show a) => a -> a -> Result
-(/==) a b = a /= b <?> show a ++ " == " ++ show b
+assertNotEquals :: forall a. (Eq a, Show a) => a -> a -> Result
+assertNotEquals a b = a /= b <?> show a ++ " == " ++ show b
+
+infix 2 assertNotEquals as /==

src/Test/QuickCheck/Arbitrary.purs

@@ -1,6 +1,6 @@
 module Test.QuickCheck.Arbitrary where
 
-import Prelude
+import Prelude (Unit, Ordering(GT, EQ, LT), const, (<<<), pure, (>>=), (<$>), id, flip, zero, bind, (>>>), (<*>), map, unit, return, ($), negate, (*), (<))
 
 import Data.Char (toCharCode, fromCharCode)
 import Data.Either (Either(..))
@@ -12,7 +12,7 @@ import Data.List (List())
 import Data.Maybe (Maybe(..))
 import Data.String (charCodeAt, fromCharArray, split)
 import Data.Tuple (Tuple(..))
-import Test.QuickCheck.Gen
+import Test.QuickCheck.Gen (Gen, listOf, chooseInt, sized, perturbGen, repeatable, arrayOf, oneOf, uniform)
 
 -- | The `Arbitrary` class represents those types whose values can be
 -- | _randomly-generated_.

src/Test/QuickCheck/Data/AlphaNumString.purs

@@ -1,10 +1,10 @@
 module Test.QuickCheck.Data.AlphaNumString where
 
-import Prelude
+import Prelude ((<$>), (<<<), pure, map)
 
 import Data.String (fromCharArray, toCharArray)
-import Test.QuickCheck.Gen
-import Test.QuickCheck.Arbitrary
+import Test.QuickCheck.Gen (Gen, arrayOf, oneOf)
+import Test.QuickCheck.Arbitrary (class Coarbitrary, class Arbitrary, coarbitrary)
 
 -- | A newtype for `String` whose `Arbitrary` instance generated random
 -- | alphanumeric strings.

src/Test/QuickCheck/Data/ApproxNumber.purs

@@ -1,19 +1,21 @@
 module Test.QuickCheck.Data.ApproxNumber where
 
-import Prelude
+import Prelude (class Num, class DivisionRing, class Ring, class ModuloSemiring, class Semiring, class Ord, class Eq, (-), mod, (/), one, (*), zero, (+), compare, (<$>), negate, (>=), (&&), (<=))
 
-import Test.QuickCheck.Arbitrary
+import Test.QuickCheck.Arbitrary (class Coarbitrary, class Arbitrary, coarbitrary, arbitrary)
 
 -- | A newtype for `Number` whose `Eq` instance uses an epsilon value to allow
 -- | for precision erros when comparing.
 newtype ApproxNumber = ApproxNumber Number
 
 -- Approximate equality comparison
-(=~=) :: Number -> Number -> Boolean
-(=~=) x y = (y - x) <= epsilon && (y - x) >= (-epsilon)
+approximateEqual :: Number -> Number -> Boolean
+approximateEqual x y = (y - x) <= epsilon && (y - x) >= (-epsilon)
   where
   epsilon = 0.00000001
 
+infix 2 approximateEqual as =~=
+
 instance arbitraryApproxNumber :: Arbitrary ApproxNumber where
   arbitrary = ApproxNumber <$> arbitrary
 

src/Test/QuickCheck/Gen.purs

@@ -27,26 +27,24 @@ module Test.QuickCheck.Gen
   , randomSample'
   ) where
 
-import Prelude
+import Prelude (bind, (/), (<$>), return, ($), one, (-), zero, (==), pure, (<#>), (<=), (<<<), map, (<), (+), otherwise, (>=), mod, (*), (>>>))
 
 import Control.Monad.Eff (Eff())
 import Control.Monad.Eff.Random (RANDOM())
 import Control.Monad.State (State(), runState, evalState)
 import Control.Monad.State.Class (state, modify)
-import Control.Monad.Rec.Class (MonadRec, tailRecM)
-import Math ((%))
+import Control.Monad.Rec.Class (class MonadRec, tailRecM)
 import Data.Array ((!!), length)
 import Data.Tuple (Tuple(..))
 import Data.Foldable (fold)
-import Data.Int (toNumber, fromNumber)
+import Data.Int (toNumber)
 import Data.Maybe (fromMaybe)
-import Data.Maybe.Unsafe as U
 import Data.Monoid.Additive (Additive(..), runAdditive)
 import Data.Tuple (Tuple(..), fst, snd)
 import Data.Either (Either(..))
 import Data.List (List(..), fromList)
-import Test.QuickCheck.LCG
-import qualified Math as M
+import Test.QuickCheck.LCG (Seed, lcgPerturb, lcgN, lcgNext, runSeed, randomSeed)
+import Math as M
 
 -- | Tests are parameterized by the `Size` of the randomly-generated data,
 -- | the meaning of which depends on the particular generator used.

src/Test/QuickCheck/LCG.purs

@@ -10,13 +10,13 @@ module Test.QuickCheck.LCG
   , randomSeed
   ) where
 
-import Prelude
+import Prelude (class Eq, class Show, eq, show, (<>), mod, (+), (-), (<$>), (<<<), (*), ($))
 
 import Math ((%))
 import Control.Monad.Eff (Eff())
 import Control.Monad.Eff.Random (RANDOM(), randomInt)
 import Data.Int (fromNumber, toNumber)
-import qualified Data.Maybe.Unsafe as U
+import Data.Maybe.Unsafe as U
 
 -- | The *multiplier*: a magic constant for the linear congruential generator
 lcgM :: Int