Improve test output of HashSet properties

Author: sjakobi

tests/Properties/HashSet.hs

@@ -30,10 +30,10 @@ instance Hashable Key where
 ------------------------------------------------------------------------
 -- ** Instances
 
-pEq :: [Key] -> [Key] -> Bool
+pEq :: [Key] -> [Key] -> Property
 pEq xs = (Set.fromList xs ==) `eq` (S.fromList xs ==)
 
-pNeq :: [Key] -> [Key] -> Bool
+pNeq :: [Key] -> [Key] -> Property
 pNeq xs = (Set.fromList xs /=) `eq` (S.fromList xs /=)
 
 -- We cannot compare to `Data.Map` as ordering is different.
@@ -78,7 +78,7 @@ pOrdEq xs ys = case (compare x y, x == y) of
 pReadShow :: [Key] -> Bool
 pReadShow xs = Set.fromList xs == read (show (Set.fromList xs))
 
-pFoldable :: [Int] -> Bool
+pFoldable :: [Int] -> Property
 pFoldable = (List.sort . Foldable.foldr (:) []) `eq`
             (List.sort . Foldable.foldr (:) [])
 
@@ -105,42 +105,42 @@ pHashable xs is salt =
 ------------------------------------------------------------------------
 -- ** Basic interface
 
-pSize :: [Key] -> Bool
+pSize :: [Key] -> Property
 pSize = Set.size `eq` S.size
 
-pMember :: Key -> [Key] -> Bool
+pMember :: Key -> [Key] -> Property
 pMember k = Set.member k `eq` S.member k
 
-pInsert :: Key -> [Key] -> Bool
+pInsert :: Key -> [Key] -> Property
 pInsert a = Set.insert a `eq_` S.insert a
 
-pDelete :: Key -> [Key] -> Bool
+pDelete :: Key -> [Key] -> Property
 pDelete a = Set.delete a `eq_` S.delete a
 
 ------------------------------------------------------------------------
 -- ** Combine
 
-pUnion :: [Key] -> [Key] -> Bool
+pUnion :: [Key] -> [Key] -> Property
 pUnion xs ys = Set.union (Set.fromList xs) `eq_`
                S.union (S.fromList xs) $ ys
 
 ------------------------------------------------------------------------
 -- ** Transformations
 
-pMap :: [Key] -> Bool
+pMap :: [Key] -> Property
 pMap = Set.map (+ 1) `eq_` S.map (+ 1)
 
 ------------------------------------------------------------------------
 -- ** Folds
 
-pFoldr :: [Int] -> Bool
+pFoldr :: [Int] -> Property
 pFoldr = (List.sort . foldrSet (:) []) `eq`
          (List.sort . S.foldr (:) [])
 
 foldrSet :: (a -> b -> b) -> b -> Set.Set a -> b
 foldrSet = Set.foldr
 
-pFoldl' :: Int -> [Int] -> Bool
+pFoldl' :: Int -> [Int] -> Property
 pFoldl' z0 = foldl'Set (+) z0 `eq` S.foldl' (+) z0
 
 foldl'Set :: (a -> b -> a) -> a -> Set.Set b -> a
@@ -149,13 +149,13 @@ foldl'Set = Set.foldl'
 ------------------------------------------------------------------------
 -- ** Filter
 
-pFilter :: [Key] -> Bool
+pFilter :: [Key] -> Property
 pFilter = Set.filter odd `eq_` S.filter odd
 
 ------------------------------------------------------------------------
 -- ** Conversions
 
-pToList :: [Key] -> Bool
+pToList :: [Key] -> Property
 pToList = Set.toAscList `eq` toAscList
 
 ------------------------------------------------------------------------
@@ -211,22 +211,21 @@ type Model a = Set.Set a
 
 -- | Check that a function operating on a 'HashMap' is equivalent to
 -- one operating on a 'Model'.
-eq :: (Eq a, Hashable a, Ord a, Eq b)
+eq :: (Eq a, Hashable a, Ord a, Show a, Eq b, Show b)
    => (Model a -> b)      -- ^ Function that modifies a 'Model' in the same
                           -- way
    -> (S.HashSet a -> b)  -- ^ Function that modified a 'HashSet'
    -> [a]                 -- ^ Initial content of the 'HashSet' and 'Model'
-   -> Bool                -- ^ True if the functions are equivalent
-eq f g xs = g (S.fromList xs) == f (Set.fromList xs)
+   -> Property
+eq f g xs = f (Set.fromList xs) === g (S.fromList xs)
 
-eq_ :: (Eq a, Hashable a, Ord a)
+eq_ :: (Eq a, Hashable a, Ord a, Show a)
     => (Model a -> Model a)          -- ^ Function that modifies a 'Model'
     -> (S.HashSet a -> S.HashSet a)  -- ^ Function that modified a
                                      -- 'HashSet' in the same way
     -> [a]                           -- ^ Initial content of the 'HashSet'
                                      -- and 'Model'
-    -> Bool                          -- ^ True if the functions are
-                                     -- equivalent
+    -> Property
 eq_ f g = (Set.toAscList . f) `eq` (toAscList . g)
 
 ------------------------------------------------------------------------