mkClassTyCon,
mkFunTyCon,
mkPrimTyCon,
+ mkLiftedPrimTyCon,
mkTupleTyCon,
mkSynTyCon,
mkKindCon,
import PrelNames ( Unique, Uniquable(..), anyBoxConKey )
import PrimRep ( PrimRep(..), isFollowableRep )
import Outputable
+import FastString
\end{code}
%************************************************************************
primTyConRep :: PrimRep, -- Many primitive tycons are unboxed, but some are
-- boxed (represented by pointers). The PrimRep tells.
- isUnLifted :: Bool -- Most primitive tycons are unlifted,
+ isUnLifted :: Bool, -- Most primitive tycons are unlifted,
-- but foreign-imported ones may not be
+ tyConExtName :: Maybe FastString
}
| TupleTyCon {
data AlgTyConFlavour
= DataTyCon -- Data type
+
| EnumTyCon -- Special sort of enumeration type
+
| NewTyCon Type -- Newtype, with its *ultimate* representation type
-- By 'ultimate' I mean that the rep type is not itself
-- a newtype or type synonym.
- -- The rep type has explicit for-alls for the tyvars of
- -- the TyCon. Thus:
+ -- The rep type has free type variables the tyConTyVars
+ -- Thus:
-- newtype T a = MkT [(a,Int)]
- -- The rep type is forall a. [(a,Int)]
+ -- The rep type is [(a,Int)]
--
-- The rep type isn't entirely simple:
-- for a recursive newtype we pick () as the rep type
genInfo = gen_info
}
-mkClassTyCon name kind tyvars argvrcs con clas flavour
+mkClassTyCon name kind tyvars argvrcs con clas flavour rec
= AlgTyCon {
tyConName = name,
tyConUnique = nameUnique name,
noOfDataCons = 1,
algTyConClass = Just clas,
algTyConFlavour = flavour,
- algTyConRec = NonRecursive,
+ algTyConRec = rec,
genInfo = Nothing
}
}
-- Foreign-imported (.NET) type constructors are represented
--- as primitive, but *lifted*, TyCons for now.
--- They have PtrRep
-mkForeignTyCon name kind arity arg_vrcs
+-- as primitive, but *lifted*, TyCons for now. They are lifted
+-- because the Haskell type T representing the (foreign) .NET
+-- type T is actually implemented (in ILX) as a thunk<T>
+-- They have PtrRep
+mkForeignTyCon name ext_name kind arity arg_vrcs
= PrimTyCon {
tyConName = name,
tyConUnique = nameUnique name,
tyConArity = arity,
tyConArgVrcs = arg_vrcs,
primTyConRep = PtrRep,
- isUnLifted = False
+ isUnLifted = False,
+ tyConExtName = ext_name
}
+-- most Prim tycons are lifted
mkPrimTyCon name kind arity arg_vrcs rep
+ = mkPrimTyCon' name kind arity arg_vrcs rep True
+
+-- but RealWorld is lifted
+mkLiftedPrimTyCon name kind arity arg_vrcs rep
+ = mkPrimTyCon' name kind arity arg_vrcs rep False
+
+mkPrimTyCon' name kind arity arg_vrcs rep is_unlifted
= PrimTyCon {
tyConName = name,
tyConUnique = nameUnique name,
tyConArity = arity,
tyConArgVrcs = arg_vrcs,
primTyConRep = rep,
- isUnLifted = True
+ isUnLifted = is_unlifted,
+ tyConExtName = Nothing
}
mkSynTyCon name kind arity tyvars rhs argvrcs
isAlgTyCon (TupleTyCon {}) = True
isAlgTyCon other = False
--- isDataTyCon returns False for @newtype@ and for unboxed tuples
-isDataTyCon (AlgTyCon {algTyConFlavour = new_or_data}) = case new_or_data of
- NewTyCon _ -> False
- other -> True
+-- isDataTyCon returns True for data types that are 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
+-- False for newtypes
+-- unboxed tuples
+isDataTyCon (AlgTyCon {algTyConFlavour = new_or_data, algTyConRec = is_rec})
+ = case new_or_data of
+ NewTyCon _ -> False
+ other -> True
+
isDataTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity
isDataTyCon other = False
isNewTyCon (AlgTyCon {algTyConFlavour = NewTyCon _}) = True
isNewTyCon other = False
-newTyConRep (AlgTyCon {algTyConFlavour = NewTyCon rep}) = Just rep
-newTyConRep other = Nothing
+newTyConRep :: TyCon -> ([TyVar], Type)
+newTyConRep (AlgTyCon {tyConTyVars = tvs, algTyConFlavour = NewTyCon rep}) = (tvs, rep)
-- A "product" tycon
-- has *one* constructor,