Fix (some issues) with the tests

Author: jappeace

tests/Strictness.hs

@@ -14,13 +14,15 @@ import Data.Maybe (fromMaybe, isJust)
 import Control.Arrow (second)
 import Control.Monad (guard)
 import Data.Foldable (foldl')
+import GHC.TypeNats(KnownNat)
 #if !MIN_VERSION_base(4,8,0)
 import Data.Functor ((<$))
 import Data.Foldable (all)
 import Prelude hiding (all)
 #endif
 
-import Data.HashMap.Strict (HashMap)
+
+import Data.HashMap.Strict (HashMapT, HashMap)
 import qualified Data.HashMap.Strict as HM
 
 -- Key type that generates more hash collisions.
@@ -30,9 +32,9 @@ newtype Key = K { unK :: Int }
 instance Hashable Key where
     hashWithSalt salt k = hashWithSalt salt (unK k) `mod` 20
 
-instance (Arbitrary k, Arbitrary v, Eq k, Hashable k) =>
-         Arbitrary (HashMap k v) where
-    arbitrary = HM.fromList `fmap` arbitrary
+instance (Arbitrary k, Arbitrary v, Eq k, Hashable k, KnownNat salt) =>
+         Arbitrary (HashMapT salt k v) where
+    arbitrary = HM.fromList' `fmap` arbitrary
 
 instance Show (Int -> Int) where
     show _ = "<function>"
@@ -100,7 +102,7 @@ pFromListWithKeyStrict f =
 -- could be lazy in the "new" value. fromListWith must, however,
 -- be strict in whatever value is actually inserted into the map.
 -- Getting all these properties specified efficiently seems tricky.
--- Since it's not hard, we verify that the converted HashMap has
+-- Since it's not hard, we verify that the converted HashMapT salt has
 -- no unforced values. Rather than trying to go into detail for the
 -- rest, this test compares the strictness behavior of fromListWith
 -- to that of insertWith. The latter should be easier to specify
@@ -123,7 +125,7 @@ pFromListWithValueResultStrict :: [(Key, Maybe A)]
 pFromListWithValueResultStrict lst comb_lazy calc_good_raw
          = all (all isJust) recovered .&&. (recovered === recover (fmap recover fake_map))
   where
-    recovered :: Maybe (HashMap Key (Maybe A))
+    recovered :: Maybe (HashMapT salt Key (Maybe A))
     recovered = recover (fmap recover real_map)
     -- What we get out of the conversion using insertWith
     fake_map = foldl' (\m (k,v) -> HM.insertWith real_comb k v m) HM.empty real_list
@@ -189,7 +191,7 @@ main = defaultMain tests
 ------------------------------------------------------------------------
 -- * Utilities
 
-keyStrict :: (Key -> HashMap Key Int -> a) -> HashMap Key Int -> Bool
+keyStrict :: (Key -> HashMapT salt Key Int -> a) -> HashMapT salt Key Int -> Bool
 keyStrict f m = isBottom $ f bottom m
 
 const2 :: a -> b -> c -> a