diff --git a/checkers.cabal b/checkers.cabal
--- a/checkers.cabal
+++ b/checkers.cabal
@@ -1,5 +1,5 @@
 Name:                checkers
-Version:             0.2.8
+Version:             0.2.9
 Cabal-Version:       >= 1.2
 Synopsis:            Check properties on standard classes and data structures.
 Category:            Testing
diff --git a/src/Test/QuickCheck/Checkers.hs b/src/Test/QuickCheck/Checkers.hs
--- a/src/Test/QuickCheck/Checkers.hs
+++ b/src/Test/QuickCheck/Checkers.hs
@@ -48,6 +48,7 @@
 import Data.Function (on)
 import Control.Applicative
 import Control.Arrow ((***),first)
+import qualified Control.Exception as Ex
 import Data.List (foldl')
 import System.Random
 import Test.QuickCheck
@@ -89,8 +90,10 @@
      mapM_ pr tests
  where
    pr (s,p) = do putStr (padTo (width + 4) ("  "++s ++ ":"))
-                 catch (quickCheckWith args p) print
+                 Ex.catch (quickCheckWith args p) 
+                          (print :: Ex.SomeException -> IO ())
    width    = foldl' max 0 (map (length.fst) tests)
+
 
 padTo :: Int -> String -> String
 padTo n = take n . (++ repeat ' ')
diff --git a/src/Test/QuickCheck/Instances/List.hs b/src/Test/QuickCheck/Instances/List.hs
--- a/src/Test/QuickCheck/Instances/List.hs
+++ b/src/Test/QuickCheck/Instances/List.hs
@@ -46,11 +46,11 @@
 monotonic gen = monotonic_ anyList gen
 
 -- | Generate increasing towards infinity
-increasing :: (Arbitrary a, Num a) => Gen [a]
+increasing :: (Arbitrary a, Eq a, Num a) => Gen [a]
 increasing = monotonic positive
 
 -- | Generate an infinite list of increasing values
-increasingInf :: (Arbitrary a, Num a) => Gen [a]
+increasingInf :: (Arbitrary a, Eq a, Num a) => Gen [a]
 increasingInf = monotonic_ infiniteList positive
 
 -- | Generate nondecreasing values
@@ -62,11 +62,11 @@
 nondecreasingInf = monotonic_ infiniteList nonNegative
 
 -- | Generate increasing towards infinity
-decreasing :: (Arbitrary a, Num a) => Gen [a]
+decreasing :: (Arbitrary a, Eq a, Num a) => Gen [a]
 decreasing = monotonic negative
 
 -- | Generate an infinite list of increasing values
-decreasingInf :: (Arbitrary a, Num a) => Gen [a]
+decreasingInf :: (Arbitrary a, Eq a, Num a) => Gen [a]
 decreasingInf = monotonic_ infiniteList negative
 
 -- | Generate nondecreasing values
diff --git a/src/Test/QuickCheck/Instances/Num.hs b/src/Test/QuickCheck/Instances/Num.hs
--- a/src/Test/QuickCheck/Instances/Num.hs
+++ b/src/Test/QuickCheck/Instances/Num.hs
@@ -11,18 +11,18 @@
 nonNegative :: (Num a, Arbitrary a) => Gen a
 nonNegative = abs <$> arbitrary
 
-positive :: (Num a, Arbitrary a) => Gen a
+positive :: (Eq a, Num a, Arbitrary a) => Gen a
 positive = nonZero nonNegative
 
 nonPositive :: (Num a, Arbitrary a) => Gen a
 nonPositive = negate <$> nonNegative
 
-negative :: (Num a, Arbitrary a) => Gen a
+negative :: (Eq a, Num a, Arbitrary a) => Gen a
 negative = negate <$> positive
 
-nonZero :: (Num a, Arbitrary a) => Gen a -> Gen a
+nonZero :: (Eq a, Num a, Arbitrary a) => Gen a -> Gen a
 nonZero g =
   sized (\s -> satisfiesM (/= 0) (if (s == 0) then (resize 1 g) else g))
 
-nonZero_ :: (Num a, Arbitrary a) => Gen a
+nonZero_ :: (Eq a, Num a, Arbitrary a) => Gen a
 nonZero_ = nonZero arbitrary
diff --git a/src/Test/QuickCheck/Later.hs b/src/Test/QuickCheck/Later.hs
--- a/src/Test/QuickCheck/Later.hs
+++ b/src/Test/QuickCheck/Later.hs
@@ -31,7 +31,7 @@
 import Control.Monad (forever)
 
 -- Generate a random delay up to given max seconds for a property.
-delayP :: (Num t, System.Random.Random t, Testable b) => t -> (t -> b) -> Property
+delayP :: (Show t, Num t, System.Random.Random t, Testable b) => t -> (t -> b) -> Property
 delayP d = forAll (genR (0,d))
 
 -- | Is the given function commutative when restricted to the same value