diff --git a/CHANGES.txt b/CHANGES.txt
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,13 +1,15 @@
-Version 0.0.4
+Version 0.0.2
 -------------
 
-Added Monoid instances and singleton ranges, courtesy of Jean-Philippe
-Bernardy.
+Fixed the infinite loop with infinite sets, at least as far as possible.
+Added lots more QuickCheck properties.
+Added subset predicates.
+Added infix operators.
 
 Version 0.0.3
 -------------
 
-Removed support for infinite sets.  They sometimes still work, but generally 
+Removed support for infinite sets.  They sometimes still work, but generally
 are more trouble than they are worth.  There is no simple set of rules for
 client applications to guarantee termination.
 
@@ -28,13 +30,11 @@
 
 
 
-Version 0.0.2
+Version 0.0.4
 -------------
 
-Fixed the infinite loop with infinite sets, at least as far as possible.
-Added lots more QuickCheck properties.
-Added subset predicates.
-Added infix operators.
+Added Monoid instances and singleton ranges, courtesy of Jean-Philippe
+Bernardy.
 
 Version 0.2.0
 -------------
@@ -45,3 +45,8 @@
 Version 0.2.1
 -------------
 Require QuickCheck < 2.
+
+Version 0.3.0
+-------------
+Require QuickCheck >= 2.4. This changes the API for the Arbitrary and CoArbitrary
+instances, so it gets a version number bump.
diff --git a/Data/Ranged/Boundaries.hs b/Data/Ranged/Boundaries.hs
--- a/Data/Ranged/Boundaries.hs
+++ b/Data/Ranged/Boundaries.hs
@@ -55,27 +55,27 @@
    adjacentBelow :: a -> Maybe a
 
 
--- Implementation note: the precise rules about unbounded enumerated vs 
+-- Implementation note: the precise rules about unbounded enumerated vs
 -- bounded enumerated types are difficult to express using Haskell 98, so
 -- the prelude types are listed individually here.
 
-instance DiscreteOrdered Bool where 
+instance DiscreteOrdered Bool where
    adjacent = boundedAdjacent
    adjacentBelow = boundedBelow
 
-instance DiscreteOrdered Ordering where 
+instance DiscreteOrdered Ordering where
    adjacent = boundedAdjacent
    adjacentBelow = boundedBelow
 
-instance DiscreteOrdered Char where 
+instance DiscreteOrdered Char where
    adjacent = boundedAdjacent
    adjacentBelow = boundedBelow
 
-instance DiscreteOrdered Int where 
+instance DiscreteOrdered Int where
    adjacent = boundedAdjacent
    adjacentBelow = boundedBelow
 
-instance DiscreteOrdered Integer where 
+instance DiscreteOrdered Integer where
    adjacent = enumAdjacent
    adjacentBelow = Just . pred
 
@@ -220,8 +220,10 @@
          v <- arbitrary
          oneof [return $ BoundaryAbove v, return $ BoundaryBelow v]
       )]
-   coarbitrary BoundaryBelowAll   = variant 0
-   coarbitrary BoundaryAboveAll   = variant 1
-   coarbitrary (BoundaryBelow v)  = variant 2 . coarbitrary v
-   coarbitrary (BoundaryAbove v)  = variant 3 . coarbitrary v
+
+instance CoArbitrary a => CoArbitrary (Boundary a) where
+   coarbitrary BoundaryBelowAll   = variant (0 :: Int)
+   coarbitrary BoundaryAboveAll   = variant (1 :: Int)
+   coarbitrary (BoundaryBelow v)  = variant (2 :: Int) . coarbitrary v
+   coarbitrary (BoundaryAbove v)  = variant (3 :: Int) . coarbitrary v
 
diff --git a/Data/Ranged/RangedSet.hs b/Data/Ranged/RangedSet.hs
--- a/Data/Ranged/RangedSet.hs
+++ b/Data/Ranged/RangedSet.hs
@@ -82,7 +82,7 @@
 
 validRangeList [] = True
 validRangeList [Range lower upper] = lower <= upper
-validRangeList ranges = and $ zipWith okAdjacent ranges (tail ranges)
+validRangeList rs = and $ zipWith okAdjacent rs (tail rs)
    where
       okAdjacent (Range lower1 upper1) (Range lower2 upper2) =
          lower1 <= upper1 && upper1 <= lower2 && lower2 <= upper2
@@ -91,8 +91,7 @@
 -- | Rearrange and merge the ranges in the list so that they are in order and
 -- non-overlapping.
 normaliseRangeList :: DiscreteOrdered v => [Range v] -> [Range v]
-normaliseRangeList ranges =
-   normalise $ sort $ filter (not . rangeIsEmpty) ranges
+normaliseRangeList = normalise . sort . filter (not . rangeIsEmpty)
 
 
 -- Private routine: normalise a range list that is known to be already sorted.
@@ -204,12 +203,12 @@
 
 -- | Set negation.
 rSetNegation :: DiscreteOrdered a => RSet a -> RSet a
-rSetNegation set = RSet $ ranges $ setBounds1
+rSetNegation set = RSet $ ranges1 $ setBounds1
    where
-      ranges (b1:b2:bs) = Range b1 b2 : ranges bs
-      ranges [BoundaryAboveAll] = []
-      ranges [b] = [Range b BoundaryAboveAll]
-      ranges _ = []
+      ranges1 (b1:b2:bs) = Range b1 b2 : ranges1 bs
+      ranges1 [BoundaryAboveAll] = []
+      ranges1 [b] = [Range b BoundaryAboveAll]
+      ranges1 _ = []
       setBounds1 = case setBounds of
          (BoundaryBelowAll : bs)  -> bs
          _                        -> BoundaryBelowAll : setBounds
@@ -237,12 +236,12 @@
       -- boundary, which must return a result greater than the argument
       -- (not checked).  If ranges overlap then they will be merged.
    -> RSet a
-rSetUnfold bound upperFunc succFunc = RSet $ normalise $ ranges bound
+rSetUnfold bound upperFunc succFunc = RSet $ normalise $ ranges1 bound
    where
-      ranges b =
+      ranges1 b =
          Range b (upperFunc b)
          : case succFunc b of
-            Just b2 -> ranges b2
+            Just b2 -> ranges1 b2
             Nothing -> []
 
 
@@ -265,7 +264,10 @@
          rangeList (b1:b2:bs) = Range b1 b2 : rangeList bs
          rangeList _ = []
 
-   coarbitrary (RSet ls) = variant 0 . coarbitrary ls
+instance (CoArbitrary v, DiscreteOrdered v, Show v) =>
+      CoArbitrary (RSet v)
+   where
+   coarbitrary (RSet ls) = variant (0 :: Int) . coarbitrary ls
 
 -- ==================================================================
 -- QuickCheck Properties
@@ -290,14 +292,14 @@
 prop_has ls v = (ls `rangeListHas` v) == makeRangedSet ls -?- v
 
 
--- | Verifies the correct membership of a set containing all integers 
+-- | Verifies the correct membership of a set containing all integers
 -- starting with the digit \"1\" up to 19999.
 --
 -- > prop_unfold = (v <= 99999 && head (show v) == '1') == (initial1 -?- v)
 -- >    where
 -- >       initial1 = rSetUnfold (BoundaryBelow 1) addNines times10
 -- >       addNines (BoundaryBelow n) = BoundaryAbove $ n * 2 - 1
--- >       times10 (BoundaryBelow n) = 
+-- >       times10 (BoundaryBelow n) =
 -- >          if n <= 1000 then Just $ BoundaryBelow $ n * 10 else Nothing
 
 prop_unfold :: Integer -> Bool
@@ -306,7 +308,7 @@
       initial1 = rSetUnfold (BoundaryBelow 1) addNines times10
       addNines (BoundaryBelow n) = BoundaryAbove $ n * 2 - 1
       addNines _ = error "Can't happen"
-      times10 (BoundaryBelow n) = 
+      times10 (BoundaryBelow n) =
          if n <= 10000 then Just $ BoundaryBelow $ n * 10 else Nothing
       times10 _ = error "Can't happen"
 
@@ -317,7 +319,7 @@
 -- | Iff a value is in either of two ranged sets then it is in the union of
 -- those two sets.
 --
--- > prop_union rs1 rs2 v = 
+-- > prop_union rs1 rs2 v =
 -- >    (rs1 -?- v || rs2 -?- v) == ((rs1 -\/- rs2) -?- v)
 prop_union :: (DiscreteOrdered a ) => RSet a -> RSet a -> a -> Bool
 prop_union rs1 rs2 v = (rs1 -?- v || rs2 -?- v) == ((rs1 -\/- rs2) -?- v)
@@ -452,7 +454,7 @@
 --
 -- > prop_intersection_associates rs1 rs2 rs3 =
 -- >    ((rs1 -/\- rs2) -/\- rs3) == (rs1 -/\- (rs2 -/\- rs3))
-prop_intersection_associates :: (DiscreteOrdered a) => 
+prop_intersection_associates :: (DiscreteOrdered a) =>
    RSet a -> RSet a  -> RSet a -> Bool
 prop_intersection_associates rs1 rs2 rs3 =
    ((rs1 -/\- rs2) -/\- rs3) == (rs1 -/\- (rs2 -/\- rs3))
@@ -461,7 +463,7 @@
 --
 -- > prop_union_associates rs1 rs2 rs3 =
 -- >    ((rs1 -\/- rs2) -\/- rs3) == (rs1 -\/- (rs2 -\/- rs3))
-prop_union_associates :: (DiscreteOrdered a) => 
+prop_union_associates :: (DiscreteOrdered a) =>
    RSet a -> RSet a  -> RSet a -> Bool
 prop_union_associates rs1 rs2 rs3 =
    ((rs1 -\/- rs2) -\/- rs3) == (rs1 -\/- (rs2 -\/- rs3))
diff --git a/Data/Ranged/Ranges.hs b/Data/Ranged/Ranges.hs
--- a/Data/Ranged/Ranges.hs
+++ b/Data/Ranged/Ranges.hs
@@ -119,10 +119,10 @@
 -- | If the range is a singleton, returns @Just@ the value.  Otherwise returns
 -- @Nothing@.
 --
--- Known bug: This always returns @Nothing@ for ranges including 
--- @BoundaryBelowAll@ or @BoundaryAboveAll@.  For bounded types this can be 
+-- Known bug: This always returns @Nothing@ for ranges including
+-- @BoundaryBelowAll@ or @BoundaryAboveAll@.  For bounded types this can be
 -- incorrect.  For instance, the following range only contains one value:
--- 
+--
 -- >    Range (BoundaryBelow maxBound) BoundaryAboveAll
 rangeSingletonValue :: DiscreteOrdered v => Range v -> Maybe v
 rangeSingletonValue (Range (BoundaryBelow v1) (BoundaryBelow v2))
@@ -131,7 +131,7 @@
 rangeSingletonValue (Range (BoundaryBelow v1) (BoundaryAbove v2))
    | v1 == v2        = Just v1
    | otherwise       = Nothing
-rangeSingletonValue (Range (BoundaryAbove v1) (BoundaryBelow v2)) = 
+rangeSingletonValue (Range (BoundaryAbove v1) (BoundaryBelow v2)) =
    do
       v2' <- adjacentBelow v2
       v2'' <- adjacentBelow v2'
@@ -234,15 +234,18 @@
       (1, return fullRange)
       ]
 
+instance (CoArbitrary v, DiscreteOrdered v, Show v) =>
+   CoArbitrary (Range v) where
+
    coarbitrary (Range lower upper) =
-      variant 0 . coarbitrary lower . coarbitrary upper
+      variant (0 :: Int) . coarbitrary lower . coarbitrary upper
 
 
 
 -- QuickCheck Properties
 
 -- | The union of two ranges has a value iff either range has it.
--- 
+--
 -- > prop_unionRange r1 r2 n =
 -- >    (r1 `rangeHas` n || r2 `rangeHas` n)
 -- >    == (r1 `rangeUnion` r2) `rangeListHas` n
@@ -252,7 +255,7 @@
    == (r1 `rangeUnion` r2) `rangeListHas` n
 
 -- | The union of two ranges always contains one or two ranges.
--- 
+--
 -- > prop_unionRangeLength r1 r2 = (n == 1) || (n == 2)
 -- >    where n = length $ rangeUnion r1 r2
 prop_unionRangeLength :: (DiscreteOrdered a) => Range a -> Range a -> Bool
@@ -260,7 +263,7 @@
    where n = length $ rangeUnion r1 r2
 
 -- | The intersection of two ranges has a value iff both ranges have it.
--- 
+--
 -- > prop_intersectionRange r1 r2 n =
 -- >    (r1 `rangeHas` n && r2 `rangeHas` n)
 -- >    == (r1 `rangeIntersection` r2) `rangeHas` n
@@ -271,7 +274,7 @@
 
 -- | The difference of two ranges has a value iff the first range has it and
 -- the second does not.
--- 
+--
 -- > prop_differenceRange r1 r2 n =
 -- >    (r1 `rangeHas` n && not (r2 `rangeHas` n))
 -- >    == (r1 `rangeDifference` r2) `rangeListHas` n
@@ -281,28 +284,28 @@
    == (r1 `rangeDifference` r2) `rangeListHas` n
 
 -- | Iff two ranges overlap then their intersection is non-empty.
--- 
--- > prop_intersectionOverlap r1 r2 = 
+--
+-- > prop_intersectionOverlap r1 r2 =
 -- >     (rangeIsEmpty $ rangeIntersection r1 r2) == (rangeOverlap r1 r2)
 prop_intersectionOverlap :: (DiscreteOrdered a) => Range a -> Range a -> Bool
-prop_intersectionOverlap r1 r2 = 
+prop_intersectionOverlap r1 r2 =
     (rangeIsEmpty $ rangeIntersection r1 r2) == not (rangeOverlap r1 r2)
 
 -- | Range enclosure makes union an identity function.
--- 
--- > prop_enclosureUnion r1 r2 = 
+--
+-- > prop_enclosureUnion r1 r2 =
 -- >    rangeEncloses r1 r2 == (rangeUnion r1 r2 == [r1])
 prop_enclosureUnion :: (DiscreteOrdered a) => Range a -> Range a -> Bool
 prop_enclosureUnion r1 r2 = rangeEncloses r1 r2 == (rangeUnion r1 r2 == [r1])
 
 -- | Range Singleton has its member.
--- 
+--
 -- > prop_singletonRangeHas v = singletonRange v `rangeHas` v
 prop_singletonRangeHas :: (DiscreteOrdered a) => a -> Bool
 prop_singletonRangeHas v = singletonRange v `rangeHas` v
 
 -- | Range Singleton has only its member.
--- 
+--
 -- > prop_singletonHasOnly v1 v2 =
 -- >    (v1 == v2) == (singletonRange v1 `rangeHas` v2)
 prop_singletonRangeHasOnly :: (DiscreteOrdered a) => a -> a -> Bool
@@ -310,7 +313,7 @@
    (v1 == v2) == (singletonRange v1 `rangeHas` v2)
 
 -- | A singleton range can have its value extracted.
--- 
+--
 -- > prop_singletonRangeConverse v =
 -- >    rangeSingletonValue (singletonRange v) == Just v
 prop_singletonRangeConverse:: (DiscreteOrdered a) => a -> Bool
@@ -318,17 +321,17 @@
    rangeSingletonValue (singletonRange v) == Just v
 
 -- | The empty range is not a singleton.
--- 
+--
 -- > prop_emptyNonSingleton = rangeSingletonValue emptyRange == Nothing
 prop_emptyNonSingleton :: Bool
-prop_emptyNonSingleton = 
+prop_emptyNonSingleton =
     rangeSingletonValue (emptyRange :: Range Int) == Nothing
 
 -- | The full range is not a singleton.
--- 
+--
 -- > prop_fullNonSingleton = rangeSingletonValue fullRange == Nothing
 prop_fullNonSingleton :: Bool
-prop_fullNonSingleton = 
+prop_fullNonSingleton =
     rangeSingletonValue (fullRange :: Range Int) == Nothing
 
 -- | For real x and y, @x < y@ implies that any range between them is a
@@ -352,5 +355,5 @@
     where
       rangeAround v1 v2 = return Range `ap` genBound v1 `ap` genBound v2
       genBound v = elements [BoundaryAbove v, BoundaryBelow v]
-   
+
 
diff --git a/Ranged-sets.cabal b/Ranged-sets.cabal
--- a/Ranged-sets.cabal
+++ b/Ranged-sets.cabal
@@ -1,21 +1,54 @@
-Name:           Ranged-sets
-Version:        0.2.1
-License:        BSD3
-License-file:   LICENSE.txt
-Copyright:      Paul Johnson, 2005, 2006, 2007, 2008
-Author:         Paul Johnson
-Homepage:       http://code.haskell.org/ranged-sets
-Maintainer:     paul@cogito.org.uk
-Stability:      beta
-Category:       Data
-Build-Depends:  base, QuickCheck<2, HUnit
-Build-type:     Simple
-Synopsis:       Ranged sets for Haskell
-Description:	A ranged set is an ordered list of ranges.  This allows sets
-           	such as all reals x such that
-                (0.25 < x <= 0.75 or 1.4 <= x < 2.3 or 4.5 < x).
-Exposed-modules: Data.Ranged, Data.Ranged.Boundaries, Data.Ranged.Ranges,
-		Data.Ranged.RangedSet
-Extra-source-files: tests/Makefile, tests/Main.hs, README.txt, CHANGES.txt,
-		INSTALL.txt, TODO.txt
-ghc-options:    -Wall
+name: Ranged-sets
+version: 0.3.0
+cabal-version: -any
+build-type: Simple
+license: BSD3
+license-file: LICENSE.txt
+copyright: Paul Johnson, 2005, 2006, 2007, 2008
+maintainer: paul@cogito.org.uk
+build-depends: HUnit -any, QuickCheck >=2, base >=4 && <5
+stability: beta
+homepage: http://code.haskell.org/ranged-sets
+package-url:
+bug-reports:
+synopsis: Ranged sets for Haskell
+description: A ranged set is an ordered list of ranges.  This allows sets such as all reals x such that:
+             .
+             > (0.25 < x <= 0.75 or 1.4 <= x < 2.3 or 4.5 < x)
+             .
+             Alternatively you can have all strings s such that:
+             .
+             >    ("F" <= s < "G")
+category: Data
+author: Paul Johnson
+tested-with:
+data-files:
+data-dir: ""
+extra-source-files: CHANGES.txt INSTALL.txt README.txt TODO.txt
+                    tests/Main.hs tests/Makefile
+extra-tmp-files:
+exposed-modules: Data.Ranged Data.Ranged.Ranges
+                 Data.Ranged.RangedSet Data.Ranged.Boundaries
+exposed: True
+buildable: True
+build-tools:
+cpp-options:
+cc-options:
+ld-options:
+pkgconfig-depends:
+frameworks:
+c-sources:
+extensions:
+extra-libraries:
+extra-lib-dirs:
+includes:
+install-includes:
+include-dirs:
+hs-source-dirs: .
+other-modules:
+ghc-prof-options:
+ghc-shared-options:
+ghc-options: -Wall
+hugs-options:
+nhc98-options:
+jhc-options:
diff --git a/tests/Main.hs b/tests/Main.hs
--- a/tests/Main.hs
+++ b/tests/Main.hs
@@ -7,178 +7,180 @@
 import Test.QuickCheck
 
 
-conf :: Config
-conf = defaultConfig { configMaxTest = 1000, configMaxFail = 10000 }
+conf :: Args
+conf = stdArgs { maxSuccess = 1000, maxDiscard = 10000 }
 
+check :: (Test.QuickCheck.Testable prop) => prop -> IO ()
+check = quickCheckWith conf
 
 main :: IO ()
 main = do
    putStrLn "QuickCheck Data.Ranged.Ranges:"
    putStrLn "   Sparse type Integer:"
    putStrLn "      * prop_unionRange"
-   check conf $ \(r1 :: Range Integer) -> prop_unionRange r1
+   check $ \(r1 :: Range Integer) -> prop_unionRange r1
    putStrLn "      * prop_unionRangeLength"
-   check conf $ \(r1 :: Range Integer) -> prop_unionRangeLength r1
+   check $ \(r1 :: Range Integer) -> prop_unionRangeLength r1
    putStrLn "      * prop_intersectionRange"
-   check conf $ \(r1 :: Range Integer) -> prop_intersectionRange r1
+   check $ \(r1 :: Range Integer) -> prop_intersectionRange r1
    putStrLn "      * prop_intersectionOverlap"
-   check conf $ \(r1 :: Range Integer) -> prop_intersectionOverlap r1
+   check $ \(r1 :: Range Integer) -> prop_intersectionOverlap r1
    putStrLn "      * prop_enclosureUnion"
-   check conf $ \(r1 :: Range Integer) -> prop_enclosureUnion r1
+   check $ \(r1 :: Range Integer) -> prop_enclosureUnion r1
    putStrLn "      * prop_differenceRange"
-   check conf $ \(r1 :: Range Integer) -> prop_differenceRange r1
+   check $ \(r1 :: Range Integer) -> prop_differenceRange r1
    putStrLn "      * prop_singletonRangeHas"
-   check conf $ \(v :: Integer) -> prop_singletonRangeHas v
+   check $ \(v :: Integer) -> prop_singletonRangeHas v
    putStrLn "      * prop_singletonRangeHasOnly"
-   check conf $ \(v :: Integer) -> prop_singletonRangeHasOnly v
+   check $ \(v :: Integer) -> prop_singletonRangeHasOnly v
    putStrLn "      * prop_singletonRangeConverse"
-   check conf $ \(v :: Integer) -> prop_singletonRangeConverse v
+   check $ \(v :: Integer) -> prop_singletonRangeConverse v
 
    putStrLn "   Dense type Double:"
    putStrLn "      * prop_unionRange"
-   check conf $ \(r1 :: Range Double) -> prop_unionRange r1
+   check $ \(r1 :: Range Double) -> prop_unionRange r1
    putStrLn "      * prop_unionRangeLength"
-   check conf $ \(r1 :: Range Double) -> prop_unionRangeLength r1
+   check $ \(r1 :: Range Double) -> prop_unionRangeLength r1
    putStrLn "      * prop_intersectionRange"
-   check conf $ \(r1 :: Range Double) -> prop_intersectionRange r1
+   check $ \(r1 :: Range Double) -> prop_intersectionRange r1
    putStrLn "      * prop_intersectionOverlap"
-   check conf $ \(r1 :: Range Integer) -> prop_intersectionOverlap r1
+   check $ \(r1 :: Range Integer) -> prop_intersectionOverlap r1
    putStrLn "      * prop_enclosureUnion"
-   check conf $ \(r1 :: Range Integer) -> prop_enclosureUnion r1
+   check $ \(r1 :: Range Integer) -> prop_enclosureUnion r1
    putStrLn "      * prop_differenceRange"
-   check conf $ \(r1 :: Range Double) -> prop_differenceRange r1
+   check $ \(r1 :: Range Double) -> prop_differenceRange r1
    putStrLn "      * prop_singletonRangeHas"
-   check conf $ \(v :: Double) -> prop_singletonRangeHas v
+   check $ \(v :: Double) -> prop_singletonRangeHas v
    putStrLn "      * prop_singletonRangeHasOnly"
-   check conf $ \(v :: Double) -> prop_singletonRangeHasOnly v
+   check $ \(v :: Double) -> prop_singletonRangeHasOnly v
    putStrLn "      * prop_singletonRangeConverse"
-   check conf $ \(v :: Double) -> prop_singletonRangeConverse v
+   check $ \(v :: Double) -> prop_singletonRangeConverse v
 
    putStrLn "   Type-insensitive tests:"
    putStrLn "      * prop_emptyNonSingleton"
-   check conf prop_emptyNonSingleton
+   check prop_emptyNonSingleton
    putStrLn "      * prop_fullNonSingleton"
-   check conf prop_fullNonSingleton
+   check prop_fullNonSingleton
    putStrLn "      * prop_nonSingleton"
-   check conf prop_nonSingleton
+   check prop_nonSingleton
    putStrLn "      * prop_intSingleton"
-   check conf prop_intSingleton
+   check prop_intSingleton
 
    putStrLn "   Checking show for range:"
-   runTestTT $ TestList 
+   _ <- runTestTT $ TestList
        [
-        TestCase $ assertEqual "Show range1" "3 <= x <= 8" $ 
+        TestCase $ assertEqual "Show range1" "3 <= x <= 8" $
                  show $ Range (BoundaryBelow (3 :: Int)) (BoundaryAbove 8),
         TestCase $ assertEqual "Show range2" "x < 8" $
                  show $ Range (BoundaryBelowAll) (BoundaryBelow (8 :: Int)),
         TestCase $ assertEqual "Show range3" "3 < x" $
                  show $ Range (BoundaryAbove (3 :: Int)) (BoundaryAboveAll),
-        TestCase $ assertEqual "Show singleton" "x == 4" $ 
+        TestCase $ assertEqual "Show singleton" "x == 4" $
                  show $ singletonRange (4 :: Int),
-        TestCase $ assertEqual "Show full" "All x" $ 
+        TestCase $ assertEqual "Show full" "All x" $
                  show (fullRange :: Range Int),
-        TestCase $ assertEqual "Show empty" "Empty" $ 
+        TestCase $ assertEqual "Show empty" "Empty" $
                  show (emptyRange :: Range Int)
        ]
 
    putStrLn "QuickCheck Data.Ranged.RangedSet:"
    putStrLn "   Sparse type Integer:"
    putStrLn "      * prop_validNormalised"
-   check conf $ \(rs :: [Range Integer]) -> prop_validNormalised rs
+   check $ \(rs :: [Range Integer]) -> prop_validNormalised rs
    putStrLn "      * prop_has"
-   check conf $ \(rs :: [Range Integer]) -> prop_has rs
+   check $ \(rs :: [Range Integer]) -> prop_has rs
    putStrLn "      * prop_unfold"
-   check conf prop_unfold
+   check prop_unfold
    putStrLn "      * prop_union"
-   check conf $ \(rset1 :: RSet Integer) -> prop_union rset1
+   check $ \(rset1 :: RSet Integer) -> prop_union rset1
    putStrLn "      * prop_intersection"
-   check conf $ \(rset1 :: RSet Integer) -> prop_intersection rset1
+   check $ \(rset1 :: RSet Integer) -> prop_intersection rset1
    putStrLn "      * prop_difference"
-   check conf $ \(rset1 :: RSet Integer) -> prop_difference rset1
+   check $ \(rset1 :: RSet Integer) -> prop_difference rset1
    putStrLn "      * prop_negation"
-   check conf $ \(rset1 :: RSet Integer) -> prop_negation rset1
+   check $ \(rset1 :: RSet Integer) -> prop_negation rset1
    putStrLn "      * prop_not_empty"
-   check conf $ \(rset1 :: RSet Integer) -> prop_not_empty rset1
+   check $ \(rset1 :: RSet Integer) -> prop_not_empty rset1
    putStrLn "      * prop_empty"
-   check conf $ \(v :: Integer) -> prop_empty v
+   check $ \(v :: Integer) -> prop_empty v
    putStrLn "      * prop_full"
-   check conf $ \(v :: Integer) -> prop_full v
+   check $ \(v :: Integer) -> prop_full v
    putStrLn "      * prop_empty_intersection"
-   check conf $ \(rset1 :: RSet Integer) -> prop_empty_intersection rset1
+   check $ \(rset1 :: RSet Integer) -> prop_empty_intersection rset1
    putStrLn "      * prop_full_union"
-   check conf $ \(rset1 :: RSet Integer) -> prop_full_union rset1
+   check $ \(rset1 :: RSet Integer) -> prop_full_union rset1
    putStrLn "      * prop_union_superset"
-   check conf $ \(rset1 :: RSet Integer) -> prop_union_superset rset1
+   check $ \(rset1 :: RSet Integer) -> prop_union_superset rset1
    putStrLn "      * prop_intersection_subset"
-   check conf $ \(rset1 :: RSet Integer) -> prop_intersection_subset rset1
+   check $ \(rset1 :: RSet Integer) -> prop_intersection_subset rset1
    putStrLn "      * prop_diff_intersect"
-   check conf $ \(rset1 :: RSet Integer) -> prop_diff_intersect rset1
+   check $ \(rset1 :: RSet Integer) -> prop_diff_intersect rset1
    putStrLn "      * prop_subset"
-   check conf $ \(rset1 :: RSet Integer) -> prop_subset rset1
+   check $ \(rset1 :: RSet Integer) -> prop_subset rset1
    putStrLn "      * prop_strict_subset"
-   check conf $ \(rset1 :: RSet Integer) -> prop_strict_subset rset1
+   check $ \(rset1 :: RSet Integer) -> prop_strict_subset rset1
    putStrLn "      * prop_union_strict_superset"
-   check conf $ \(rset1 :: RSet Integer) -> prop_union_strict_superset rset1
+   check $ \(rset1 :: RSet Integer) -> prop_union_strict_superset rset1
    putStrLn "      * prop_intersection_commutes"
-   check conf $ \(rset1 :: RSet Integer) -> prop_intersection_commutes rset1
+   check $ \(rset1 :: RSet Integer) -> prop_intersection_commutes rset1
    putStrLn "      * prop_union_commutes"
-   check conf $ \(rset1 :: RSet Integer) -> prop_union_commutes rset1
+   check $ \(rset1 :: RSet Integer) -> prop_union_commutes rset1
    putStrLn "      * prop_intersection_associates"
-   check conf $ \(rset1 :: RSet Integer) -> prop_intersection_associates rset1
+   check $ \(rset1 :: RSet Integer) -> prop_intersection_associates rset1
    putStrLn "      * prop_union_associates"
-   check conf $ \(rset1 :: RSet Integer) -> prop_union_associates rset1
+   check $ \(rset1 :: RSet Integer) -> prop_union_associates rset1
    putStrLn "      * prop_de_morgan_intersection"
-   check conf $ \(rset1 :: RSet Integer) -> prop_de_morgan_intersection rset1
+   check $ \(rset1 :: RSet Integer) -> prop_de_morgan_intersection rset1
    putStrLn "      * prop_de_morgan_union"
-   check conf $ \(rset1 :: RSet Integer) -> prop_de_morgan_union rset1
+   check $ \(rset1 :: RSet Integer) -> prop_de_morgan_union rset1
 
    putStrLn "   Dense type Double:"
    putStrLn "      * prop_validNormalised"
-   check conf $ \(rs :: [Range Double]) -> prop_validNormalised rs
+   check $ \(rs :: [Range Double]) -> prop_validNormalised rs
    putStrLn "      * prop_has"
-   check conf $ \(rs :: [Range Double]) -> prop_has rs
+   check $ \(rs :: [Range Double]) -> prop_has rs
    putStrLn "      * prop_unfold"
-   check conf prop_unfold
+   check prop_unfold
    putStrLn "      * prop_union"
-   check conf $ \(rset1 :: RSet Double) -> prop_union rset1
+   check $ \(rset1 :: RSet Double) -> prop_union rset1
    putStrLn "      * prop_intersection"
-   check conf $ \(rset1 :: RSet Double) -> prop_intersection rset1
+   check $ \(rset1 :: RSet Double) -> prop_intersection rset1
    putStrLn "      * prop_difference"
-   check conf $ \(rset1 :: RSet Double) -> prop_difference rset1
+   check $ \(rset1 :: RSet Double) -> prop_difference rset1
    putStrLn "      * prop_negation"
-   check conf $ \(rset1 :: RSet Double) -> prop_negation rset1
+   check $ \(rset1 :: RSet Double) -> prop_negation rset1
    putStrLn "      * prop_not_empty"
-   check conf $ \(rset1 :: RSet Double) -> prop_not_empty rset1
+   check $ \(rset1 :: RSet Double) -> prop_not_empty rset1
    putStrLn "      * prop_empty"
-   check conf $ \(v :: Double) -> prop_empty v
+   check $ \(v :: Double) -> prop_empty v
    putStrLn "      * prop_full"
-   check conf $ \(v :: Double) -> prop_full v
+   check $ \(v :: Double) -> prop_full v
    putStrLn "      * prop_empty_intersection"
-   check conf $ \(rset1 :: RSet Double) -> prop_empty_intersection rset1
+   check $ \(rset1 :: RSet Double) -> prop_empty_intersection rset1
    putStrLn "      * prop_full_union"
-   check conf $ \(rset1 :: RSet Double) -> prop_full_union rset1
+   check $ \(rset1 :: RSet Double) -> prop_full_union rset1
    putStrLn "      * prop_union_superset"
-   check conf $ \(rset1 :: RSet Double) -> prop_union_superset rset1
+   check $ \(rset1 :: RSet Double) -> prop_union_superset rset1
    putStrLn "      * prop_intersection_subset"
-   check conf $ \(rset1 :: RSet Double) -> prop_intersection_subset rset1
+   check $ \(rset1 :: RSet Double) -> prop_intersection_subset rset1
    putStrLn "      * prop_diff_intersect"
-   check conf $ \(rset1 :: RSet Double) -> prop_diff_intersect rset1
+   check $ \(rset1 :: RSet Double) -> prop_diff_intersect rset1
    putStrLn "      * prop_subset"
-   check conf $ \(rset1 :: RSet Double) -> prop_subset rset1
+   check $ \(rset1 :: RSet Double) -> prop_subset rset1
    putStrLn "      * prop_strict_subset"
-   check conf $ \(rset1 :: RSet Double) -> prop_strict_subset rset1
+   check $ \(rset1 :: RSet Double) -> prop_strict_subset rset1
    putStrLn "      * prop_union_strict_superset"
-   check conf $ \(rset1 :: RSet Double) -> prop_union_strict_superset rset1
+   check $ \(rset1 :: RSet Double) -> prop_union_strict_superset rset1
    putStrLn "      * prop_intersection_commutes"
-   check conf $ \(rset1 :: RSet Double) -> prop_intersection_commutes rset1
+   check $ \(rset1 :: RSet Double) -> prop_intersection_commutes rset1
    putStrLn "      * prop_union_commutes"
-   check conf $ \(rset1 :: RSet Double) -> prop_union_commutes rset1
+   check $ \(rset1 :: RSet Double) -> prop_union_commutes rset1
    putStrLn "      * prop_intersection_associates"
-   check conf $ \(rset1 :: RSet Double) -> prop_intersection_associates rset1
+   check $ \(rset1 :: RSet Double) -> prop_intersection_associates rset1
    putStrLn "      * prop_union_associates"
-   check conf $ \(rset1 :: RSet Double) -> prop_union_associates rset1
+   check $ \(rset1 :: RSet Double) -> prop_union_associates rset1
    putStrLn "      * prop_de_morgan_intersection"
-   check conf $ \(rset1 :: RSet Double) -> prop_de_morgan_intersection rset1
+   check $ \(rset1 :: RSet Double) -> prop_de_morgan_intersection rset1
    putStrLn "      * prop_de_morgan_union"
-   check conf $ \(rset1 :: RSet Double) -> prop_de_morgan_union rset1
+   check $ \(rset1 :: RSet Double) -> prop_de_morgan_union rset1