Disable deprecated things (#536)
authorDavid Feuer <David.Feuer@gmail.com>
Fri, 9 Mar 2018 20:29:20 +0000 (15:29 -0500)
committerGitHub <noreply@github.com>
Fri, 9 Mar 2018 20:29:20 +0000 (15:29 -0500)
Disable all deprecated functions by making them produce type errors when used.
This is an experimental removal approach.  It may or may not really be a good
idea. The benefit is that unlike deprecation it *forces* people to make a
change, and unlike immediate removal it tells them what change to make.

With GHC 8.0 and above, the type errors are pretty. With earlier
versions of GHC, they're gross. With a hypothetical non-GHC compiler, the
functions are just removed.

13 files changed:
Data/IntMap.hs
Data/IntMap/Internal/DeprecatedDebug.hs
Data/IntMap/Lazy.hs
Data/IntMap/Strict.hs
Data/Map.hs
Data/Map/Internal/DeprecatedShowTree.hs
Data/Map/Lazy.hs
Data/Map/Strict.hs
Data/Map/Strict/Internal.hs
Utils/Containers/Internal/TypeError.hs [new file with mode: 0644]
changelog.md
containers.cabal
tests/deprecated-properties.hs [deleted file]

index f73adcb..75855de 100644 (file)
@@ -2,6 +2,12 @@
 #if !defined(TESTING) && defined(__GLASGOW_HASKELL__)
 {-# LANGUAGE Safe #-}
 #endif
+#ifdef __GLASGOW_HASKELL__
+{-# LANGUAGE DataKinds, FlexibleContexts #-}
+#endif
+#if __GLASGOW_HASKELL__ >= 800
+{-# LANGUAGE MonoLocalBinds #-}
+#endif
 
 #include "containers.h"
 
 
 module Data.IntMap
     ( module Data.IntMap.Lazy
+#ifdef __GLASGOW_HASKELL__
+-- For GHC, we disable these, pending removal. For anything else,
+-- we just don't define them at all.
     , insertWith'
     , insertWithKey'
     , fold
     , foldWithKey
+#endif
     ) where
 
-import Prelude ()  -- hide foldr
-import qualified Data.IntMap.Strict as Strict
 import Data.IntMap.Lazy
 
--- | /O(log n)/. Same as 'insertWith', but the result of the combining function
--- is evaluated to WHNF before inserted to the map.
+#ifdef __GLASGOW_HASKELL__
+import Utils.Containers.Internal.TypeError
 
-{-# DEPRECATED insertWith' "As of version 0.5, replaced by 'Data.IntMap.Strict.insertWith'." #-}
-insertWith' :: (a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
-insertWith' = Strict.insertWith
+-- | This function is being removed and is no longer usable.
+-- Use 'Data.IntMap.Strict.insertWith'
+insertWith' :: Whoops "Data.IntMap.insertWith' is gone. Use Data.IntMap.Strict.insertWith."
+            => (a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
+insertWith' _ _ _ _ = undefined
 
--- | /O(log n)/. Same as 'insertWithKey', but the result of the combining
--- function is evaluated to WHNF before inserted to the map.
+-- | This function is being removed and is no longer usable.
+-- Use 'Data.IntMap.Strict.insertWithKey'.
+insertWithKey' :: Whoops "Data.IntMap.insertWithKey' is gone. Use Data.IntMap.Strict.insertWithKey."
+               => (Key -> a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
+insertWithKey' _ _ _ _ = undefined
 
-{-# DEPRECATED insertWithKey' "As of version 0.5, replaced by 'Data.IntMap.Strict.insertWithKey'." #-}
-insertWithKey' :: (Key -> a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
-insertWithKey' = Strict.insertWithKey
+-- | This function is being removed and is no longer usable.
+-- Use 'Data.IntMap.Lazy.foldr'.
+fold :: Whoops "Data.IntMap.fold' is gone. Use Data.IntMap.foldr or Prelude.foldr."
+     => (a -> b -> b) -> b -> IntMap a -> b
+fold _ _ _ = undefined
 
--- | /O(n)/. Fold the values in the map using the given
--- right-associative binary operator. This function is an equivalent
--- of 'foldr' and is present for compatibility only.
-{-# DEPRECATED fold "As of version 0.5, replaced by 'foldr'." #-}
-fold :: (a -> b -> b) -> b -> IntMap a -> b
-fold = foldr
-{-# INLINE fold #-}
-
--- | /O(n)/. Fold the keys and values in the map using the given
--- right-associative binary operator. This function is an equivalent
--- of 'foldrWithKey' and is present for compatibility only.
-
-{-# DEPRECATED foldWithKey "As of version 0.5, replaced by 'foldrWithKey'." #-}
-foldWithKey :: (Key -> a -> b -> b) -> b -> IntMap a -> b
-foldWithKey = foldrWithKey
-{-# INLINE foldWithKey #-}
+-- | This function is being removed and is no longer usable.
+-- Use 'foldrWithKey'.
+foldWithKey :: Whoops "Data.IntMap.foldWithKey is gone. Use foldrWithKey."
+            => (Key -> a -> b -> b) -> b -> IntMap a -> b
+foldWithKey _ _ _ = undefined
+#endif
index 2894999..708a38a 100644 (file)
@@ -1,20 +1,17 @@
+{-# LANGUAGE CPP, FlexibleContexts, DataKinds, MonoLocalBinds #-}
+
 module Data.IntMap.Internal.DeprecatedDebug where
-import qualified Data.IntMap.Internal as IM
 import Data.IntMap.Internal (IntMap)
 
-{-# DEPRECATED showTree, showTreeWith
-    "These debugging functions will be removed from this module. They are available from Data.IntMap.Internal.Debug."
-    #-}
+import Utils.Containers.Internal.TypeError
+
 
--- | /O(n)/. Show the tree that implements the map. The tree is shown
--- in a compressed, hanging format.
-showTree :: Show a => IntMap a -> String
-showTree = IM.showTree
+-- | 'showTree' has moved to 'Data.IntMap.Internal.Debug.showTree'
+showTree :: Whoops "Data.IntMap.showTree has moved to Data.IntMap.Internal.Debug.showTree"
+         => IntMap a -> String
+showTree _ = undefined
 
-{- | /O(n)/. The expression (@'showTreeWith' hang wide map@) shows
- the tree that implements the map. If @hang@ is
- 'True', a /hanging/ tree is shown otherwise a rotated tree is shown. If
- @wide@ is 'True', an extra wide version is shown.
--}
-showTreeWith :: Show a => Bool -> Bool -> IntMap a -> String
-showTreeWith = IM.showTreeWith
+-- | 'showTreeWith' has moved to 'Data.IntMap.Internal.Debug.showTreeWith'
+showTreeWith :: Whoops "Data.IntMap.showTreeWith has moved to Data.IntMap.Internal.Debug.showTreeWith"
+             => Bool -> Bool -> IntMap a -> String
+showTreeWith _ _ _ = undefined
index c878652..57b26ee 100644 (file)
@@ -223,10 +223,14 @@ module Data.IntMap.Lazy (
     , minViewWithKey
     , maxViewWithKey
 
+#ifdef __GLASGOW_HASKELL__
     -- * Debugging
     , showTree
     , showTreeWith
+#endif
     ) where
 
 import Data.IntMap.Internal as IM hiding (showTree, showTreeWith)
+#ifdef __GLASGOW_HASKELL__
 import Data.IntMap.Internal.DeprecatedDebug
+#endif
index 8f68a9e..e7191c6 100644 (file)
@@ -242,9 +242,11 @@ module Data.IntMap.Strict (
     , minViewWithKey
     , maxViewWithKey
 
+#ifdef __GLASGOW_HASKELL__
     -- * Debugging
     , showTree
     , showTreeWith
+#endif
     ) where
 
 import Prelude hiding (lookup,map,filter,foldr,foldl,null)
@@ -331,7 +333,9 @@ import Data.IntMap.Internal
   , unions
   , withoutKeys
   )
+#ifdef __GLASGOW_HASKELL__
 import Data.IntMap.Internal.DeprecatedDebug (showTree, showTreeWith)
+#endif
 import qualified Data.IntSet.Internal as IntSet
 import Utils.Containers.Internal.BitUtil
 import Utils.Containers.Internal.StrictPair
index d80804b..47385aa 100644 (file)
@@ -3,6 +3,13 @@
 {-# LANGUAGE Safe #-}
 #endif
 
+#ifdef __GLASGOW_HASKELL__
+{-# LANGUAGE DataKinds, FlexibleContexts #-}
+#endif
+#if __GLASGOW_HASKELL__ >= 800
+{-# LANGUAGE MonoLocalBinds #-}
+#endif
+
 #include "containers.h"
 
 -----------------------------------------------------------------------------
 
 module Data.Map
     ( module Data.Map.Lazy
+#ifdef __GLASGOW_HASKELL__
     , insertWith'
     , insertWithKey'
     , insertLookupWithKey'
     , fold
     , foldWithKey
+#endif
     ) where
 
-import Prelude hiding (foldr)
 import Data.Map.Lazy
-import qualified Data.Map.Strict as Strict
 
--- | /O(log n)/. Same as 'insertWith', but the value being inserted to the map is
--- evaluated to WHNF beforehand.
---
--- For example, to update a counter:
---
--- > insertWith' (+) k 1 m
---
-{-# DEPRECATED insertWith' "As of version 0.5, replaced by 'Data.Map.Strict.insertWith'." #-}
-insertWith' :: Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
-insertWith' = Strict.insertWith
-#if __GLASGOW_HASKELL__
-{-# INLINABLE insertWith' #-}
-#else
-{-# INLINE insertWith' #-}
-#endif
+#ifdef __GLASGOW_HASKELL__
+import Utils.Containers.Internal.TypeError
 
--- | /O(log n)/. Same as 'insertWithKey', but the value being inserted to the map is
--- evaluated to WHNF beforehand.
-{-# DEPRECATED insertWithKey' "As of version 0.5, replaced by 'Data.Map.Strict.insertWithKey'." #-}
-insertWithKey' :: Ord k => (k -> a -> a -> a) -> k -> a -> Map k a -> Map k a
--- We do not reuse Data.Map.Strict.insertWithKey, because it is stricter -- it
--- forces evaluation of the given value.
-insertWithKey' = Strict.insertWithKey
-#if __GLASGOW_HASKELL__
-{-# INLINABLE insertWithKey' #-}
-#else
-{-# INLINE insertWithKey' #-}
-#endif
+-- | This function is being removed and is no longer usable.
+-- Use 'Data.Map.Strict.insertWith'.
+insertWith' :: Whoops "Data.Map.insertWith' is gone. Use Data.Map.Strict.insertWith."
+            => (a -> a -> a) -> k -> a -> Map k a -> Map k a
+insertWith' _ _ _ _ = undefined
 
--- | /O(log n)/. Same as 'insertLookupWithKey', but the value being inserted to
--- the map is evaluated to WHNF beforehand.
-{-# DEPRECATED insertLookupWithKey' "As of version 0.5, replaced by 'Data.Map.Strict.insertLookupWithKey'." #-}
-insertLookupWithKey' :: Ord k => (k -> a -> a -> a) -> k -> a -> Map k a
+-- | This function is being removed and is no longer usable.
+-- Use 'Data.Map.Strict.insertWithKey'.
+insertWithKey' :: Whoops "Data.Map.insertWithKey' is gone. Use Data.Map.Strict.insertWithKey."
+               => (k -> a -> a -> a) -> k -> a -> Map k a -> Map k a
+insertWithKey' _ _ _ _ = undefined
+
+-- | This function is being removed and is no longer usable.
+-- Use 'Data.Map.Strict.insertLookupWithKey'.
+insertLookupWithKey' :: Whoops "Data.Map.insertLookupWithKey' is gone. Use Data.Map.Strict.insertLookupWithKey."
+                     => (k -> a -> a -> a) -> k -> a -> Map k a
                      -> (Maybe a, Map k a)
--- We do not reuse Data.Map.Strict.insertLookupWithKey, because it is stricter -- it
--- forces evaluation of the given value.
-insertLookupWithKey' = Strict.insertLookupWithKey
-#if __GLASGOW_HASKELL__
-{-# INLINABLE insertLookupWithKey' #-}
-#else
-{-# INLINE insertLookupWithKey' #-}
-#endif
+insertLookupWithKey' _ _ _ _ = undefined
 
--- | /O(n)/. Fold the values in the map using the given right-associative
--- binary operator. This function is an equivalent of 'foldr' and is present
--- for compatibility only.
-{-# DEPRECATED fold "As of version 0.5, replaced by 'foldr'." #-}
-fold :: (a -> b -> b) -> b -> Map k a -> b
-fold = foldr
-{-# INLINE fold #-}
+-- | This function is being removed and is no longer usable.
+-- Use 'foldr'.
+fold :: Whoops "Data.Map.fold is gone. Use foldr."
+     => (a -> b -> b) -> b -> Map k a -> b
+fold _ _ _ = undefined
 
--- | /O(n)/. Fold the keys and values in the map using the given right-associative
--- binary operator. This function is an equivalent of 'foldrWithKey' and is present
--- for compatibility only.
-{-# DEPRECATED foldWithKey "As of version 0.4, replaced by 'foldrWithKey'." #-}
-foldWithKey :: (k -> a -> b -> b) -> b -> Map k a -> b
-foldWithKey = foldrWithKey
-{-# INLINE foldWithKey #-}
+-- | This function is being removed and is no longer usable.
+-- Use 'foldrWithKey'.
+foldWithKey :: Whoops "Data.Map.foldWithKey is gone. Use foldrWithKey."
+            => (k -> a -> b -> b) -> b -> Map k a -> b
+foldWithKey _ _ _ = undefined
+#endif
index 9f7f503..0d296d0 100644 (file)
@@ -1,56 +1,29 @@
-{-# LANGUAGE CPP #-}
+{-# LANGUAGE CPP, FlexibleContexts, DataKinds #-}
+#if __GLASGOW_HASKELL__ >= 800
+{-# LANGUAGE MonoLocalBinds #-}
+#endif
+#if __GLASGOW_HASKELL__ < 710
+-- Why do we need this? Guess it doesn't matter; this is all
+-- going away soon.
+{-# LANGUAGE Trustworthy #-}
+#endif
 
 #include "containers.h"
 
--- | This module simply holds deprecated copies of functions from
+-- | This module simply holds disabled copies of functions from
 -- Data.Map.Internal.Debug.
 module Data.Map.Internal.DeprecatedShowTree where
 
-import qualified Data.Map.Internal.Debug as Debug
 import Data.Map.Internal (Map)
+import Utils.Containers.Internal.TypeError
 
--- | /O(n)/. Show the tree that implements the map. The tree is shown
--- in a compressed, hanging format. See 'showTreeWith'.
-{-# DEPRECATED showTree "'showTree' is now in \"Data.Map.Internal.Debug\"" #-}
-showTree :: (Show k,Show a) => Map k a -> String
-showTree = Debug.showTree
+-- | This function has moved to 'Data.Map.Internal.Debug.showTree'.
+showTree :: Whoops "showTree has moved to Data.Map.Internal.Debug.showTree."
+         => Map k a -> String
+showTree _ = undefined
 
-{- | /O(n)/. The expression (@'showTreeWith' showelem hang wide map@) shows
- the tree that implements the map. Elements are shown using the @showElem@ function. If @hang@ is
- 'True', a /hanging/ tree is shown otherwise a rotated tree is shown. If
- @wide@ is 'True', an extra wide version is shown.
-
->  Map> let t = fromDistinctAscList [(x,()) | x <- [1..5]]
->  Map> putStrLn $ showTreeWith (\k x -> show (k,x)) True False t
->  (4,())
->  +--(2,())
->  |  +--(1,())
->  |  +--(3,())
->  +--(5,())
->
->  Map> putStrLn $ showTreeWith (\k x -> show (k,x)) True True t
->  (4,())
->  |
->  +--(2,())
->  |  |
->  |  +--(1,())
->  |  |
->  |  +--(3,())
->  |
->  +--(5,())
->
->  Map> putStrLn $ showTreeWith (\k x -> show (k,x)) False True t
->  +--(5,())
->  |
->  (4,())
->  |
->  |  +--(3,())
->  |  |
->  +--(2,())
->     |
->     +--(1,())
-
--}
-{-# DEPRECATED showTreeWith "'showTreeWith' is now in \"Data.Map.Internal.Debug\"" #-}
-showTreeWith :: (k -> a -> String) -> Bool -> Bool -> Map k a -> String
-showTreeWith = Debug.showTreeWith
+-- | This function has moved to 'Data.Map.Internal.Debug.showTreeWith'.
+showTreeWith ::
+      Whoops "showTreeWith has moved to Data.Map.Internal.Debug.showTreeWith."
+   => (k -> a -> String) -> Bool -> Bool -> Map k a -> String
+showTreeWith _ _ _ _ = undefined
index e951003..64a0bc6 100644 (file)
@@ -262,8 +262,10 @@ module Data.Map.Lazy (
     , maxViewWithKey
 
     -- * Debugging
+#ifdef __GLASGOW_HASKELL__
     , showTree
     , showTreeWith
+#endif
     , valid
     ) where
 
index 3d347ac..206985f 100644 (file)
@@ -279,8 +279,10 @@ module Data.Map.Strict
     , maxViewWithKey
 
     -- * Debugging
+#ifdef __GLASGOW_HASKELL__
     , showTree
     , showTreeWith
+#endif
     , valid
     ) where
 
index 3639adb..3905e1e 100644 (file)
@@ -292,8 +292,10 @@ module Data.Map.Strict.Internal
     , maxViewWithKey
 
     -- * Debugging
+#if defined(__GLASGOW_HASKELL__)
     , showTree
     , showTreeWith
+#endif
     , valid
     ) where
 
@@ -397,7 +399,9 @@ import Data.Map.Internal
   , unions
   , withoutKeys )
 
+#if defined(__GLASGOW_HASKELL__)
 import Data.Map.Internal.DeprecatedShowTree (showTree, showTreeWith)
+#endif
 import Data.Map.Internal.Debug (valid)
 
 import Control.Applicative (Const (..), liftA3)
diff --git a/Utils/Containers/Internal/TypeError.hs b/Utils/Containers/Internal/TypeError.hs
new file mode 100644 (file)
index 0000000..972918b
--- /dev/null
@@ -0,0 +1,52 @@
+{-# LANGUAGE DataKinds, FlexibleInstances, FlexibleContexts, UndecidableInstances,
+     KindSignatures, TypeFamilies, CPP #-}
+
+#if !defined(TESTING)
+# if __GLASGOW_HASKELL__ >= 710
+{-# LANGUAGE Safe #-}
+# else
+{-# LANGUAGE Trustworthy #-}
+#endif
+#endif
+
+-- | Unsatisfiable constraints for functions being removed.
+
+module Utils.Containers.Internal.TypeError where
+import GHC.TypeLits
+
+-- | The constraint @Whoops s@ is unsatisfiable for every 'Symbol' @s@.
+-- Under GHC 8.0 and above, trying to use a function with a @Whoops s@
+-- constraint will lead to a pretty type error explaining how to fix
+-- the problem. Under earlier GHC versions, it will produce an extremely
+-- ugly type error within which the desired message is buried.
+--
+-- ==== Example
+--
+-- @
+-- oldFunction :: Whoops "oldFunction is gone now. Use newFunction."
+--             => Int -> IntMap a -> IntMap a
+-- @
+class Whoops (a :: Symbol)
+
+#if __GLASGOW_HASKELL__ >= 800
+instance TypeError ('Text a) => Whoops a
+#endif
+
+-- Why don't we just use
+--
+-- type Whoops a = TypeError ('Text a) ?
+--
+-- When GHC sees the type signature of oldFunction, it will see that it
+-- has an unsatisfiable constraint and reject it out of hand.
+--
+-- It seems possible to hack around that with a type family:
+--
+-- type family Whoops a where
+--   Whoops a = TypeError ('Text a)
+--
+-- but I don't really trust that to work reliably. What we actually
+-- do is pretty much guaranteed to work. Despite the fact that there
+-- is a totally polymorphic instance in scope, GHC will refrain from
+-- reducing the constraint because it knows someone could (theoretically)
+-- define an overlapping instance of Whoops. It doesn't commit to
+-- the polymorphic one until it has to, at the call site.
index 8a72e34..ddbee07 100644 (file)
@@ -7,6 +7,22 @@
 * Add `Data.Containers.ListUtils` offering `nub`-like functions. (Thanks to
   Gershom Bazerman for starting the process of writing these.)
 
+### Death of deprecated functions
+
+The following functions have been disabled. As an experiment
+in function removal technology, the functions are still temporarily present,
+but any attempts to use them will result in type errors advising on
+replacement.
+
+* `Data.IntMap`: `insertWith'`, `insertWithKey'`, `fold`, and `foldWithKey`.
+
+* `Data.Map`: `insertWith'`, `insertWithKey'`, `insertLookupWithKey'`,
+   `fold`, and `foldWithKey`.
+
+The same has been done for the deprecated exports of `showTree` and
+`showTreeWith`. These function remain available in the internal `Debug`
+modules.
+
 ### Changes to existing functions
 
 * Generalize the types of `unions` and `unionsWith`. (Thanks, jwaldmann.)
index b1cac88..bc41138 100644 (file)
@@ -83,6 +83,9 @@ Library
         Utils.Containers.Internal.StrictMaybe
         Utils.Containers.Internal.PtrEquality
         Utils.Containers.Internal.Coercions
+    if impl(ghc)
+      other-modules:
+        Utils.Containers.Internal.TypeError
         Data.Map.Internal.DeprecatedShowTree
         Data.IntMap.Internal.DeprecatedDebug
 
@@ -207,6 +210,7 @@ benchmark lookupge-intmap
       LookupGE_IntMap
       Utils.Containers.Internal.BitUtil
       Utils.Containers.Internal.StrictPair
+      Utils.Containers.Internal.TypeError
   ghc-options: -O2
   cpp-options: -DTESTING
   other-modules:
@@ -378,6 +382,7 @@ Test-suite intmap-lazy-properties
         IntMapValidity
         Utils.Containers.Internal.BitUtil
         Utils.Containers.Internal.StrictPair
+        Utils.Containers.Internal.TypeError
     type: exitcode-stdio-1.0
     cpp-options: -DTESTING
 
@@ -406,6 +411,7 @@ Test-suite intmap-strict-properties
         IntMapValidity
         Utils.Containers.Internal.BitUtil
         Utils.Containers.Internal.StrictPair
+        Utils.Containers.Internal.TypeError
     type: exitcode-stdio-1.0
     cpp-options: -DTESTING -DSTRICT
 
@@ -448,42 +454,6 @@ Test-suite intset-properties
         test-framework-hunit,
         test-framework-quickcheck2
 
-Test-suite deprecated-properties
-    hs-source-dirs: tests, .
-    main-is: deprecated-properties.hs
-    other-modules:
-        Data.IntMap
-        Data.IntMap.Internal
-        Data.IntMap.Internal.DeprecatedDebug
-        Data.IntMap.Lazy
-        Data.IntMap.Strict
-        Data.IntSet.Internal
-        Data.Map
-        Data.Map.Internal
-        Data.Map.Internal.Debug
-        Data.Map.Internal.DeprecatedShowTree
-        Data.Map.Lazy
-        Data.Map.Strict
-        Data.Map.Strict.Internal
-        Data.Set.Internal
-        Utils.Containers.Internal.BitQueue
-        Utils.Containers.Internal.BitUtil
-        Utils.Containers.Internal.PtrEquality
-        Utils.Containers.Internal.StrictMaybe
-        Utils.Containers.Internal.StrictPair
-    type: exitcode-stdio-1.0
-    cpp-options: -DTESTING
-
-    build-depends: base >= 4.6 && < 5, array >= 0.4.0.0, deepseq >= 1.2 && < 1.5, ghc-prim
-    ghc-options: -O2
-    other-extensions: CPP, BangPatterns
-    include-dirs: include
-
-    build-depends:
-        QuickCheck >= 2.7.1,
-        test-framework,
-        test-framework-quickcheck2
-
 Test-suite seq-properties
     hs-source-dirs: tests, .
     main-is: seq-properties.hs
@@ -565,6 +535,7 @@ test-suite intmap-strictness-properties
       Data.IntSet.Internal
       Utils.Containers.Internal.BitUtil
       Utils.Containers.Internal.StrictPair
+      Utils.Containers.Internal.TypeError
   type: exitcode-stdio-1.0
   other-extensions: CPP, BangPatterns
 
diff --git a/tests/deprecated-properties.hs b/tests/deprecated-properties.hs
deleted file mode 100644 (file)
index 5478520..0000000
+++ /dev/null
@@ -1,108 +0,0 @@
-{-# LANGUAGE CPP #-}
-{-# OPTIONS_GHC -fno-warn-warnings-deprecations #-}
-
--- This module tests the deprecated properties of Data.Map and Data.IntMap,
--- because these cannot be tested in either map-properties or
--- intmap-properties, as these modules are designed to work with the .Lazy and
--- .Strict modules.
-
-import qualified Data.Map as M
-import qualified Data.Map.Strict as SM
-import qualified Data.IntMap as IM
-import qualified Data.IntMap.Strict as SIM
-
-import Test.Framework
-import Test.Framework.Providers.QuickCheck2
-import Test.QuickCheck.Function (Fun(..), apply)
-
-default (Int)
-
-main :: IO ()
-main = defaultMain
-         [ testProperty "Data.Map.insertWith' as Strict.insertWith" prop_mapInsertWith'Strict
-         , testProperty "Data.Map.insertWith' undefined value" prop_mapInsertWith'Undefined
-         , testProperty "Data.Map.insertWithKey' as Strict.insertWithKey" prop_mapInsertWithKey'Strict
-         , testProperty "Data.Map.insertWithKey' undefined value" prop_mapInsertWithKey'Undefined
-         , testProperty "Data.Map.insertLookupWithKey' as Strict.insertLookupWithKey" prop_mapInsertLookupWithKey'Strict
-         , testProperty "Data.Map.insertLookupWithKey' undefined value" prop_mapInsertLookupWithKey'Undefined
-         , testProperty "Data.IntMap.insertWith' as Strict.insertWith" prop_intmapInsertWith'Strict
-         , testProperty "Data.IntMap.insertWith' undefined value" prop_intmapInsertWith'Undefined
-         , testProperty "Data.IntMap.insertWithKey' as Strict.insertWithKey" prop_intmapInsertWithKey'Strict
-         , testProperty "Data.IntMap.insertWithKey' undefined value" prop_intmapInsertWithKey'Undefined
-         ]
-
-
----------- Map properties ----------
-apply2 :: Fun (a, b) c -> a -> b -> c
-apply2 f a b = apply f (a, b)
-
-apply3 :: Fun (a, b, c) d -> a -> b -> c -> d
-apply3 f a b c = apply f (a, b, c)
-
-prop_mapInsertWith'Strict :: [(Int, Int)] -> Fun (Int, Int) Int -> [(Int, Int)] -> Bool
-prop_mapInsertWith'Strict xs f kxxs =
-  let m = M.fromList xs
-      insertList ins = foldr (\(kx, x) -> ins (apply2 f) kx x) m kxxs
-  in insertList M.insertWith' == insertList SM.insertWith
-
-prop_mapInsertWith'Undefined :: [(Int, Int)] -> Bool
-prop_mapInsertWith'Undefined xs =
-  let m = M.fromList xs
-      f _ x = x * 33
-      insertList ins = foldr (\(kx, _) -> ins f kx undefined) m xs
-  in insertList M.insertWith' == insertList M.insertWith
-
-prop_mapInsertWithKey'Strict :: [(Int, Int)] -> Fun (Int, Int, Int) Int -> [(Int, Int)] -> Bool
-prop_mapInsertWithKey'Strict xs f kxxs =
-  let m = M.fromList xs
-      insertList ins = foldr (\(kx, x) -> ins (apply3 f) kx x) m kxxs
-  in insertList M.insertWithKey' == insertList SM.insertWithKey
-
-prop_mapInsertWithKey'Undefined :: [(Int, Int)] -> Bool
-prop_mapInsertWithKey'Undefined xs =
-  let m = M.fromList xs
-      f k _ x = (k + x) * 33
-      insertList ins = foldr (\(kx, _) -> ins f kx undefined) m xs
-  in insertList M.insertWithKey' == insertList M.insertWithKey
-
-prop_mapInsertLookupWithKey'Strict :: [(Int, Int)] -> Fun (Int, Int, Int) Int -> [(Int, Int)] -> Bool
-prop_mapInsertLookupWithKey'Strict xs f kxxs =
-  let m = M.fromList xs
-      insertLookupList insLkp = scanr (\(kx, x) (_, mp) -> insLkp (apply3 f) kx x mp) (Nothing, m) kxxs
-  in insertLookupList M.insertLookupWithKey' == insertLookupList SM.insertLookupWithKey
-
-prop_mapInsertLookupWithKey'Undefined :: [(Int, Int)] -> Bool
-prop_mapInsertLookupWithKey'Undefined xs =
-  let m = M.fromList xs
-      f k _ x = (k + x) * 33
-      insertLookupList insLkp = scanr (\(kx, _) (_, mp) -> insLkp f kx undefined mp) (Nothing, m) xs
-  in insertLookupList M.insertLookupWithKey' == insertLookupList M.insertLookupWithKey
-
-
----------- IntMap properties ----------
-
-prop_intmapInsertWith'Strict :: [(Int, Int)] -> Fun (Int, Int) Int -> [(Int, Int)] -> Bool
-prop_intmapInsertWith'Strict xs f kxxs =
-  let m = IM.fromList xs
-      insertList ins = foldr (\(kx, x) -> ins (apply2 f) kx x) m kxxs
-  in insertList IM.insertWith' == insertList SIM.insertWith
-
-prop_intmapInsertWith'Undefined :: [(Int, Int)] -> Bool
-prop_intmapInsertWith'Undefined xs =
-  let m = IM.fromList xs
-      f _ x = x * 33
-      insertList ins = foldr (\(kx, _) -> ins f kx undefined) m xs
-  in insertList IM.insertWith' == insertList IM.insertWith
-
-prop_intmapInsertWithKey'Strict :: [(Int, Int)] -> Fun (Int, Int, Int) Int -> [(Int, Int)] -> Bool
-prop_intmapInsertWithKey'Strict xs f kxxs =
-  let m = IM.fromList xs
-      insertList ins = foldr (\(kx, x) -> ins (apply3 f) kx x) m kxxs
-  in insertList IM.insertWithKey' == insertList SIM.insertWithKey
-
-prop_intmapInsertWithKey'Undefined :: [(Int, Int)] -> Bool
-prop_intmapInsertWithKey'Undefined xs =
-  let m = IM.fromList xs
-      f k _ x = (k + x) * 33
-      insertList ins = foldr (\(kx, _) -> ins f kx undefined) m xs
-  in insertList IM.insertWithKey' == insertList IM.insertWithKey