X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=Data%2FTypeable.hs;h=7f0e974e56d5c9f6173de6a759f38f8f217d2e25;hb=3e23aaae1a1f07fd28f1092d0f79e13d66b72f09;hp=ff2b304a685c7e9150ef6dcbbbf702646b4b8da7;hpb=d4039901986f6991c23f0469a40148e8150b0f1e;p=ghc-base.git

diff --git a/Data/Typeable.hs b/Data/Typeable.hs
index ff2b304..7f0e974 100644
--- a/Data/Typeable.hs
+++ b/Data/Typeable.hs
@@ -9,15 +9,24 @@
 -- Stability   :  experimental
 -- Portability :  portable
 --
--- The Typeable class reifies types to some extent by associating type
+-- The 'Typeable' class reifies types to some extent by associating type
 -- representations to types. These type representations can be compared,
 -- and one can in turn define a type-safe cast operation. To this end,
 -- an unsafe cast is guarded by a test for type (representation)
--- equivalence. The module Data.Dynamic uses Typeable for an
--- implementation of dynamics. The module Data.Generics uses Typeable
+-- equivalence. The module "Data.Dynamic" uses Typeable for an
+-- implementation of dynamics. The module "Data.Generics" uses Typeable
 -- and type-safe cast (but not dynamics) to support the \"Scrap your
 -- boilerplate\" style of generic programming.
 --
+-- Note, only relevant if you use dynamic linking. If you have a program
+-- that is statically linked with Data.Typeable, and then dynamically link
+-- a program that also uses Data.Typeable, you'll get two copies of the module.
+-- That's fine, but behind the scenes, the module uses a mutable variable to
+-- allocate unique Ids to type constructors.  So in the situation described,
+-- there'll be two separate Id allocators, which aren't comparable to each other.
+-- This can lead to chaos.  (It's a bug that we will fix.)  None of
+-- this matters if you aren't using dynamic linking.
+--
 -----------------------------------------------------------------------------
 
 module Data.Typeable
@@ -39,13 +48,13 @@ module Data.Typeable
 	mkTyConApp,	-- :: TyCon   -> [TypeRep] -> TypeRep
 	mkAppTy,	-- :: TypeRep -> TypeRep   -> TypeRep
 	mkFunTy,	-- :: TypeRep -> TypeRep   -> TypeRep
-	splitTyConApp,	-- :: TypeRep -> (TyCon, [TypeRep])
-	funResultTy,	-- :: TypeRep -> TypeRep   -> Maybe TypeRep
 
 	-- * Observation of type representations
-	typerepTyCon,	-- :: TypeRep -> TyCon
-	typerepArgs,	-- :: TypeRep -> [TypeRep]
-	tyconString,	-- :: TyCon   -> String
+	splitTyConApp,	-- :: TypeRep -> (TyCon, [TypeRep])
+	funResultTy,	-- :: TypeRep -> TypeRep   -> Maybe TypeRep
+	typeRepTyCon,	-- :: TypeRep -> TyCon
+	typeRepArgs,	-- :: TypeRep -> [TypeRep]
+	tyConString,	-- :: TyCon   -> String
 
 	-- * The other Typeable classes
 	-- | /Note:/ The general instances are provided for GHC only.
@@ -87,6 +96,7 @@ import GHC.Num
 import GHC.Float
 import GHC.Real( rem, Ratio )
 import GHC.IOBase
+import GHC.ST		-- So we can give Typeable instance for ST
 import GHC.Ptr          -- So we can give Typeable instance for Ptr
 import GHC.Stable       -- So we can give Typeable instance for StablePtr
 #endif
@@ -211,16 +221,16 @@ mkTyCon str = TyCon (mkTyConKey str) str
 ----------------- Observation ---------------------
 
 -- | Observe the type constructor of a type representation
-typerepTyCon :: TypeRep -> TyCon
-typerepTyCon (TypeRep _ tc _) = tc
+typeRepTyCon :: TypeRep -> TyCon
+typeRepTyCon (TypeRep _ tc _) = tc
 
 -- | Observe the argument types of a type representation
-typerepArgs :: TypeRep -> [TypeRep]
-typerepArgs (TypeRep _ _ args) = args
+typeRepArgs :: TypeRep -> [TypeRep]
+typeRepArgs (TypeRep _ _ args) = args
 
 -- | Observe string encoding of a type representation
-tyconString :: TyCon   -> String
-tyconString  (TyCon _ str) = str
+tyConString :: TyCon   -> String
+tyConString  (TyCon _ str) = str
 
 ----------------- Showing TypeReps --------------------
 
@@ -454,6 +464,9 @@ INSTANCE_TYPEABLE1(Ratio,ratioTc,"Ratio")
 INSTANCE_TYPEABLE2(Either,eitherTc,"Either")
 INSTANCE_TYPEABLE2((->),funTc,"->")
 INSTANCE_TYPEABLE1(IO,ioTc,"IO")
+#ifdef __GLASGOW_HASKELL__
+INSTANCE_TYPEABLE2(ST,stTc,"ST")
+#endif
 INSTANCE_TYPEABLE0((),unitTc,"()")
 #ifndef __NHC__
 INSTANCE_TYPEABLE2((,),pairTc,",")
@@ -478,15 +491,15 @@ instance Typeable6 (,,,,,) where
   typeOf6 tu = mkTyConApp tup6Tc []
 
 tup7Tc :: TyCon
-tup7Tc = mkTyCon ",,,,,"
+tup7Tc = mkTyCon ",,,,,,"
 
 instance Typeable7 (,,,,,,) where
   typeOf7 tu = mkTyConApp tup7Tc []
 
 #endif /* __NHC__ */
-INSTANCE_TYPEABLE1(Ptr,ptrTc,"Foreign.Ptr.Ptr")
-INSTANCE_TYPEABLE1(StablePtr,stableptrTc,"Foreign.StablePtr.StablePtr")
-INSTANCE_TYPEABLE1(IORef,iorefTc,"Data.IORef.IORef")
+INSTANCE_TYPEABLE1(Ptr,ptrTc,"Ptr")
+INSTANCE_TYPEABLE1(StablePtr,stableptrTc,"StablePtr")
+INSTANCE_TYPEABLE1(IORef,iorefTc,"IORef")
 
 -------------------------------------------------------
 --
@@ -517,7 +530,9 @@ INSTANCE_TYPEABLE0(TyCon,tyconTc,"TyCon")
 INSTANCE_TYPEABLE0(TypeRep,typeRepTc,"TypeRep")
 
 #ifdef __GLASGOW_HASKELL__
+INSTANCE_TYPEABLE0(RealWorld,realWorldTc,"RealWorld")
 INSTANCE_TYPEABLE0(Word,wordTc,"Word" )
+INSTANCE_TYPEABLE1(MVar,mvarTc,"MVar" )
 #endif
 
 ---------------------------------------------