module BuildTyCl (
buildSynTyCon, buildAlgTyCon, buildDataCon,
buildClass,
- mkAbstractTyConRhs, mkNewTyConRhs, mkDataTyConRhs
+ mkAbstractTyConRhs, mkOpenDataTyConRhs, mkOpenNewTyConRhs,
+ mkNewTyConRhs, mkDataTyConRhs
) where
#include "HsVersions.h"
import TysWiredIn ( unitTy )
import BasicTypes ( RecFlag, StrictnessMark(..) )
import Name ( Name )
-import OccName ( mkDataConWrapperOcc, mkDataConWorkerOcc, mkClassTyConOcc,
- mkClassDataConOcc, mkSuperDictSelOcc, mkNewTyCoOcc )
+import OccName ( mkDataConWrapperOcc, mkDataConWorkerOcc,
+ mkClassTyConOcc, mkClassDataConOcc,
+ mkSuperDictSelOcc, mkNewTyCoOcc, mkInstTyTcOcc,
+ mkInstTyCoOcc )
import MkId ( mkDataConIds, mkRecordSelId, mkDictSelId )
import Class ( mkClass, Class( classTyCon), FunDep, DefMeth(..) )
-import TyCon ( mkSynTyCon, mkAlgTyCon, visibleDataCons, tyConStupidTheta,
- tyConDataCons, isNewTyCon, mkClassTyCon, TyCon( tyConTyVars ),
- isRecursiveTyCon, tyConArity,
- AlgTyConRhs(..), newTyConRhs )
+import TyCon ( mkSynTyCon, mkAlgTyCon, visibleDataCons,
+ tyConStupidTheta, tyConDataCons, isNewTyCon,
+ mkClassTyCon, TyCon( tyConTyVars ),
+ isRecursiveTyCon, tyConArity, AlgTyConRhs(..),
+ SynTyConRhs(..), newTyConRhs, AlgTyConParent(..) )
import Type ( mkArrowKinds, liftedTypeKind, typeKind,
tyVarsOfType, tyVarsOfTypes, tyVarsOfPred,
- splitTyConApp_maybe, splitAppTy_maybe, getTyVar_maybe,
- mkPredTys, mkTyVarTys, ThetaType, Type,
+ splitTyConApp_maybe, splitAppTy_maybe,
+ getTyVar_maybe,
+ mkPredTys, mkTyVarTys, ThetaType, Type, Kind,
+ TyThing(..),
substTyWith, zipTopTvSubst, substTheta, mkForAllTys,
mkTyConApp, mkTyVarTy )
-import Coercion ( mkNewTypeCoercion )
+import Coercion ( mkNewTypeCoercion, mkDataInstCoercion )
import Outputable
import List ( nub )
\begin{code}
------------------------------------------------------
-buildSynTyCon name tvs rhs_ty
- = mkSynTyCon name kind tvs rhs_ty
+buildSynTyCon :: Name -> [TyVar] -> SynTyConRhs -> TyCon
+buildSynTyCon name tvs rhs@(OpenSynTyCon rhs_ki)
+ = mkSynTyCon name kind tvs rhs
+ where
+ kind = mkArrowKinds (map tyVarKind tvs) rhs_ki
+buildSynTyCon name tvs rhs@(SynonymTyCon rhs_ty)
+ = mkSynTyCon name kind tvs rhs
where
kind = mkArrowKinds (map tyVarKind tvs) (typeKind rhs_ty)
-> RecFlag
-> Bool -- True <=> want generics functions
-> Bool -- True <=> was declared in GADT syntax
+ -> Maybe (TyCon, [Type],
+ Int) -- Just (family, tys, index)
+ -- <=> instance of `family' at `tys'
-> TcRnIf m n TyCon
buildAlgTyCon tc_name tvs stupid_theta rhs is_rec want_generics gadt_syn
- = do { let { tycon = mkAlgTyCon tc_name kind tvs stupid_theta
- rhs fields is_rec want_generics gadt_syn
- ; kind = mkArrowKinds (map tyVarKind tvs) liftedTypeKind
- ; fields = mkTyConSelIds tycon rhs
- }
- ; return tycon }
+ mb_family
+ = do { -- We need to tie a knot as the coercion of a data instance depends
+ -- on the instance representation tycon and vice versa.
+ ; tycon <- fixM (\ tycon_rec -> do
+ { (final_name, parent) <- maybeComputeFamilyInfo mb_family tycon_rec
+ ; let { tycon = mkAlgTyCon final_name kind tvs stupid_theta rhs
+ fields parent is_rec want_generics gadt_syn
+ ; kind = mkArrowKinds (map tyVarKind tvs) liftedTypeKind
+ ; fields = mkTyConSelIds tycon rhs
+ }
+ ; return tycon
+ })
+ ; return tycon
+ }
+ where
+ -- If a family tycon with instance types is given, the current tycon is an
+ -- instance of that family and we have to perform three extra tasks:
+ --
+ -- (1) The instance tycon (representing the family at a particular type
+ -- instance) need to get a new, derived name - we may not reuse the
+ -- family name.
+ -- (2) Create a coercion that identifies the family instance type and the
+ -- representation type from Step (1); ie, it is of the form
+ -- `Co tvs :: F ts :=: R tvs', where `Co' is the name of the coercion,
+ -- `F' the family tycon and `R' the (derived) representation tycon.
+ -- (3) Produce a `AlgTyConParent' value containing the parent and coercion
+ -- information.
+ --
+ maybeComputeFamilyInfo Nothing rep_tycon =
+ return (tc_name, NoParentTyCon)
+ maybeComputeFamilyInfo (Just (family, instTys, index)) rep_tycon =
+ do { -- (1) New, derived name for the instance tycon
+ ; final_name <- newImplicitBinder tc_name (mkInstTyTcOcc index)
+
+ -- (2) Create the coercion.
+ ; co_tycon_name <- newImplicitBinder tc_name (mkInstTyCoOcc index)
+ ; let co_tycon = mkDataInstCoercion co_tycon_name tvs
+ family instTys rep_tycon
+
+ -- (3) Produce parent information.
+ ; return (final_name, FamilyTyCon family instTys co_tycon index)
+ }
+
------------------------------------------------------
mkAbstractTyConRhs :: AlgTyConRhs
mkAbstractTyConRhs = AbstractTyCon
+mkOpenDataTyConRhs :: AlgTyConRhs
+mkOpenDataTyConRhs = OpenDataTyCon
+
+mkOpenNewTyConRhs :: AlgTyConRhs
+mkOpenNewTyConRhs = OpenNewTyCon
+
mkDataTyConRhs :: [DataCon] -> AlgTyConRhs
mkDataTyConRhs cons
= DataTyCon { data_cons = cons, is_enum = all isNullarySrcDataCon cons }
data_con = mkDataCon src_name declared_infix
arg_stricts field_lbls
univ_tvs ex_tvs eq_spec ctxt
- arg_tys tycon stupid_ctxt dc_ids
+ arg_tys tycon
+ stupid_ctxt dc_ids
dc_ids = mkDataConIds wrap_name work_name data_con
; returnM data_con }
\begin{code}
buildClass :: Name -> [TyVar] -> ThetaType
-> [FunDep TyVar] -- Functional dependencies
+ -> [TyThing] -- Associated types
-> [(Name, DefMeth, Type)] -- Method info
-> RecFlag -- Info for type constructor
-> TcRnIf m n Class
-buildClass class_name tvs sc_theta fds sig_stuff tc_isrec
+buildClass class_name tvs sc_theta fds ats sig_stuff tc_isrec
= do { tycon_name <- newImplicitBinder class_name mkClassTyConOcc
; datacon_name <- newImplicitBinder class_name mkClassDataConOcc
-- The class name is the 'parent' for this datacon, not its tycon,
-- Because C has only one operation, it is represented by
-- a newtype, and it should be a *recursive* newtype.
-- [If we don't make it a recursive newtype, we'll expand the
- -- newtype like a synonym, but that will lead to an infinite type]
+ -- newtype like a synonym, but that will lead to an infinite
+ -- type]
+ ; atTyCons = [tycon | ATyCon tycon <- ats]
}
- ; return (mkClass class_name tvs fds
- sc_theta sc_sel_ids op_items
+ ; return (mkClass class_name tvs fds
+ sc_theta sc_sel_ids atTyCons op_items
tycon)
})}
\end{code}
projects / ghc-hetmet.git / blobdiff