Disable deprecated things (#536)

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.

Author: treeowl

Data/IntMap.hs

@@ -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"
 
@@ -54,43 +60,42 @@
 
 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

Data/IntMap/Internal/DeprecatedDebug.hs

@@ -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

Data/IntMap/Lazy.hs

@@ -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

Data/IntMap/Strict.hs

@@ -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

Data/Map.hs

@@ -3,6 +3,13 @@
 {-# LANGUAGE Safe #-}
 #endif
 
+#ifdef __GLASGOW_HASKELL__
+{-# LANGUAGE DataKinds, FlexibleContexts #-}
+#endif
+#if __GLASGOW_HASKELL__ >= 800
+{-# LANGUAGE MonoLocalBinds #-}
+#endif
+
 #include "containers.h"
 
 -----------------------------------------------------------------------------
@@ -60,72 +67,48 @@
 
 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

Data/Map/Internal/DeprecatedShowTree.hs

@@ -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

Data/Map/Lazy.hs

@@ -262,8 +262,10 @@ module Data.Map.Lazy (
     , maxViewWithKey
 
     -- * Debugging
+#ifdef __GLASGOW_HASKELL__
     , showTree
     , showTreeWith
+#endif
     , valid
     ) where
 

Data/Map/Strict.hs

@@ -279,8 +279,10 @@ module Data.Map.Strict
     , maxViewWithKey
 
     -- * Debugging
+#ifdef __GLASGOW_HASKELL__
     , showTree
     , showTreeWith
+#endif
     , valid
     ) where
 

Data/Map/Strict/Internal.hs

@@ -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)