Eliminate Equality.hs-boot and Proxy.hs-boot by moving instances
authorRichard Eisenberg <eir@cis.upenn.edu>
Thu, 25 Jul 2013 10:25:38 +0000 (11:25 +0100)
committerRichard Eisenberg <eir@cis.upenn.edu>
Thu, 25 Jul 2013 10:25:38 +0000 (11:25 +0100)
12 files changed:
libraries/base/Control/Applicative.hs
libraries/base/Control/Category.hs
libraries/base/Data/Data.hs
libraries/base/Data/Foldable.hs
libraries/base/Data/Proxy.hs
libraries/base/Data/Proxy.hs-boot [deleted file]
libraries/base/Data/Traversable.hs
libraries/base/Data/Type/Equality.hs
libraries/base/Data/Type/Equality.hs-boot [deleted file]
libraries/base/Data/Typeable.hs
libraries/base/Data/Typeable/Internal.hs
libraries/base/GHC/Generics.hs

index 58738b9..9f6b514 100644 (file)
@@ -54,6 +54,7 @@ import Control.Monad.ST.Safe (ST)
 import qualified Control.Monad.ST.Lazy.Safe as Lazy (ST)
 import Data.Functor ((<$>), (<$))
 import Data.Monoid (Monoid(..))
+import Data.Proxy
 
 import Text.ParserCombinators.ReadP (ReadP)
 import Text.ParserCombinators.ReadPrec (ReadPrec)
@@ -277,6 +278,12 @@ instance Applicative ZipList where
     pure x = ZipList (repeat x)
     ZipList fs <*> ZipList xs = ZipList (zipWith id fs xs)
 
+instance Applicative Proxy where
+    pure _ = Proxy
+    {-# INLINE pure #-}
+    _ <*> _ = Proxy
+    {-# INLINE (<*>) #-}
+
 -- extra functions
 
 -- | A variant of '<*>' with the arguments reversed.
index 67ea60b..9eaf38f 100644 (file)
@@ -2,7 +2,7 @@
 {-# LANGUAGE CPP #-}
 
 #if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 706
-{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE PolyKinds, GADTs #-}
 #endif
 
 -----------------------------------------------------------------------------
@@ -21,6 +21,10 @@ module Control.Category where
 
 import qualified Prelude
 
+#ifdef __GLASGOW_HASKELL__
+import Data.Type.Equality
+#endif
+
 infixr 9 .
 infixr 1 >>>, <<<
 
@@ -46,6 +50,12 @@ instance Category (->) where
     id = Prelude.id
     (.) = (Prelude..)
 
+#ifdef __GLASGOW_HASKELL__
+instance Category (:=:) where
+  id          = Refl
+  Refl . Refl = Refl
+#endif
+
 -- | Right-to-left composition
 (<<<) :: Category cat => cat b c -> cat a b -> cat a c
 (<<<) = (.)
index 5d22b3b..29760b2 100644 (file)
@@ -1,5 +1,7 @@
-{-# LANGUAGE Trustworthy #-}
+{-# LANGUAGE Trustworthy, FlexibleInstances #-}
 {-# LANGUAGE CPP, RankNTypes, ScopedTypeVariables, PolyKinds #-}
+{-# LANGUAGE StandaloneDeriving, DeriveDataTypeable, TypeOperators,
+             GADTs #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -129,6 +131,7 @@ import Hugs.Prelude( Ratio(..) )
 import Foreign.Ptr
 import Foreign.ForeignPtr
 import Data.Array
+import Data.Proxy
 #endif
 
 #include "Typeable.h"
@@ -1299,3 +1302,39 @@ instance (Typeable a, Data a, Data b, Ix a) => Data (Array a b)
   gunfold _ _  = error "Data.Data.gunfold(Array)"
   dataTypeOf _ = mkNoRepType "Data.Array.Array"
   dataCast2 x  = gcast2 x
+
+----------------------------------------------------------------------------
+-- Data instance for Proxy
+
+proxyConstr :: Constr
+proxyConstr = mkConstr proxyDataType "Proxy" [] Prefix
+
+proxyDataType :: DataType
+proxyDataType = mkDataType "Data.Proxy.Proxy" [proxyConstr]
+
+instance (Data t) => Data (Proxy t) where
+  gfoldl _ z Proxy  = z Proxy
+  toConstr Proxy  = proxyConstr
+  gunfold _ z c = case constrIndex c of
+                    1 -> z Proxy
+                    _ -> error "Data.Data.gunfold(Proxy)"
+  dataTypeOf _ = proxyDataType
+  dataCast1 f  = gcast1 f
+
+-----------------------------------------------------------------------
+-- instance for (:=:)
+
+reflConstr :: Constr
+reflConstr = mkConstr equalityDataType "Refl" [] Prefix
+
+equalityDataType :: DataType
+equalityDataType = mkDataType "Data.Type.Equality.(:=:)" [reflConstr]
+
+instance (Typeable a, Data a) => Data (a :=: a) where
+  gfoldl _ z Refl = z Refl
+  toConstr Refl   = reflConstr
+  gunfold _ z c   = case constrIndex c of
+                      1 -> z Refl
+                      _ -> error "Data.Data.gunfold(:=:)"
+  dataTypeOf _    = equalityDataType
+  dataCast2 f     = gcast2 f
index 7f77a4a..bb131e8 100644 (file)
@@ -67,6 +67,7 @@ import Control.Applicative
 import Control.Monad (MonadPlus(..))
 import Data.Maybe (fromMaybe, listToMaybe)
 import Data.Monoid
+import Data.Proxy
 
 #ifdef __GLASGOW_HASKELL__
 import GHC.Exts (build)
@@ -193,6 +194,20 @@ instance Ix i => Foldable (Array i) where
     foldr1 f = Prelude.foldr1 f . elems
     foldl1 f = Prelude.foldl1 f . elems
 
+instance Foldable Proxy where
+    foldMap _ _ = mempty
+    {-# INLINE foldMap #-}
+    fold _ = mempty
+    {-# INLINE fold #-}
+    foldr _ z _ = z
+    {-# INLINE foldr #-}
+    foldl _ z _ = z
+    {-# INLINE foldl #-}
+    foldl1 _ _ = error "foldl1: Proxy"
+    {-# INLINE foldl1 #-}
+    foldr1 _ _ = error "foldr1: Proxy"
+    {-# INLINE foldr1 #-}
+
 -- | Monadic fold over the elements of a structure,
 -- associating to the right, i.e. from right to left.
 foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
index dc7877a..65a33f9 100644 (file)
@@ -1,32 +1,45 @@
-{-# LANGUAGE PolyKinds, DeriveDataTypeable, NoImplicitPrelude,
-             DeriveGeneric #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+#ifdef __GLASGOW_HASKELL__
+{-# LANGUAGE PolyKinds #-}
+#endif
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Proxy
+-- License     :  BSD-style (see the LICENSE file in the distribution)
+--
+-- Maintainer  :  libraries@haskell.org
+-- Stability   :  experimental
+-- Portability :  portable
+--
+-- Definition of a Proxy type (poly-kinded in GHC)
+--
+-----------------------------------------------------------------------------
 
 module Data.Proxy
   (
-        Proxy(..), KProxy(..)
+        Proxy(..)
+#ifdef __GLASGOW_HASKELL__
+      , KProxy(..)
+#endif
   ) where
 
-import Data.Data
 import Data.Monoid
-import Data.Traversable
-import Data.Foldable
-
-import Control.Applicative
 
 import GHC.Base
 import GHC.Show
 import GHC.Read
 import GHC.Enum
 import GHC.Arr
-import qualified GHC.Generics as Generics
 
 -- | A concrete, poly-kinded proxy type
 data Proxy t = Proxy
-  deriving (Typeable, Generics.Generic)
 
+#ifdef __GLASGOW_HASKELL__
 -- | A concrete, promotable proxy type, for use at the kind level
 -- There are no instances for this because it is intended at the kind level only
 data KProxy (t :: *) = KProxy
+#endif
 
 instance Eq (Proxy s) where
   _ == _ = True
@@ -40,21 +53,6 @@ instance Show (Proxy s) where
 instance Read (Proxy s) where
   readsPrec d = readParen (d > 10) (\r -> [(Proxy, s) | ("Proxy",s) <- lex r ])
 
-proxyConstr :: Constr
-proxyConstr = mkConstr proxyDataType "Proxy" [] Prefix
-
-proxyDataType :: DataType
-proxyDataType = mkDataType "Data.Proxy.Proxy" [proxyConstr]
-
-instance (Data t) => Data (Proxy t) where
-  gfoldl _ z Proxy  = z Proxy
-  toConstr Proxy  = proxyConstr
-  gunfold _ z c = case constrIndex c of
-                    1 -> z Proxy
-                    _ -> error "Data.Data.gunfold(Proxy)"
-  dataTypeOf _ = proxyDataType
-  dataCast1 f  = gcast1 f
-
 instance Enum (Proxy s) where
     succ _               = error "Proxy.succ"
     pred _               = error "Proxy.pred"
@@ -84,12 +82,6 @@ instance Functor Proxy where
     fmap _ _ = Proxy
     {-# INLINE fmap #-}
 
-instance Applicative Proxy where
-    pure _ = Proxy
-    {-# INLINE pure #-}
-    _ <*> _ = Proxy
-    {-# INLINE (<*>) #-}
-
 instance Monoid (Proxy s) where
     mempty = Proxy
     {-# INLINE mempty #-}
@@ -103,27 +95,3 @@ instance Monad Proxy where
     {-# INLINE return #-}
     _ >>= _ = Proxy
     {-# INLINE (>>=) #-}
-
-instance Foldable Proxy where
-    foldMap _ _ = mempty
-    {-# INLINE foldMap #-}
-    fold _ = mempty
-    {-# INLINE fold #-}
-    foldr _ z _ = z
-    {-# INLINE foldr #-}
-    foldl _ z _ = z
-    {-# INLINE foldl #-}
-    foldl1 _ _ = error "foldl1: Proxy"
-    {-# INLINE foldl1 #-}
-    foldr1 _ _ = error "foldr1: Proxy"
-    {-# INLINE foldr1 #-}
-
-instance Traversable Proxy where
-    traverse _ _ = pure Proxy
-    {-# INLINE traverse #-}
-    sequenceA _ = pure Proxy
-    {-# INLINE sequenceA #-}
-    mapM _ _ = return Proxy
-    {-# INLINE mapM #-}
-    sequence _ = return Proxy
-    {-# INLINE sequence #-}
\ No newline at end of file
diff --git a/libraries/base/Data/Proxy.hs-boot b/libraries/base/Data/Proxy.hs-boot
deleted file mode 100644 (file)
index 3434d99..0000000
+++ /dev/null
@@ -1,5 +0,0 @@
-{-# LANGUAGE NoImplicitPrelude, PolyKinds #-}
-
-module Data.Proxy ( Proxy(..) ) where
-
-data Proxy (t :: k) = Proxy
\ No newline at end of file
index be5fe24..e34cde4 100644 (file)
@@ -56,6 +56,7 @@ import qualified Prelude (mapM, foldr)
 import Control.Applicative
 import Data.Foldable (Foldable())
 import Data.Monoid (Monoid)
+import Data.Proxy
 
 #if defined(__GLASGOW_HASKELL__)
 import GHC.Arr
@@ -192,6 +193,16 @@ instance Traversable ((,) a) where
 instance Ix i => Traversable (Array i) where
     traverse f arr = listArray (bounds arr) `fmap` traverse f (elems arr)
 
+instance Traversable Proxy where
+    traverse _ _ = pure Proxy
+    {-# INLINE traverse #-}
+    sequenceA _ = pure Proxy
+    {-# INLINE sequenceA #-}
+    mapM _ _ = return Proxy
+    {-# INLINE mapM #-}
+    sequence _ = return Proxy
+    {-# INLINE sequence #-}
+
 -- general functions
 
 -- | 'for' is 'traverse' with its arguments flipped.
index 343d0eb..62b0241 100644 (file)
@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE DeriveGeneric      #-}
 {-# LANGUAGE TypeOperators      #-}
 {-# LANGUAGE GADTs              #-}
@@ -8,15 +7,29 @@
 {-# LANGUAGE NoImplicitPrelude  #-}
 {-# LANGUAGE PolyKinds          #-}
 
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Type.Equality
+-- License     :  BSD-style (see the LICENSE file in the distribution)
+--
+-- Maintainer  :  libraries@haskell.org
+-- Stability   :  experimental
+-- Portability :  not portable
+--
+-- Definition of propositional equality @(:=:)@. Pattern-matching on a variable
+-- of type @(a :=: b)@ produces a proof that @a ~ b@.
+--
+-----------------------------------------------------------------------------
+
+
+
 module Data.Type.Equality where
 
-import Data.Data
 import Data.Maybe
 import GHC.Enum
 import GHC.Show
 import GHC.Read
 import GHC.Base
-import Control.Category
 
 infix 4 :=:
 
@@ -67,16 +80,10 @@ lower Refl = Refl
 deriving instance Eq   (a :=: b)
 deriving instance Show (a :=: b)
 deriving instance Ord  (a :=: b)
-deriving instance Typeable (:=:)
-deriving instance (Typeable a, Data a) => Data (a :=: a)
 
 instance Read (a :=: a) where
   readsPrec d = readParen (d > 10) (\r -> [(Refl, s) | ("Refl",s) <- lex r ])
 
-instance Category (:=:) where
-  id          = Refl
-  Refl . Refl = Refl
-
 instance Enum (a :=: a) where
   toEnum 0 = Refl
   toEnum _ = error "Data.Type.Equality.toEnum: bad argument"
diff --git a/libraries/base/Data/Type/Equality.hs-boot b/libraries/base/Data/Type/Equality.hs-boot
deleted file mode 100644 (file)
index db6ecab..0000000
+++ /dev/null
@@ -1,6 +0,0 @@
-{-# LANGUAGE TypeOperators, GADTs, PolyKinds, NoImplicitPrelude #-}
-
-module Data.Type.Equality where
-
-data a :=: b where
-  Refl :: a :=: a
\ No newline at end of file
index 34d777c..af8c672 100644 (file)
@@ -88,7 +88,7 @@ module Data.Typeable
   ) where
 
 import Data.Typeable.Internal hiding (mkTyCon)
-import {-# SOURCE #-} Data.Type.Equality
+import Data.Type.Equality
 
 import Unsafe.Coerce
 import Data.Maybe
index 0ab0232..4d5837b 100644 (file)
@@ -49,7 +49,7 @@ import GHC.Base
 import GHC.Word
 import GHC.Show
 import Data.Maybe
-import {-# SOURCE #-} Data.Proxy
+import Data.Proxy
 import GHC.Num
 import GHC.Real
 -- import GHC.IORef
@@ -60,6 +60,7 @@ import GHC.STRef        ( STRef )
 import GHC.Ptr          ( Ptr, FunPtr )
 -- import GHC.Stable
 import GHC.Arr          ( Array, STArray )
+import Data.Type.Equality
 -- import Data.Int
 
 import GHC.Fingerprint.Type
@@ -360,4 +361,6 @@ INSTANCE_TYPEABLE0(TypeRep,typeRepTc,"TypeRep")
 
 #ifdef __GLASGOW_HASKELL__
 deriving instance Typeable RealWorld
+deriving instance Typeable Proxy
+deriving instance Typeable (:=:)
 #endif
index e669af3..6ab1e9e 100644 (file)
@@ -53,6 +53,7 @@ import Data.Either ( Either(..) )
 import GHC.Classes ( Eq, Ord )
 import GHC.Read ( Read )
 import GHC.Show ( Show )
+import Data.Proxy
 
 --------------------------------------------------------------------------------
 -- Representation types
@@ -298,3 +299,5 @@ instance Generic Char where
   type Rep Char = D1 D_Char (C1 C_Char (S1 NoSelector (Rec0 Char)))
   from x = M1 (M1 (M1 (K1 x)))
   to (M1 (M1 (M1 (K1 x)))) = x
+
+deriving instance Generic (Proxy t)