Add and use applyFun3.

This function is only available in new versions of QuickCheck which we may not
have for old GHC versions. This inlines the function here for portability.

Skipping CI since there's still a known failure (pInsertWithKeyValueStrict).

[ci skip]

Author: m-renaud

tests/HashMapProperties.hs

@@ -18,7 +18,7 @@ import qualified Data.HashMap.Lazy as HM
 #endif
 import qualified Data.Map as M
 import Test.QuickCheck (Arbitrary, CoArbitrary, Property, (==>), (===))
-import Test.QuickCheck.Function (Fun, Function(function), apply, functionMap)
+import Test.QuickCheck.Function (Fun(Fun), Function(function), apply, functionMap)
 import Test.Framework (Test, defaultMain, testGroup)
 import Test.Framework.Providers.QuickCheck2 (testProperty)
 
@@ -156,9 +156,14 @@ pInsertWith f k =
   M.insertWith f' k 1 `eq_` HM.insertWith f' k 1
   where f' = curry . apply $ f
 
-pInsertWithKey :: Fun (Key, (Int, Int)) Int -> Key -> [(Key, Int)] -> Bool
+-- | Extracts the value of a ternary function.
+-- Copied from Test.QuickCheck.Function.applyFun3
+applyFun3 :: Fun (a, b, c) d -> (a -> b -> c -> d)
+applyFun3 (Fun _ f) a b c = f (a, b, c)
+
+pInsertWithKey :: Fun (Key, Int, Int) Int -> Key -> [(Key, Int)] -> Bool
 pInsertWithKey f k = M.insertWithKey f' k 1 `eq_` HM.insertWithKey f' k 1
-  where f' = curry . curry (apply f)
+  where f' = applyFun3 f
 
 pAdjust :: Key -> [(Key, Int)] -> Bool
 pAdjust k = M.adjust succ k `eq_` HM.adjust succ k

tests/Strictness.hs

@@ -84,15 +84,20 @@ pInsertWithValueStrict f k v m
     | HM.member k m = isBottom $ HM.insertWith (const2 bottom) k v m
     | otherwise     = isBottom $ HM.insertWith (curry . apply $ f) k bottom m
 
-pInsertWithKeyKeyStrict :: Fun (Key, (Int, Int)) Int -> Int -> HashMap Key Int -> Bool
+-- | Extracts the value of a ternary function.
+-- Copied from Test.QuickCheck.Function.applyFun3
+applyFun3 :: Fun (a, b, c) d -> (a -> b -> c -> d)
+applyFun3 (Fun _ f) a b c = f (a, b, c)
+
+pInsertWithKeyKeyStrict :: Fun (Key, Int, Int) Int -> Int -> HashMap Key Int -> Bool
 pInsertWithKeyKeyStrict f v m =
-  isBottom $ HM.insertWithKey (curry . curry (apply f)) bottom v m
+  isBottom $ HM.insertWithKey (applyFun3 f) bottom v m
 
-pInsertWithKeyValueStrict :: Fun (Key, (Int, Int)) Int -> Key -> Int -> HashMap Key Int
+pInsertWithKeyValueStrict :: Fun (Key, Int, Int) Int -> Key -> Int -> HashMap Key Int
                           -> Bool
 pInsertWithKeyValueStrict f k v m
-    | HM.member k m = isBottom $ HM.insertWithKey (const2 bottom) k v m
-    | otherwise     = isBottom $ HM.insertWithKey (curry . curry (apply f)) k bottom m
+    | HM.member k m = isBottom $ HM.insertWithKey (const3 bottom) k v m
+    | otherwise     = isBottom $ HM.insertWithKey (applyFun3 f) k bottom m
 
 pFromListKeyStrict :: Bool
 pFromListKeyStrict = isBottom $ HM.fromList [(undefined :: Key, 1 :: Int)]
@@ -206,3 +211,6 @@ keyStrict f m = isBottom $ f bottom m
 
 const2 :: a -> b -> c -> a
 const2 x _ _ = x
+
+const3 :: a -> b -> c -> d -> a
+const3 x _ _ _ = x