\begin{code}
module BuildTyCl (
- buildSynTyCon, buildAlgTyCon, buildDataCon,
- buildClass,
- mkAbstractTyConRhs, mkOpenDataTyConRhs,
- mkNewTyConRhs, mkDataTyConRhs, setAssocFamilyPermutation
+ buildSynTyCon,
+ buildAlgTyCon,
+ buildDataCon,
+ TcMethInfo, buildClass,
+ mkAbstractTyConRhs,
+ mkNewTyConRhs, mkDataTyConRhs,
+ newImplicitBinder
) where
#include "HsVersions.h"
import Coercion
import TcRnMonad
-import Util ( count )
+import Data.List ( partition )
import Outputable
\end{code}
\begin{code}
------------------------------------------------------
buildSynTyCon :: Name -> [TyVar]
- -> SynTyConRhs
- -> Kind -- Kind of the RHS
- -> Maybe (TyCon, [Type]) -- family instance if applicable
+ -> SynTyConRhs
+ -> Kind -- ^ Kind of the RHS
+ -> TyConParent
+ -> Maybe (TyCon, [Type]) -- ^ family instance if applicable
-> TcRnIf m n TyCon
-
-buildSynTyCon tc_name tvs rhs@(OpenSynTyCon {}) rhs_kind _
- = let
- kind = mkArrowKinds (map tyVarKind tvs) rhs_kind
- in
- return $ mkSynTyCon tc_name kind tvs rhs NoParentTyCon
-
-buildSynTyCon tc_name tvs rhs@(SynonymTyCon {}) rhs_kind 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) rhs_kind
- }
- ; return tycon
- })
- ; return tycon
- }
+buildSynTyCon tc_name tvs rhs rhs_kind parent mb_family
+ | Just fam_inst_info <- mb_family
+ = ASSERT( isNoParent parent )
+ fixM $ \ tycon_rec -> do
+ { fam_parent <- mkFamInstParentInfo tc_name tvs fam_inst_info tycon_rec
+ ; return (mkSynTyCon tc_name kind tvs rhs fam_parent) }
+
+ | otherwise
+ = return (mkSynTyCon tc_name kind tvs rhs parent)
+ where
+ kind = mkArrowKinds (map tyVarKind tvs) rhs_kind
------------------------------------------------------
buildAlgTyCon :: Name -> [TyVar]
- -> ThetaType -- Stupid theta
+ -> ThetaType -- ^ Stupid theta
-> AlgTyConRhs
-> RecFlag
- -> Bool -- True <=> want generics functions
- -> Bool -- True <=> was declared in GADT syntax
- -> Maybe (TyCon, [Type]) -- family instance if applicable
+ -> Bool -- ^ True <=> was declared in GADT syntax
+ -> TyConParent
+ -> 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 { -- 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
- parent is_rec want_generics gadt_syn
- ; kind = mkArrowKinds (map tyVarKind tvs) liftedTypeKind
- }
- ; return tycon
- })
- ; return tycon
- }
-
--- If a family tycon with instance types is given, the current tycon is an
+buildAlgTyCon tc_name tvs stupid_theta rhs is_rec gadt_syn
+ parent mb_family
+ | Just fam_inst_info <- mb_family
+ = -- We need to tie a knot as the coercion of a data instance depends
+ -- on the instance representation tycon and vice versa.
+ ASSERT( isNoParent parent )
+ fixM $ \ tycon_rec -> do
+ { fam_parent <- mkFamInstParentInfo tc_name tvs fam_inst_info tycon_rec
+ ; return (mkAlgTyCon tc_name kind tvs stupid_theta rhs
+ fam_parent is_rec gadt_syn) }
+
+ | otherwise
+ = return (mkAlgTyCon tc_name kind tvs stupid_theta rhs
+ parent is_rec gadt_syn)
+ where
+ kind = mkArrowKinds (map tyVarKind tvs) liftedTypeKind
+
+-- | 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
-- (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
- }
+mkFamInstParentInfo :: Name -> [TyVar]
+ -> (TyCon, [Type])
+ -> TyCon
+ -> TcRnIf m n TyConParent
+mkFamInstParentInfo tc_name tvs (family, instTys) rep_tycon
+ = do { -- Create the coercion
+ ; co_tycon_name <- newImplicitBinder tc_name mkInstTyCoOcc
+ ; let co_tycon = mkFamInstCo co_tycon_name tvs
+ family instTys rep_tycon
+ ; return $ FamInstTyCon family instTys co_tycon }
------------------------------------------------------
mkAbstractTyConRhs :: AlgTyConRhs
mkAbstractTyConRhs = AbstractTyCon
-mkOpenDataTyConRhs :: AlgTyConRhs
-mkOpenDataTyConRhs = OpenTyCon Nothing
-
mkDataTyConRhs :: [DataCon] -> AlgTyConRhs
mkDataTyConRhs cons
= DataTyCon {
data_cons = cons,
- is_enum = -- We define datatypes with no constructors to not be
- -- enumerations; this fixes trac #2578
- not (null cons) &&
- all isNullarySrcDataCon cons
+ is_enum = not (null cons) && all is_enum_con cons
+ -- See Note [Enumeration types] in TyCon
}
+ where
+ is_enum_con con
+ | (_tvs, theta, arg_tys, _res) <- dataConSig con
+ = null theta && null arg_tys
+
mkNewTyConRhs :: Name -> TyCon -> DataCon -> TcRnIf m n AlgTyConRhs
--- Monadic because it makes a Name for the coercion TyCon
--- We pass the Name of the parent TyCon, as well as the TyCon itself,
--- because the latter is part of a knot, whereas the former is not.
+-- ^ Monadic because it makes a Name for the coercion TyCon
+-- We pass the Name of the parent TyCon, as well as the TyCon itself,
+-- 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 etad_tvs etad_rhs
- cocon_maybe | all_coercions || isRecursiveTyCon tycon
- = Just co_tycon
- | otherwise
- = Nothing
- ; traceIf (text "mkNewTyConRhs" <+> ppr cocon_maybe)
+ ; let co_tycon = mkNewTypeCo co_tycon_name tycon etad_tvs etad_rhs
+ ; traceIf (text "mkNewTyConRhs" <+> ppr co_tycon)
; return (NewTyCon { data_con = con,
nt_rhs = rhs_ty,
nt_etad_rhs = (etad_tvs, etad_rhs),
- nt_co = cocon_maybe } ) }
+ nt_co = co_tycon } ) }
-- Coreview looks through newtypes with a Nothing
-- for nt_co, or uses explicit coercions otherwise
where
- -- 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
tvs = tyConTyVars tycon
inst_con_ty = applyTys (dataConUserType con) (mkTyVarTys tvs)
rhs_ty = ASSERT( isFunTy inst_con_ty ) funArgTy inst_con_ty
-- has a single argument (Foo a) that is a *type class*, so
-- dataConInstOrigArgTys returns [].
- etad_tvs :: [TyVar] -- Matched lazily, so that mkNewTypeCoercion can
+ etad_tvs :: [TyVar] -- Matched lazily, so that mkNewTypeCo 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 tvs ty = (reverse tvs, ty)
-setAssocFamilyPermutation :: [TyVar] -> TyThing -> TyThing
-setAssocFamilyPermutation clas_tvs (ATyCon tc)
- = ATyCon (setTyConArgPoss clas_tvs tc)
-setAssocFamilyPermutation _clas_tvs other
- = pprPanic "setAssocFamilyPermutation" (ppr other)
-
-
------------------------------------------------------
buildDataCon :: Name -> Bool
- -> [StrictnessMark]
+ -> [HsBang]
-> [Name] -- Field labels
-> [TyVar] -> [TyVar] -- Univ and ext
-> [(TyVar,Type)] -- Equality spec
------------------------------------------------------
\begin{code}
-buildClass :: Bool -- True <=> do not include unfoldings
- -- on dict selectors
- -- Used when importing a class without -O
+type TcMethInfo = (Name, DefMethSpec, Type)
+ -- A temporary intermediate, to communicate between
+ -- tcClassSigs and buildClass.
+
+buildClass :: Bool -- True <=> do not include unfoldings
+ -- on dict selectors
+ -- Used when importing a class without -O
-> Name -> [TyVar] -> ThetaType
- -> [FunDep TyVar] -- Functional dependencies
- -> [TyThing] -- Associated types
- -> [(Name, DefMeth, Type)] -- Method info
- -> RecFlag -- Info for type constructor
+ -> [FunDep TyVar] -- Functional dependencies
+ -> [TyThing] -- Associated types
+ -> [TcMethInfo] -- Method info
+ -> RecFlag -- Info for type constructor
-> TcRnIf m n Class
buildClass no_unf class_name tvs sc_theta fds ats sig_stuff tc_isrec
; fixM (\ rec_clas -> do { -- Only name generation inside loop
- let { rec_tycon = classTyCon rec_clas
- ; op_tys = [ty | (_,_,ty) <- sig_stuff]
- ; op_names = [op | (op,_,_) <- sig_stuff]
- ; op_items = [ (mkDictSelId no_unf op_name rec_clas, dm_info)
- | (op_name, dm_info, _) <- sig_stuff ] }
+ ; op_items <- mapM (mk_op_item rec_clas) sig_stuff
-- Build the selector id and default method id
- ; let n_value_preds = count (not . isEqPred) sc_theta
- all_value_preds = n_value_preds == length sc_theta
+ ; let (eq_theta, dict_theta) = partition isEqPred sc_theta
+
-- We only make selectors for the *value* superclasses,
-- not equality predicates
-
; sc_sel_names <- mapM (newImplicitBinder class_name . mkSuperDictSelOcc)
- [1..n_value_preds]
- ; let sc_sel_ids = [mkDictSelId no_unf sc_name rec_clas | sc_name <- sc_sel_names]
+ [1..length dict_theta]
+ ; let sc_sel_ids = [ mkDictSelId no_unf sc_name rec_clas
+ | sc_name <- sc_sel_names]
-- We number off the Dict superclass selectors, 1, 2, 3 etc so that we
-- can construct names for the selectors. Thus
-- class (C a, C b) => D a b where ...
-- D_sc1, D_sc2
-- (We used to call them D_C, but now we can have two different
-- superclasses both called C!)
- --
- ; let use_newtype = (n_value_preds + length sig_stuff == 1) && all_value_preds
+ ; let use_newtype = null eq_theta && (length dict_theta + length sig_stuff == 1)
-- Use a newtype if the data constructor has
-- (a) exactly one value field
-- (b) no existential or equality-predicate fields
-- i.e. exactly one operation or superclass taken together
-- See note [Class newtypes and equality predicates]
- -- We play a bit fast and loose by treating the superclasses
- -- as ordinary arguments. That means that in the case of
+ -- We play a bit fast and loose by treating the dictionary
+ -- superclasses as ordinary arguments. That means that in
+ -- the case of
-- class C a => D a
-- we don't get a newtype with no arguments!
- args = sc_sel_names ++ op_names
- arg_tys = map mkPredTy sc_theta ++ op_tys
-
+ args = sc_sel_names ++ op_names
+ op_tys = [ty | (_,_,ty) <- sig_stuff]
+ op_names = [op | (op,_,_) <- sig_stuff]
+ arg_tys = map mkPredTy dict_theta ++ op_tys
+ rec_tycon = classTyCon rec_clas
+
; dict_con <- buildDataCon datacon_name
False -- Not declared infix
- (map (const NotMarkedStrict) args)
+ (map (const HsNoBang) args)
[{- No fields -}]
tvs [{- no existentials -}]
- [{- No GADT equalities -}] [{- No theta -}]
+ [{- No GADT equalities -}]
+ eq_theta
arg_tys
(mkTyConApp rec_tycon (mkTyVarTys tvs))
rec_tycon
; atTyCons = [tycon | ATyCon tycon <- ats]
; result = mkClass class_name tvs fds
- sc_theta sc_sel_ids atTyCons
+ (eq_theta ++ dict_theta) -- Equalities first
+ (length eq_theta) -- Number of equalities
+ sc_sel_ids atTyCons
op_items tycon
}
; traceIf (text "buildClass" <+> ppr tycon)
; return result
})}
+ where
+ mk_op_item :: Class -> TcMethInfo -> TcRnIf n m ClassOpItem
+ mk_op_item rec_clas (op_name, dm_spec, _)
+ = do { dm_info <- case dm_spec of
+ NoDM -> return NoDefMeth
+ GenericDM -> do { dm_name <- newImplicitBinder op_name mkGenDefMethodOcc
+ ; return (GenDefMeth dm_name) }
+ VanillaDM -> do { dm_name <- newImplicitBinder op_name mkDefaultMethodOcc
+ ; return (DefMeth dm_name) }
+ ; return (mkDictSelId no_unf op_name rec_clas, dm_info) }
\end{code}
Note [Class newtypes and equality predicates]
projects / ghc-hetmet.git / blobdiff