\begin{code}
module TyCon(
- TyCon, KindCon, Boxity(..),
+ TyCon, KindCon, SuperKindCon, ArgVrcs, AlgTyConFlavour(..),
isFunTyCon, isUnLiftedTyCon, isBoxedTyCon, isProductTyCon,
isAlgTyCon, isDataTyCon, isSynTyCon, isNewTyCon, isPrimTyCon,
isEnumerationTyCon, isTupleTyCon, isUnboxedTupleTyCon,
+ isRecursiveTyCon, newTyConRep,
mkAlgTyCon,
+ mkClassTyCon,
mkFunTyCon,
mkPrimTyCon,
mkTupleTyCon,
mkSynTyCon,
mkKindCon,
- superKindCon,
+ mkSuperKindCon,
+
+ setTyConName,
tyConKind,
tyConUnique,
tyConTyVars,
+ tyConArgVrcs_maybe,
tyConDataCons,
tyConFamilySize,
tyConDerivings,
#include "HsVersions.h"
-import {-# SOURCE #-} Type ( Type, Kind )
-import {-# SOURCE #-} DataCon ( DataCon )
+import {-# SOURCE #-} TypeRep ( Type, 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 )
import Var ( TyVar )
import BasicTypes ( Arity, NewOrData(..), RecFlag(..) )
import Maybes
import Name ( Name, nameUnique, NamedThing(getName) )
-import Unique ( Unique, Uniquable(..), superKindConKey )
+import Unique ( Unique, Uniquable(..), anyBoxConKey )
import PrimRep ( PrimRep(..), isFollowableRep )
import Outputable
\end{code}
%************************************************************************
\begin{code}
-type KindCon = TyCon
+type KindCon = TyCon
+type SuperKindCon = TyCon
data TyCon
= FunTyCon {
tyConKind :: Kind,
tyConArity :: Arity,
- tyConTyVars :: [TyVar],
- dataTyConTheta :: [(Class,[Type])],
+ tyConTyVars :: [TyVar],
+ tyConArgVrcs :: ArgVrcs,
+ algTyConTheta :: [(Class,[Type])],
dataCons :: [DataCon],
-- Its data constructors, with fully polymorphic types
-- (b) in a quest for fast compilation we don't import
-- the constructors
- dataTyConDerivings :: [Class], -- Classes which have derived instances
+ 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
- dataTyConClass_maybe :: (Maybe Class), -- Nothing for ordinary types;
+ algTyConClass_maybe :: Maybe Class -- Nothing for ordinary types;
-- Just c for the type constructor
-- for dictionaries of class c.
- algTyConFlavour :: NewOrData,
- algTyConRec :: RecFlag -- Tells whether the data type is part of
- -- a mutually-recursive group or not
+
}
| PrimTyCon { -- Primitive types; cannot be defined in Haskell
tyConName :: Name,
tyConKind :: Kind,
tyConArity :: Arity,
+ tyConArgVrcs :: ArgVrcs,
primTyConRep :: PrimRep
}
tyConName :: Name,
tyConKind :: Kind,
tyConArity :: Arity,
- tyConBoxed :: Bool,
+ tyConBoxed :: Bool, -- True for boxed; False for unboxed
tyConTyVars :: [TyVar],
dataCon :: DataCon
}
tyConKind :: Kind,
tyConArity :: Arity,
- tyConTyVars :: [TyVar], -- Bound tyvars
- synTyConDefn :: Type -- Right-hand side, mentioning these type vars.
+ tyConTyVars :: [TyVar], -- Bound tyvars
+ synTyConDefn :: Type, -- Right-hand side, mentioning these type vars.
-- Acts as a template for the expansion when
-- the tycon is applied to some types.
+ tyConArgVrcs :: ArgVrcs
}
| KindCon { -- Type constructor at the kind level
tyConUnique :: Unique,
tyConName :: Name,
- tyConKind :: Kind,
- tyConArity :: Arity,
-
- kindConBoxity :: Boxity
+ tyConKind :: SuperKind,
+ tyConArity :: Arity
}
- | SuperKindCon { -- The type of kind variables,
- tyConUnique :: Unique -- sometimes written as a box
+ | SuperKindCon { -- The type of kind variables or boxity variables,
+ tyConUnique :: Unique,
+ tyConName :: Name
}
-data Boxity = Boxed | Unboxed | Open
+type ArgVrcs = [(Bool,Bool)] -- Tyvar variance info: [(occPos,occNeg)]
+ -- *NB*: this is tyvar variance info, *not*
+ -- termvar usage info.
+
+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:
+ -- newtype T a = MkT [(a,Int)]
+ -- The rep type is forall a. [(a,Int)]
+ --
+ -- The rep type isn't entirely simple:
+ -- for a recursive newtype we pick () as the rep type
+ -- newtype T = MkT T
\end{code}
%************************************************************************
So we compromise, and move their Kind calculation to the call site.
\begin{code}
-superKindCon = SuperKindCon superKindConKey
-
-mkKindCon name kind boxity
+mkSuperKindCon :: Name -> SuperKindCon
+mkSuperKindCon name = SuperKindCon {
+ tyConUnique = nameUnique name,
+ tyConName = name
+ }
+
+mkKindCon :: Name -> SuperKind -> KindCon
+mkKindCon name kind
= KindCon {
tyConUnique = nameUnique name,
tyConName = name,
tyConArity = 0,
- tyConKind = kind,
- kindConBoxity = boxity
+ tyConKind = kind
}
+mkFunTyCon :: Name -> Kind -> TyCon
mkFunTyCon name kind
= FunTyCon {
tyConUnique = nameUnique name,
tyConArity = 2
}
-mkAlgTyCon name kind tyvars theta cons derivs maybe_clas flavour rec
+mkAlgTyCon name kind tyvars theta argvrcs cons derivs flavour rec
= AlgTyCon {
- tyConName = name,
- tyConUnique = nameUnique name,
- tyConKind = kind,
- tyConArity = length tyvars,
- tyConTyVars = tyvars,
- dataTyConTheta = theta,
- dataCons = cons,
- dataTyConDerivings = derivs,
- dataTyConClass_maybe = maybe_clas,
- algTyConFlavour = flavour,
- algTyConRec = rec
+ tyConName = name,
+ tyConUnique = nameUnique name,
+ tyConKind = kind,
+ tyConArity = length tyvars,
+ tyConTyVars = tyvars,
+ tyConArgVrcs = argvrcs,
+ algTyConTheta = theta,
+ dataCons = cons,
+ algTyConDerivings = derivs,
+ algTyConClass_maybe = Nothing,
+ algTyConFlavour = flavour,
+ algTyConRec = rec
}
+mkClassTyCon name kind tyvars argvrcs con clas flavour
+ = AlgTyCon {
+ tyConName = name,
+ tyConUnique = nameUnique name,
+ tyConKind = kind,
+ tyConArity = length tyvars,
+ tyConTyVars = tyvars,
+ tyConArgVrcs = argvrcs,
+ algTyConTheta = [],
+ dataCons = [con],
+ algTyConDerivings = [],
+ algTyConClass_maybe = Just clas,
+ algTyConFlavour = flavour,
+ algTyConRec = NonRecursive
+ }
+
+
mkTupleTyCon name kind arity tyvars con boxed
= TupleTyCon {
tyConUnique = nameUnique name,
dataCon = con
}
-mkPrimTyCon name kind arity rep
+mkPrimTyCon name kind arity arg_vrcs rep
= PrimTyCon {
tyConName = name,
tyConUnique = nameUnique name,
tyConKind = kind,
tyConArity = arity,
+ tyConArgVrcs = arg_vrcs,
primTyConRep = rep
}
-mkSynTyCon name kind arity tyvars rhs
+mkSynTyCon name kind arity tyvars rhs argvrcs
= SynTyCon {
tyConName = name,
tyConUnique = nameUnique name,
tyConKind = kind,
tyConArity = arity,
tyConTyVars = tyvars,
- synTyConDefn = rhs
+ synTyConDefn = rhs,
+ tyConArgVrcs = argvrcs
}
+
+setTyConName tc name = tc {tyConName = name, tyConUnique = nameUnique name}
\end{code}
\begin{code}
isAlgTyCon (TupleTyCon {}) = True
isAlgTyCon other = False
--- isDataTyCon returns False for @newtype@.
+-- isDataTyCon returns False for @newtype@ and for unboxed tuples
isDataTyCon (AlgTyCon {algTyConFlavour = new_or_data}) = case new_or_data of
- NewType -> False
+ NewTyCon _ -> False
other -> True
-isDataTyCon (TupleTyCon {}) = True -- is an unboxed tuple a datatype?
+isDataTyCon (TupleTyCon {tyConBoxed = True}) = True
isDataTyCon other = False
-isNewTyCon (AlgTyCon {algTyConFlavour = NewType}) = True
-isNewTyCon other = False
+isNewTyCon (AlgTyCon {algTyConFlavour = NewTyCon _}) = True
+isNewTyCon other = False
--- A "product" tycon is non-recursive and has one constructor,
--- whether DataType or NewType
-isProductTyCon (AlgTyCon {dataCons = [c], algTyConRec = NonRecursive}) = True
-isProductTyCon (TupleTyCon {}) = True
-isProductTyCon other = False
+newTyConRep (AlgTyCon {algTyConFlavour = NewTyCon rep}) = Just rep
+newTyConRep other = Nothing
+
+-- A "product" tycon
+-- has *one* constructor,
+-- is *not* existential
+-- but
+-- may be DataType or NewType,
+-- may be unboxed or not,
+-- may be recursive or not
+isProductTyCon (AlgTyCon {dataCons = [data_con]}) = not (isExistentialDataCon data_con)
+isProductTyCon (TupleTyCon {}) = True
+isProductTyCon other = False
isSynTyCon (SynTyCon {}) = True
isSynTyCon _ = False
-isEnumerationTyCon (AlgTyCon {algTyConFlavour = EnumType}) = True
-isEnumerationTyCon other = False
+isEnumerationTyCon (AlgTyCon {algTyConFlavour = EnumTyCon}) = True
+isEnumerationTyCon other = False
-- The unit tycon isn't classed as a tuple tycon
isTupleTyCon (TupleTyCon {tyConArity = arity, tyConBoxed = True}) = arity >= 2
isUnboxedTupleTyCon (TupleTyCon {tyConBoxed = False}) = True
isUnboxedTupleTyCon other = False
+
+isRecursiveTyCon (AlgTyCon {algTyConRec = Recursive}) = True
+isRecursiveTyCon other = False
\end{code}
\begin{code}
\begin{code}
tyConDerivings :: TyCon -> [Class]
-tyConDerivings (AlgTyCon {dataTyConDerivings = derivs}) = derivs
-tyConDerivings other = []
+tyConDerivings (AlgTyCon {algTyConDerivings = derivs}) = derivs
+tyConDerivings other = []
\end{code}
\begin{code}
tyConTheta :: TyCon -> [(Class, [Type])]
-tyConTheta (AlgTyCon {dataTyConTheta = theta}) = theta
+tyConTheta (AlgTyCon {algTyConTheta = theta}) = theta
-- should ask about anything else
\end{code}
+@tyConArgVrcs_maybe@ gives a list of (occPos,occNeg) flags, one for
+each tyvar, if available. See @calcAlgTyConArgVrcs@ for how this is
+actually computed (in another file).
+
+\begin{code}
+tyConArgVrcs_maybe :: TyCon -> Maybe ArgVrcs
+
+tyConArgVrcs_maybe (FunTyCon {} ) = Just [(False,True),(True,False)]
+tyConArgVrcs_maybe (AlgTyCon {tyConArgVrcs = oi}) = Just oi
+tyConArgVrcs_maybe (PrimTyCon {tyConArgVrcs = oi}) = Just oi
+tyConArgVrcs_maybe (TupleTyCon {tyConArity = arity }) = Just (replicate arity (True,False))
+tyConArgVrcs_maybe (SynTyCon {tyConArgVrcs = oi }) = Just oi
+tyConArgVrcs_maybe _ = Nothing
+\end{code}
+
\begin{code}
getSynTyConDefn :: TyCon -> ([TyVar], Type)
getSynTyConDefn (SynTyCon {tyConTyVars = tyvars, synTyConDefn = ty}) = (tyvars,ty)
maybeTyConSingleCon (AlgTyCon {}) = Nothing
maybeTyConSingleCon (TupleTyCon {dataCon = con}) = Just con
maybeTyConSingleCon (PrimTyCon {}) = Nothing
+maybeTyConSingleCon (FunTyCon {}) = Nothing -- case at funty
+maybeTyConSingleCon tc = pprPanic "maybeTyConSingleCon: unexpected tycon " $
+ ppr tc
\end{code}
\begin{code}
tyConClass_maybe :: TyCon -> Maybe Class
-tyConClass_maybe (AlgTyCon {dataTyConClass_maybe = maybe_cls}) = maybe_cls
-tyConClass_maybe other_tycon = Nothing
+tyConClass_maybe (AlgTyCon {algTyConClass_maybe = maybe_cls}) = maybe_cls
+tyConClass_maybe other_tycon = Nothing
\end{code}
@matchesTyCon tc1 tc2@ checks whether an appliation
(tc1 t1..tn) matches (tc2 t1..tn). By "matches" we basically mean "equals",
-except that at the kind level tc2 might have more boxity info that tc1.
-
-E.g. It's ok to bind a type variable
- tv :: k2
-to a type
- t :: k1
+except that at the kind level tc2 might have more boxity info than tc1.
\begin{code}
matchesTyCon :: TyCon -- Expected (e.g. arg type of function)
-> TyCon -- Inferred (e.g. type of actual arg to function)
-> Bool
-matchesTyCon (KindCon {kindConBoxity = k1}) (KindCon {kindConBoxity = k2})
- = k2 `has_more` k1
- where
- -- "has_more" means has more boxity info
- Boxed `has_more` Open = True
- Boxed `has_more` Boxed = True
- Unboxed `has_more` Open = True
- Unboxed `has_more` Unboxed = True
- Open `has_more` Open = True
- k1 `has_more` k2 = False
-
-matchesTyCon tc1 tc2 = tyConUnique tc1 == tyConUnique tc2
+matchesTyCon tc1 tc2 = uniq1 == uniq2 || uniq1 == anyBoxConKey
+ where
+ uniq1 = tyConUnique tc1
+ uniq2 = tyConUnique tc2
\end{code}