isTupleTyCon, isUnboxedTupleTyCon, isBoxedTupleTyCon, tupleTyConBoxity,
isRecursiveTyCon, newTyConRep,
- mkAlgTyCon,
+ mkAlgTyCon, --mkAlgTyCon,
mkClassTyCon,
mkFunTyCon,
mkPrimTyCon,
setTyConName,
+ tyConName,
tyConKind,
tyConUnique,
tyConTyVars,
tyConArgVrcs_maybe,
- tyConDataCons, tyConDataConsIfAvailable,
- tyConFamilySize,
- tyConDerivings,
+ tyConDataCons, tyConDataConsIfAvailable, tyConFamilySize,
+ tyConSelIds,
tyConTheta,
tyConPrimRep,
tyConArity,
- isClassTyCon,
+ isClassTyCon, tyConClass_maybe,
getSynTyConDefn,
maybeTyConSingleCon,
- matchesTyCon
+ matchesTyCon,
+
+ -- Generics
+ tyConGenIds, tyConGenInfo
) where
#include "HsVersions.h"
-import {-# SOURCE #-} TypeRep ( Type, Kind, SuperKind )
+import {-# SOURCE #-} TypeRep ( Type, PredType, Kind, SuperKind )
-- Should just be Type(Type), but this fails due to bug present up to
-- and including 4.02 involving slurping of hi-boot files. Bug is now fixed.
import {-# SOURCE #-} DataCon ( DataCon, isExistentialDataCon )
-import Class ( Class, ClassContext )
-import Var ( TyVar )
-import BasicTypes ( Arity, NewOrData(..), RecFlag(..), Boxity(..), isBoxed )
+
+import Var ( TyVar, Id )
+import Class ( Class )
+import BasicTypes ( Arity, RecFlag(..), Boxity(..),
+ isBoxed, EP(..) )
import Name ( Name, nameUnique, NamedThing(getName) )
import PrelNames ( Unique, Uniquable(..), anyBoxConKey )
import PrimRep ( PrimRep(..), isFollowableRep )
tyConTyVars :: [TyVar],
tyConArgVrcs :: ArgVrcs,
- algTyConTheta :: ClassContext,
+ algTyConTheta :: [PredType],
dataCons :: [DataCon],
-- Its data constructors, with fully polymorphic types
-- (b) in a quest for fast compilation we don't import
-- the constructors
+ selIds :: [Id], -- Its record selectors (if any)
+
noOfDataCons :: Int, -- Number of data constructors
-- Usually this is the same as the length of the
-- dataCons field, but the latter may be empty if
-- abstractly we still need to know the number of constructors
-- so we can get the return convention right. Tiresome!
- algTyConDerivings :: [Class], -- Classes which have derived instances
-
algTyConFlavour :: AlgTyConFlavour,
algTyConRec :: RecFlag, -- Tells whether the data type is part of
-- a mutually-recursive group or not
- algTyConClass :: Bool -- True if this tycon comes from a class declaration
+ genInfo :: Maybe (EP Id), -- Convert T <-> Tring
+ -- Some TyCons don't have it;
+ -- e.g. the TyCon for a Class dictionary,
+ -- and TyCons with unboxed arguments
+
+ algTyConClass :: Maybe Class -- Just cl if this tycon came from a class declaration
}
| PrimTyCon { -- Primitive types; cannot be defined in Haskell
tyConArity :: Arity,
tyConBoxed :: Boxity,
tyConTyVars :: [TyVar],
- dataCon :: DataCon
+ dataCon :: DataCon,
+ genInfo :: Maybe (EP Id) -- Generic type and conv funs
}
| SynTyCon {
}
type ArgVrcs = [(Bool,Bool)] -- Tyvar variance info: [(occPos,occNeg)]
- -- *NB*: this is tyvar variance info, *not*
- -- termvar usage info.
data AlgTyConFlavour
= DataTyCon -- Data type
tyConKind = kind,
tyConArity = 2
}
-
-mkAlgTyCon name kind tyvars theta argvrcs cons ncons derivs flavour rec
+
+tyConGenInfo :: TyCon -> Maybe (EP Id)
+tyConGenInfo (AlgTyCon { genInfo = info }) = info
+tyConGenInfo (TupleTyCon { genInfo = info }) = info
+tyConGenInfo other = Nothing
+
+tyConGenIds :: TyCon -> [Id]
+-- Returns the generic-programming Ids; these Ids need bindings
+tyConGenIds tycon = case tyConGenInfo tycon of
+ Nothing -> []
+ Just (EP from to) -> [from,to]
+
+-- This is the making of a TyCon. Just the same as the old mkAlgTyCon,
+-- but now you also have to pass in the generic information about the type
+-- constructor - you can get hold of it easily (see Generics module)
+mkAlgTyCon name kind tyvars theta argvrcs cons ncons sels flavour rec
+ gen_info
= AlgTyCon {
tyConName = name,
tyConUnique = nameUnique name,
tyConArgVrcs = argvrcs,
algTyConTheta = theta,
dataCons = cons,
+ selIds = sels,
noOfDataCons = ncons,
- algTyConDerivings = derivs,
- algTyConClass = False,
+ algTyConClass = Nothing,
algTyConFlavour = flavour,
- algTyConRec = rec
+ algTyConRec = rec,
+ genInfo = gen_info
}
mkClassTyCon name kind tyvars argvrcs con clas flavour
tyConArgVrcs = argvrcs,
algTyConTheta = [],
dataCons = [con],
+ selIds = [],
noOfDataCons = 1,
- algTyConDerivings = [],
- algTyConClass = True,
+ algTyConClass = Just clas,
algTyConFlavour = flavour,
- algTyConRec = NonRecursive
+ algTyConRec = NonRecursive,
+ genInfo = Nothing
}
-mkTupleTyCon name kind arity tyvars con boxed
+mkTupleTyCon name kind arity tyvars con boxed gen_info
= TupleTyCon {
tyConUnique = nameUnique name,
tyConName = name,
tyConArity = arity,
tyConBoxed = boxed,
tyConTyVars = tyvars,
- dataCon = con
+ dataCon = con,
+ genInfo = gen_info
}
mkPrimTyCon name kind arity arg_vrcs rep
}
setTyConName tc name = tc {tyConName = name, tyConUnique = nameUnique name}
+
\end{code}
\begin{code}
\begin{code}
tyConDataCons :: TyCon -> [DataCon]
-tyConDataCons tycon = ASSERT2( not (null cons), ppr tycon ) cons
+tyConDataCons tycon = ASSERT2( not (null cons), ppr tycon )
+ ASSERT2( length cons == tyConFamilySize tycon, ppr tycon )
+ cons
where
cons = tyConDataConsIfAvailable tycon
tyConFamilySize other = pprPanic "tyConFamilySize:" (ppr other)
#endif
-tyConPrimRep :: TyCon -> PrimRep
-tyConPrimRep (PrimTyCon {primTyConRep = rep}) = rep
-tyConPrimRep _ = PtrRep
+tyConSelIds :: TyCon -> [Id]
+tyConSelIds (AlgTyCon {selIds = sels}) = sels
+tyConSelIds other_tycon = []
\end{code}
\begin{code}
-tyConDerivings :: TyCon -> [Class]
-tyConDerivings (AlgTyCon {algTyConDerivings = derivs}) = derivs
-tyConDerivings other = []
+tyConPrimRep :: TyCon -> PrimRep
+tyConPrimRep (PrimTyCon {primTyConRep = rep}) = rep
+tyConPrimRep _ = PtrRep
\end{code}
\begin{code}
-tyConTheta :: TyCon -> ClassContext
+tyConTheta :: TyCon -> [PredType]
tyConTheta (AlgTyCon {algTyConTheta = theta}) = theta
-- should ask about anything else
\end{code}
\begin{code}
isClassTyCon :: TyCon -> Bool
-isClassTyCon (AlgTyCon {algTyConClass = is_class_tycon}) = is_class_tycon
-isClassTyCon other_tycon = False
+isClassTyCon (AlgTyCon {algTyConClass = Just _}) = True
+isClassTyCon other_tycon = False
+
+tyConClass_maybe :: TyCon -> Maybe Class
+tyConClass_maybe (AlgTyCon {algTyConClass = maybe_clas}) = maybe_clas
+tyConClass_maybe ther_tycon = Nothing
\end{code}
getUnique tc = tyConUnique tc
instance Outputable TyCon where
- ppr tc = ppr (getName tc)
+ ppr tc = ppr (getName tc)
instance NamedThing TyCon where
getName = tyConName
uniq1 = tyConUnique tc1
uniq2 = tyConUnique tc2
\end{code}
+
+
+