Ranged-sets 0.2.1 → 0.3.0
raw patch · 6 files changed
+204/−157 lines, 6 filesdep ~QuickCheckdep ~basePVP ok
version bump matches the API change (PVP)
Dependency ranges changed: QuickCheck, base
API changes (from Hackage documentation)
+ Data.Ranged.Boundaries: instance CoArbitrary a => CoArbitrary (Boundary a)
+ Data.Ranged.RangedSet: instance (CoArbitrary v, DiscreteOrdered v, Show v) => CoArbitrary (RSet v)
+ Data.Ranged.Ranges: instance (CoArbitrary v, DiscreteOrdered v, Show v) => CoArbitrary (Range v)
Files
- CHANGES.txt +14/−9
- Data/Ranged/Boundaries.hs +12/−10
- Data/Ranged/RangedSet.hs +20/−18
- Data/Ranged/Ranges.hs +25/−22
- Ranged-sets.cabal +54/−21
- tests/Main.hs +79/−77
CHANGES.txt view
@@ -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.
Data/Ranged/Boundaries.hs view
@@ -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
Data/Ranged/RangedSet.hs view
@@ -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))
Data/Ranged/Ranges.hs view
@@ -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]- +
Ranged-sets.cabal view
@@ -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:
tests/Main.hs view
@@ -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