X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Ftypes%2FTyCon.lhs;h=6dba52b50081cd275a548d6141a2698a93fa21bb;hb=272fb49ecfeffe7aaa66b9b61bab12d8a858458d;hp=d91effeada8da392126742bd68afd40d621c53e5;hpb=b00b5bc04ff36a551552470060064f0b7d84ca30;p=ghc-hetmet.git

diff --git a/compiler/types/TyCon.lhs b/compiler/types/TyCon.lhs
index d91effe..6dba52b 100644
--- a/compiler/types/TyCon.lhs
+++ b/compiler/types/TyCon.lhs
@@ -1,7 +1,9 @@
 %
+% (c) The University of Glasgow 2006
 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
 %
-\section[TyCon]{The @TyCon@ datatype}
+
+The @TyCon@ datatype
 
 \begin{code}
 module TyCon(
@@ -11,12 +13,12 @@ module TyCon(
 	tyConPrimRep,
 
 	AlgTyConRhs(..), visibleDataCons, 
-        AlgTyConParent(..), hasParent,
+        AlgTyConParent(..), 
 	SynTyConRhs(..),
 
 	isFunTyCon, isUnLiftedTyCon, isProductTyCon, 
-	isAlgTyCon, isDataTyCon, isSynTyCon, isNewTyCon, isClosedNewTyCon,
-	isPrimTyCon, 
+	isAlgTyCon, isDataTyCon, isNewTyCon, isClosedNewTyCon, isSynTyCon,
+	isClosedSynTyCon, isPrimTyCon, 
 	isEnumerationTyCon, isGadtSyntaxTyCon, isOpenTyCon,
 	assocTyConArgPoss_maybe, isTyConAssoc, setTyConArgPoss,
 	isTupleTyCon, isUnboxedTupleTyCon, isBoxedTupleTyCon, tupleTyConBoxity,
@@ -66,13 +68,12 @@ module TyCon(
 import {-# SOURCE #-} TypeRep ( Kind, Type, PredType )
 import {-# SOURCE #-} DataCon ( DataCon, isVanillaDataCon )
 
-import Var   		( TyVar, Id )
-import Class		( Class )
-import BasicTypes	( Arity, RecFlag(..), Boxity(..), isBoxed )
-import Name		( Name, nameUnique, NamedThing(getName) )
-import PrelNames	( Unique, Uniquable(..) )
-import Maybe		( isJust )
-import Maybes		( orElse )
+import Var
+import Class
+import BasicTypes
+import Name
+import PrelNames
+import Maybes
 import Outputable
 import FastString
 \end{code}
@@ -113,6 +114,8 @@ data TyCon
 					-- argument list (starting from 0).
 					-- NB: Length is less than tyConArity
 					--     if higher kind signature.
+					-- NB: Just _ <=> associated (not
+					--		  toplevel) family
 	
 	algTcSelIds :: [Id],  		-- Its record selectors (empty if none)
 
@@ -171,7 +174,8 @@ data TyCon
 	tyConUnique   :: Unique,
 	tyConName     :: Name,
 	tyConKind     :: Kind,
-	tyConArity    :: Arity,
+	tyConArity    :: Arity,		-- SLPJ Oct06: I'm not sure what the significance
+					--	       of the arity of a primtycon is!
 
 	primTyConRep  :: PrimRep,
 			-- Many primitive tycons are unboxed, but some are
@@ -263,23 +267,23 @@ visibleDataCons (NewTyCon{ data_con = c })    = [c]
 -- structure (ie, the class or family from which they derive) using a type of
 -- the following form.
 --
-data AlgTyConParent = -- An ordinary type constructor has no parent.
-		      NoParentTyCon
-
-		      -- Type constructors representing a class dictionary.
-		    | ClassTyCon    Class	
-
-		      -- Type constructors representing an instances of a type
-		      -- family.
-		    | FamilyTyCon   TyCon	-- the type family
-				    [Type]	-- instance types
-				    TyCon	-- a *coercion* identifying
-						-- the representation type
-						-- with the type instance
-
-hasParent :: AlgTyConParent -> Bool
-hasParent NoParentTyCon = False
-hasParent _other        = True
+data AlgTyConParent 
+  = NoParentTyCon	-- An ordinary type constructor has no parent.
+
+  | ClassTyCon      	-- Type constructors representing a class dictionary.
+	Class	
+
+  | FamilyTyCon		-- Type constructors representing an instance of a type
+	TyCon		--   The type family
+	[Type]		--   Instance types
+	TyCon		--   A CoercionTyCon identifying the representation 
+			--     type with the type instance family.  
+			--	c.f. Note [Newtype coercions]
+	-- E.g.  data intance T [a] = ...
+	-- gives a representation tycon:
+	--	data T77 a = ...
+	-- 	axiom co a :: T [a] ~ T77 a
+	-- with T77's algTcParent = FamilyTyCon T [a] co
 
 data SynTyConRhs
   = OpenSynTyCon Kind	-- Type family: *result* kind given
@@ -316,7 +320,7 @@ and then when we used CoT at a particular type, s, we'd say
 	CoT @ s
 which encodes as (TyConApp instCoercionTyCon [TyConApp CoT [], s])
 
-But in GHC we instead make CoT into a new piece of type syntax
+But in GHC we instead make CoT into a new piece of type syntax, CoercionTyCon,
 (like instCoercionTyCon, symCoercionTyCon etc), which must always
 be saturated, but which encodes as
 	TyConApp CoT [s]
@@ -543,8 +547,8 @@ isAlgTyCon (TupleTyCon {}) = True
 isAlgTyCon other 	   = False
 
 isDataTyCon :: TyCon -> Bool
--- isDataTyCon returns True for data types that are represented by
--- heap-allocated constructors.
+-- isDataTyCon returns True for data types that are definitely
+-- represented by heap-allocated constructors.
 -- These are srcutinised by Core-level @case@ expressions, and they
 -- get info tables allocated for them.
 --	True for all @data@ types
@@ -556,7 +560,7 @@ isDataTyCon tc@(AlgTyCon {algTcRhs = rhs})
 	DataTyCon {}  -> True
 	OpenNewTyCon  -> False
 	NewTyCon {}   -> False
-	AbstractTyCon -> pprPanic "isDataTyCon" (ppr tc)
+	AbstractTyCon -> False	-- We don't know, so return False
 isDataTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity
 isDataTyCon other = False
 
@@ -596,6 +600,13 @@ isSynTyCon :: TyCon -> Bool
 isSynTyCon (SynTyCon {}) = True
 isSynTyCon _		 = False
 
+-- As for newtypes, it is in some contexts important to distinguish between
+-- closed synonyms and synonym families, as synonym families have no unique
+-- right hand side to which a synonym family application can expand.
+--
+isClosedSynTyCon :: TyCon -> Bool
+isClosedSynTyCon tycon = isSynTyCon tycon && not (isOpenTyCon tycon)
+
 isGadtSyntaxTyCon :: TyCon -> Bool
 isGadtSyntaxTyCon (AlgTyCon { algTcGadtSyntax = res }) = res
 isGadtSyntaxTyCon other				       = False
@@ -672,11 +683,24 @@ isCoercionTyCon :: TyCon -> Bool
 isCoercionTyCon (CoercionTyCon {}) = True
 isCoercionTyCon other              = False
 
+-- Identifies implicit tycons that, in particular, do not go into interface
+-- files (because they are implicitly reconstructed when the interface is
+-- read).
+--
+-- Note that 
+--
+-- * associated families are implicit, as they are re-constructed from
+--   the class declaration in which they reside, and 
+-- * family instances are *not* implicit as they represent the instance body
+--   (similar to a dfun does that for a class instance).
+--
 isImplicitTyCon :: TyCon -> Bool
-isImplicitTyCon SynTyCon{}                     = False
-isImplicitTyCon AlgTyCon{algTcParent = parent} = hasParent parent
-isImplicitTyCon other                          = True
-        -- catches: FunTyCon, TupleTyCon, PrimTyCon, 
+isImplicitTyCon tycon | isTyConAssoc tycon           = True
+		      | isSynTyCon tycon	     = False
+		      | isAlgTyCon tycon	     = isClassTyCon tycon ||
+						       isTupleTyCon tycon
+isImplicitTyCon _other                               = True
+        -- catches: FunTyCon, PrimTyCon, 
         -- CoercionTyCon, SuperKindTyCon
 \end{code}
 
@@ -824,7 +848,7 @@ isClassTyCon other_tycon			     = False
 
 tyConClass_maybe :: TyCon -> Maybe Class
 tyConClass_maybe (AlgTyCon {algTcParent = ClassTyCon clas}) = Just clas
-tyConClass_maybe ther_tycon				    = Nothing
+tyConClass_maybe other_tycon				    = Nothing
 
 isFamInstTyCon :: TyCon -> Bool
 isFamInstTyCon (AlgTyCon {algTcParent = FamilyTyCon _ _ _ }) = True
@@ -833,13 +857,13 @@ isFamInstTyCon other_tycon			             = False
 tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])
 tyConFamInst_maybe (AlgTyCon {algTcParent = FamilyTyCon fam instTys _}) = 
   Just (fam, instTys)
-tyConFamInst_maybe ther_tycon				                = 
+tyConFamInst_maybe other_tycon				                = 
   Nothing
 
 tyConFamilyCoercion_maybe :: TyCon -> Maybe TyCon
 tyConFamilyCoercion_maybe (AlgTyCon {algTcParent = FamilyTyCon _ _ coe}) = 
   Just coe
-tyConFamilyCoercion_maybe ther_tycon 				         = 
+tyConFamilyCoercion_maybe other_tycon 				         = 
   Nothing
 \end{code}