%
+% (c) The University of Glasgow 2006
% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
module BuildTyCl (
buildSynTyCon, buildAlgTyCon, buildDataCon,
buildClass,
- mkAbstractTyConRhs, mkOpenDataTyConRhs, mkOpenNewTyConRhs,
+ mkAbstractTyConRhs, mkOpenDataTyConRhs,
mkNewTyConRhs, mkDataTyConRhs
) where
#include "HsVersions.h"
-import IfaceEnv ( newImplicitBinder )
+import IfaceEnv
import TcRnMonad
-import DataCon ( DataCon, isNullarySrcDataCon, dataConUnivTyVars,
- mkDataCon, dataConFieldLabels, dataConInstOrigArgTys,
- dataConTyCon )
-import Var ( tyVarKind, TyVar, Id )
-import VarSet ( isEmptyVarSet, intersectVarSet, elemVarSet )
-import TysWiredIn ( unitTy )
-import BasicTypes ( RecFlag, StrictnessMark(..) )
-import Name ( Name )
-import OccName ( mkDataConWrapperOcc, mkDataConWorkerOcc,
- mkClassTyConOcc, mkClassDataConOcc,
- mkSuperDictSelOcc, mkNewTyCoOcc, mkLocalOcc )
-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(..),
- SynTyConRhs(..), newTyConRhs, AlgTyConParent(..) )
-import Type ( mkArrowKinds, liftedTypeKind, typeKind,
- tyVarsOfType, tyVarsOfTypes, tyVarsOfPred,
- splitTyConApp_maybe, splitAppTy_maybe,
- getTyVar_maybe,
- mkPredTys, mkTyVarTys, ThetaType, Type, Kind,
- TyThing(..),
- substTyWith, zipTopTvSubst, substTheta, mkForAllTys,
- mkTyConApp, mkTyVarTy )
-import Coercion ( mkNewTypeCoercion )
-import Outputable
-import List ( nub )
-
+import DataCon
+import Var
+import VarSet
+import TysWiredIn
+import BasicTypes
+import Name
+import OccName
+import MkId
+import Class
+import TyCon
+import Type
+import Coercion
+
+import Data.List
\end{code}
\begin{code}
------------------------------------------------------
-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)
-
+buildSynTyCon :: Name -> [TyVar]
+ -> SynTyConRhs
+ -> Maybe (TyCon, [Type]) -- family instance if applicable
+ -> TcRnIf m n TyCon
+
+buildSynTyCon tc_name tvs rhs@(OpenSynTyCon rhs_ki _) _
+ = let
+ kind = mkArrowKinds (map tyVarKind tvs) rhs_ki
+ in
+ return $ mkSynTyCon tc_name kind tvs rhs NoParentTyCon
+
+buildSynTyCon tc_name tvs rhs@(SynonymTyCon rhs_ty) 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
+ { parent <- mkParentInfo mb_family tc_name tvs tycon_rec
+ ; let { tycon = mkSynTyCon tc_name kind tvs rhs parent
+ ; kind = mkArrowKinds (map tyVarKind tvs) (typeKind rhs_ty)
+ }
+ ; return tycon
+ })
+ ; return tycon
+ }
------------------------------------------------------
buildAlgTyCon :: Name -> [TyVar]
-> RecFlag
-> Bool -- True <=> want generics functions
-> Bool -- True <=> was declared in GADT syntax
- -> Maybe TyCon -- Just family <=> instance of `family'
+ -> Maybe (TyCon, [Type]) -- family instance if applicable
-> TcRnIf m n TyCon
buildAlgTyCon tc_name tvs stupid_theta rhs is_rec want_generics gadt_syn
mb_family
- = do { -- In case of a type instance, we need to invent a new name for the
- -- instance type, as `tc_name' is the family name.
- ; uniq <- newUnique
- ; (final_name, parent) <-
- case mb_family of
- Nothing -> return (tc_name, NoParentTyCon)
- Just family ->
- do { final_name <- newImplicitBinder tc_name (mkLocalOcc uniq)
- ; return (final_name, FamilyTyCon family)
- }
- ; 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 }
-
+ = 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
+ { parent <- mkParentInfo mb_family tc_name tvs tycon_rec
+ ; let { tycon = mkAlgTyCon tc_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
+ }
+
+-- If a family tycon with instance types is given, the current tycon is an
+-- instance of that family and we need to
+--
+-- (1) 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,
+-- and
+-- (2) produce a `TyConParent' value containing the parent and coercion
+-- information.
+--
+mkParentInfo :: Maybe (TyCon, [Type])
+ -> Name -> [TyVar]
+ -> TyCon
+ -> TcRnIf m n TyConParent
+mkParentInfo Nothing _ _ _ =
+ return NoParentTyCon
+mkParentInfo (Just (family, instTys)) tc_name tvs rep_tycon =
+ do { -- Create the coercion
+ ; co_tycon_name <- newImplicitBinder tc_name mkInstTyCoOcc
+ ; let co_tycon = mkFamInstCoercion co_tycon_name tvs
+ family instTys rep_tycon
+ ; return $ FamilyTyCon family instTys co_tycon
+ }
+
------------------------------------------------------
mkAbstractTyConRhs :: AlgTyConRhs
mkAbstractTyConRhs = AbstractTyCon
mkOpenDataTyConRhs :: AlgTyConRhs
-mkOpenDataTyConRhs = OpenDataTyCon
-
-mkOpenNewTyConRhs :: AlgTyConRhs
-mkOpenNewTyConRhs = OpenNewTyCon
+mkOpenDataTyConRhs = OpenTyCon Nothing
mkDataTyConRhs :: [DataCon] -> AlgTyConRhs
mkDataTyConRhs cons
-- because the latter is part of a knot, whereas the former is not.
mkNewTyConRhs tycon_name tycon con
= do { co_tycon_name <- newImplicitBinder tycon_name mkNewTyCoOcc
- ; let co_tycon = mkNewTypeCoercion co_tycon_name tycon tvs rhs_ty
- cocon_maybe
- | all_coercions || isRecursiveTyCon tycon
- = Just co_tycon
- | otherwise
- = Nothing
- ; return (NewTyCon { data_con = con,
- nt_co = cocon_maybe,
+ ; let co_tycon = mkNewTypeCoercion co_tycon_name tycon etad_tvs etad_rhs
+ cocon_maybe | all_coercions || isRecursiveTyCon tycon
+ = Just co_tycon
+ | otherwise
+ = Nothing
+ ; return (NewTyCon { data_con = con,
+ nt_rhs = rhs_ty,
+ nt_etad_rhs = (etad_tvs, etad_rhs),
+ nt_co = cocon_maybe,
-- Coreview looks through newtypes with a Nothing
-- for nt_co, or uses explicit coercions otherwise
- nt_rhs = rhs_ty,
- nt_etad_rhs = eta_reduce tvs rhs_ty,
nt_rep = mkNewTyConRep tycon rhs_ty }) }
where
- -- if all_coercions is True then we use coercions for all newtypes
+ -- If all_coercions is True then we use coercions for all newtypes
-- otherwise we use coercions for recursive newtypes and look through
-- non-recursive newtypes
all_coercions = True
rhs_ty = head (dataConInstOrigArgTys con (mkTyVarTys tvs))
-- Instantiate the data con with the
-- type variables from the tycon
-
- eta_reduce [] ty = ([], ty)
- eta_reduce (a:as) ty | null as',
- Just (fun, arg) <- splitAppTy_maybe ty',
+ -- NB: a newtype DataCon has no existentials; hence the
+ -- call to dataConInstOrigArgTys has the right type args
+
+ etad_tvs :: [TyVar] -- Matched lazily, so that mkNewTypeCoercion can
+ etad_rhs :: Type -- return a TyCon without pulling on rhs_ty
+ -- See Note [Tricky iface loop] in LoadIface
+ (etad_tvs, etad_rhs) = eta_reduce (reverse tvs) rhs_ty
+
+ eta_reduce :: [TyVar] -- Reversed
+ -> Type -- Rhs type
+ -> ([TyVar], Type) -- Eta-reduced version (tyvars in normal order)
+ eta_reduce (a:as) ty | Just (fun, arg) <- splitAppTy_maybe ty,
Just tv <- getTyVar_maybe arg,
tv == a,
not (a `elemVarSet` tyVarsOfType fun)
- = ([], fun) -- Successful eta reduction
- | otherwise
- = (a:as', ty')
- where
- (as', ty') = eta_reduce as ty
+ = eta_reduce as fun
+ eta_reduce tvs ty = (reverse tvs, ty)
+
mkNewTyConRep :: TyCon -- The original type constructor
-> Type -- The arg type of its constructor
-> Type -- Chosen representation type
-> ThetaType -- Does not include the "stupid theta"
-- or the GADT equalities
-> [Type] -> TyCon
- -> Maybe [Type] -- Just ts <=> type pats of inst type
-> TcRnIf m n DataCon
-- A wrapper for DataCon.mkDataCon that
-- a) makes the worker Id
-- b) makes the wrapper Id if necessary, including
-- allocating its unique (hence monadic)
buildDataCon src_name declared_infix arg_stricts field_lbls
- univ_tvs ex_tvs eq_spec ctxt arg_tys tycon mb_typats
+ univ_tvs ex_tvs eq_spec ctxt arg_tys tycon
= do { wrap_name <- newImplicitBinder src_name mkDataConWrapperOcc
; work_name <- newImplicitBinder src_name mkDataConWorkerOcc
-- This last one takes the name of the data constructor in the source
data_con = mkDataCon src_name declared_infix
arg_stricts field_lbls
univ_tvs ex_tvs eq_spec ctxt
- arg_tys tycon mb_typats
+ arg_tys tycon
stupid_ctxt dc_ids
dc_ids = mkDataConIds wrap_name work_name data_con
tvs [{- no existentials -}]
[{- No equalities -}] [{-No context-}]
dict_component_tys
- rec_tycon Nothing
+ rec_tycon
; rhs <- case dict_component_tys of
[rep_ty] -> mkNewTyConRhs tycon_name rec_tycon dict_con
; let { clas_kind = mkArrowKinds (map tyVarKind tvs) liftedTypeKind
; tycon = mkClassTyCon tycon_name clas_kind tvs
- rhs rec_clas tc_isrec
+ rhs rec_clas tc_isrec
-- A class can be recursive, and in the case of newtypes
-- this matters. For example
-- class C a where { op :: C b => a -> b -> Int }