Remove dependence on Data.Data.

examples/Div0.hs

@@ -8,14 +8,13 @@ module Div0 where
 import Test.QuickCheck
 import Test.SmartCheck
 import Control.Monad
-import Data.Data
 
 import GHC.Generics
 
 data M = C Int
        | A M M
        | D M M
-  deriving (Read, Show, Data, Typeable, Generic)
+  deriving (Read, Show, Typeable, Generic)
 
 instance SubTypes M 
 

examples/Heap_Program.hs

@@ -18,7 +18,6 @@ import Data.List
   )
 
 import qualified Data.Tree as T
-import Data.Data
 import GHC.Generics
 
 import qualified Test.SmartCheck as SC
@@ -31,19 +30,18 @@ import qualified Test.SmartCheck as SC
 instance Read OrdA where
   readsPrec _ i = [ (OrdA j, str) | (j, str) <- reads i ]
 
-deriving instance Data OrdA
 deriving instance Typeable OrdA
 deriving instance Generic OrdA
 
 heapProgramTest :: IO ()
 heapProgramTest = SC.smartCheck SC.scStdArgs (\h -> property (prop_ToSortedList h))
 
 instance SC.SubTypes OrdA
-instance (SC.SubTypes a, Ord a, Arbitrary a, Data a, Generic a) 
+instance (SC.SubTypes a, Ord a, Arbitrary a, Generic a) 
          => SC.SubTypes (Heap a)
-instance (SC.SubTypes a, Arbitrary a, Data a, Generic a) 
+instance (SC.SubTypes a, Arbitrary a, Generic a) 
          => SC.SubTypes (HeapP a)
-instance (SC.SubTypes a, Ord a, Arbitrary a, Data a, Generic a) 
+instance (SC.SubTypes a, Ord a, Arbitrary a, Generic a) 
          => SC.SubTypes (HeapPP a)
 
 -- instance (Ord a, Arbitrary a, Data a, Show a) => SC.SubTypes (Heap a) where
@@ -85,7 +83,7 @@ instance (Ord a, Arbitrary a) => Arbitrary (Heap a) where
 data Heap a
   = Node a (Heap a) (Heap a)
   | Nil
- deriving ( Eq, Ord, Show, Read, Data, Typeable, Generic )
+ deriving ( Eq, Ord, Show, Read, Typeable, Generic )
 
 empty :: Heap a
 empty = Nil
@@ -147,7 +145,7 @@ data HeapP a
   | SafeRemoveMin (HeapP a)
   | Merge (HeapP a) (HeapP a)
   | FromList [a]
- deriving ( Show, Read, Data, Typeable, Generic )
+ deriving ( Show, Read, Typeable, Generic )
 
 heap :: Ord a => HeapP a -> Heap a
 heap Empty             = empty
@@ -197,7 +195,7 @@ instance Arbitrary a => Arbitrary (HeapP a) where
   -- shrink _                 = []
 
 data HeapPP a = HeapPP (HeapP a) (Heap a)
- deriving ( Show, Read, Data, Typeable, Generic )
+ deriving ( Show, Read, Typeable, Generic )
 
 instance (Ord a, Arbitrary a) => Arbitrary (HeapPP a) where
   arbitrary =

examples/LambdaCalc.hs

@@ -7,7 +7,8 @@ module LambdaCalc where
 
 import Data.List
 import Data.Tree
-import Data.Data
+import Data.Typeable
+
 import Control.Monad
 import GHC.Generics
 
@@ -21,7 +22,7 @@ data Expr
         = Var Sym
         | App Expr Expr
         | Lam Sym Expr
-        deriving (Eq, Read, Show, Data, Typeable, Generic)
+        deriving (Eq, Read, Show, Typeable, Generic)
 
 freeVars :: Expr -> [Sym]
 freeVars (Var s) = [s]
@@ -84,7 +85,7 @@ instance SubTypes Pr
 ---------------------------------------------------------------------------------
 
 data Pr = Pr Expr Expr
-  deriving (Read, Show, Data, Typeable, Generic)
+  deriving (Read, Show, Typeable, Generic)
 
 instance Arbitrary Expr where
   arbitrary = sized mkE

examples/MutualRecData.hs

@@ -8,7 +8,6 @@ import Test.SmartCheck
 import Test.QuickCheck hiding (Result)
 
 import Data.Tree
-import Data.Data
 import Control.Monad.State 
 
 import GHC.Generics
@@ -17,12 +16,12 @@ import GHC.Generics
 
 data M = M N N Int
        | P
-  deriving (Data, Typeable, Show, Eq, Read, Generic)
+  deriving (Typeable, Show, Eq, Read, Generic)
 
 instance SubTypes M
 
 data N = N M Int String
-  deriving (Data, Typeable, Show, Eq, Read, Generic)
+  deriving (Typeable, Show, Eq, Read, Generic)
 
 instance SubTypes N
 

examples/Protocol.hs

@@ -5,7 +5,6 @@
 module Protocol where
 
 import Prelude hiding (last, id)
-import Data.Data
 import Data.List hiding (last)
 import Control.Monad
 import Test.QuickCheck
@@ -15,7 +14,7 @@ import Test.SmartCheck
 
 data Input = Input 
   { header :: Header }
-  deriving (Data, Typeable, Show, Eq, Read)
+  deriving (Typeable, Show, Eq, Read)
 
 data Header = Header 
   { name   :: String
@@ -37,17 +36,17 @@ data Fields = Fields
   , f8   :: Ins
   , f9   :: Ins
   , fn   :: Ins' }
-  deriving (Data, Typeable, Show, Eq, Read)
+  deriving (Typeable, Show, Eq, Read)
 
 data Ins = Strs [String] 
          | Ints [Int]
          | Else [String]
-  deriving (Data, Typeable, Show, Eq, Read)
+  deriving (Typeable, Show, Eq, Read)
 
 data Ins' = Strs' [String] 
          | Ints' [Int]
          | Else' [String]
-  deriving (Data, Typeable, Show, Eq, Read)
+  deriving (Typeable, Show, Eq, Read)
 
 -- Output format
 data Output = Output