module PprType(
pprKind, pprParendKind,
pprType, pprParendType,
- pprConstraint, pprTheta,
+ pprPred, pprTheta, pprClassPred,
pprTyVarBndr, pprTyVarBndrs,
-- Junk
-- friends:
-- (PprType can see all the representations it's trying to print)
-import Type ( Type(..), TyNote(..), Kind, ThetaType,
- splitDictTy_maybe,
+import TypeRep ( Type(..), TyNote(..), Kind, liftedTypeKind ) -- friend
+import Type ( PredType(..), ThetaType,
+ splitPredTy_maybe,
splitForAllTys, splitSigmaTy, splitRhoTy,
isDictTy, splitTyConApp_maybe, splitFunTy_maybe,
- boxedTypeKind
+ predRepTy, isUTyVar
)
-import Var ( TyVar, tyVarKind,
- tyVarName, setTyVarName
- )
-import VarEnv
-import TyCon ( TyCon, isPrimTyCon, isTupleTyCon, isUnboxedTupleTyCon,
+import Var ( TyVar, tyVarKind )
+import Class ( Class )
+import TyCon ( TyCon, isPrimTyCon, isTupleTyCon, tupleTyConBoxity,
maybeTyConSingleCon, isEnumerationTyCon,
- tyConArity, tyConUnique
+ tyConArity, tyConName
)
-import Class ( Class )
-- others:
+import CmdLineOpts ( opt_PprStyle_RawTypes )
import Maybes ( maybeToBool )
-import Name ( getOccString, NamedThing(..) )
+import Name ( getOccString, getOccName )
import Outputable
-import PprEnv
import Unique ( Uniquable(..) )
-import Unique -- quite a few *Keys
-import Util
+import BasicTypes ( tupleParens )
+import PrelNames -- quite a few *Keys
\end{code}
%************************************************************************
\begin{code}
pprType, pprParendType :: Type -> SDoc
-pprType ty = ppr_ty pprTyEnv tOP_PREC ty
-pprParendType ty = ppr_ty pprTyEnv tYCON_PREC ty
+pprType ty = ppr_ty tOP_PREC ty
+pprParendType ty = ppr_ty tYCON_PREC ty
pprKind, pprParendKind :: Kind -> SDoc
pprKind = pprType
pprParendKind = pprParendType
-pprConstraint :: Class -> [Type] -> SDoc
-pprConstraint clas tys = ppr clas <+> hsep (map (pprParendType) tys)
+pprPred :: PredType -> SDoc
+pprPred (ClassP clas tys) = pprClassPred clas tys
+pprPred (IParam n ty) = hsep [ptext SLIT("?") <> ppr n,
+ ptext SLIT("::"), ppr ty]
+
+pprClassPred :: Class -> [Type] -> SDoc
+pprClassPred clas tys = ppr clas <+> hsep (map pprParendType tys)
pprTheta :: ThetaType -> SDoc
-pprTheta theta = parens (hsep (punctuate comma (map ppr_dict theta)))
- where
- ppr_dict (c,tys) = pprConstraint c tys
+pprTheta theta = parens (hsep (punctuate comma (map pprPred theta)))
instance Outputable Type where
ppr ty = pprType ty
+
+instance Outputable PredType where
+ ppr = pprPred
\end{code}
\begin{code}
-tOP_PREC = (0 :: Int)
-fUN_PREC = (1 :: Int)
-tYCON_PREC = (2 :: Int)
+tOP_PREC = (0 :: Int) -- type in ParseIface.y
+fUN_PREC = (1 :: Int) -- btype in ParseIface.y
+tYCON_PREC = (2 :: Int) -- atype in ParseIface.y
maybeParen ctxt_prec inner_prec pretty
| ctxt_prec < inner_prec = pretty
\end{code}
\begin{code}
-ppr_ty :: PprEnv TyVar -> Int -> Type -> SDoc
-ppr_ty env ctxt_prec (TyVarTy tyvar)
- = pTyVarO env tyvar
+ppr_ty :: Int -> Type -> SDoc
+ppr_ty ctxt_prec (TyVarTy tyvar)
+ = ppr tyvar
-ppr_ty env ctxt_prec ty@(TyConApp tycon tys)
+ppr_ty ctxt_prec ty@(TyConApp tycon tys)
-- KIND CASE; it's of the form (Type x)
- | tycon_uniq == typeConKey && n_tys == 1
+ | tycon `hasKey` typeConKey && n_tys == 1
= -- For kinds, print (Type x) as just x if x is a
-- type constructor (must be Boxed, Unboxed, AnyBox)
-- Otherwise print as (Type x)
case ty1 of
- TyConApp bx [] -> ppr bx
+ TyConApp bx [] -> ppr (getOccName bx) -- Always unqualified
other -> maybeParen ctxt_prec tYCON_PREC
- (ppr tycon <+> tys_w_spaces)
-
+ (sep [ppr tycon, nest 4 tys_w_spaces])
+
+ -- USAGE CASE
+ | (tycon `hasKey` usOnceTyConKey || tycon `hasKey` usManyTyConKey) && n_tys == 0
+ = -- For usages (! and .), always print bare OccName, without pkg/mod/uniq
+ ppr (getOccName (tyConName tycon))
-- TUPLE CASE (boxed and unboxed)
| isTupleTyCon tycon
&& length tys == tyConArity tycon -- no magic if partially applied
- = parens tys_w_commas
-
- | isUnboxedTupleTyCon tycon
- && length tys == tyConArity tycon -- no magic if partially applied
- = parens (char '#' <+> tys_w_commas <+> char '#')
+ = tupleParens (tupleTyConBoxity tycon) tys_w_commas
-- LIST CASE
- | tycon_uniq == listTyConKey && n_tys == 1
- = brackets (ppr_ty env tOP_PREC ty1)
+ | tycon `hasKey` listTyConKey && n_tys == 1
+ = brackets (ppr_ty tOP_PREC ty1)
-- DICTIONARY CASE, prints {C a}
-- This means that instance decls come out looking right in interfaces
-- and that in turn means they get "gated" correctly when being slurped in
- | maybeToBool maybe_dict
- = braces (ppr_dict env tYCON_PREC ctys)
+ | maybeToBool maybe_pred
+ = braces (pprPred pred)
-- NO-ARGUMENT CASE (=> no parens)
| null tys
-- GENERAL CASE
| otherwise
- = maybeParen ctxt_prec tYCON_PREC (hsep [ppr tycon, tys_w_spaces])
+ = maybeParen ctxt_prec tYCON_PREC (sep [ppr tycon, nest 4 tys_w_spaces])
where
- tycon_uniq = tyConUnique tycon
n_tys = length tys
(ty1:_) = tys
- Just ctys = maybe_dict
- maybe_dict = splitDictTy_maybe ty -- Checks class and arity
- tys_w_commas = sep (punctuate comma (map (ppr_ty env tOP_PREC) tys))
- tys_w_spaces = hsep (map (ppr_ty env tYCON_PREC) tys)
+ Just pred = maybe_pred
+ maybe_pred = splitPredTy_maybe ty -- Checks class and arity
+ tys_w_commas = sep (punctuate comma (map (ppr_ty tOP_PREC) tys))
+ tys_w_spaces = sep (map (ppr_ty tYCON_PREC) tys)
-ppr_ty env ctxt_prec ty@(ForAllTy _ _)
+ppr_ty ctxt_prec ty@(ForAllTy _ _)
= getPprStyle $ \ sty ->
maybeParen ctxt_prec fUN_PREC $
- if ifaceStyle sty then
- sep [ ptext SLIT("__forall") <+> brackets pp_tyvars, pp_ctxt, pp_body ]
- else
- sep [ ptext SLIT("forall") <+> pp_tyvars <> ptext SLIT("."), pp_maybe_ctxt, pp_body ]
- where
- (tyvars, rho_ty) = splitForAllTys ty
- (theta, body_ty) = splitRhoTy rho_ty
+ sep [ ptext SLIT("forall") <+> pp_tyvars sty <> ptext SLIT("."),
+ ppr_theta theta,
+ ppr_ty tOP_PREC tau
+ ]
+ where
+ (tyvars, rho) = splitForAllTys ty
+ (theta, tau) = splitRhoTy rho
- pp_tyvars = hsep (map (pBndr env LambdaBind) tyvars)
- pp_body = ppr_ty env tOP_PREC body_ty
+ pp_tyvars sty = hsep (map pprTyVarBndr some_tyvars)
+ where
+ some_tyvars | userStyle sty && not opt_PprStyle_RawTypes
+ = filter (not . isUTyVar) tyvars -- hide uvars from user
+ | otherwise
+ = tyvars
- pp_maybe_ctxt | null theta = empty
- | otherwise = pp_ctxt
-
- pp_ctxt = ppr_theta env theta <+> ptext SLIT("=>")
+ ppr_theta [] = empty
+ ppr_theta theta = pprTheta theta <+> ptext SLIT("=>")
-ppr_ty env ctxt_prec (FunTy ty1 ty2)
- = maybeParen ctxt_prec fUN_PREC (sep (ppr_ty env fUN_PREC ty1 : pp_rest ty2))
+ppr_ty ctxt_prec (FunTy ty1 ty2)
-- we don't want to lose usage annotations or synonyms,
- -- so we can't use splitFunTys here.
- where
- pp_rest (FunTy ty1 ty2) = pp_codom ty1 : pp_rest ty2
- pp_rest ty = [pp_codom ty]
- pp_codom ty = ptext SLIT("->") <+> ppr_ty env fUN_PREC ty
+ -- so we mustn't use splitFunTys here.
+ = maybeParen ctxt_prec fUN_PREC $
+ sep [ ppr_ty fUN_PREC ty1
+ , ptext SLIT("->") <+> ppr_ty tOP_PREC ty2
+ ]
-ppr_ty env ctxt_prec (AppTy ty1 ty2)
+ppr_ty ctxt_prec (AppTy ty1 ty2)
= maybeParen ctxt_prec tYCON_PREC $
- ppr_ty env tOP_PREC ty1 <+> ppr_ty env tYCON_PREC ty2
+ ppr_ty fUN_PREC ty1 <+> ppr_ty tYCON_PREC ty2
-ppr_ty env ctxt_prec (NoteTy (SynNote ty) expansion)
- = ppr_ty env ctxt_prec ty
+ppr_ty ctxt_prec (UsageTy u ty)
+ = maybeParen ctxt_prec tYCON_PREC $
+ ptext SLIT("__u") <+> ppr_ty tYCON_PREC u
+ <+> ppr_ty tYCON_PREC ty
+ -- fUN_PREC would be logical for u, but it yields a reduce/reduce conflict with AppTy
-ppr_ty env ctxt_prec (NoteTy (FTVNote _) ty) = ppr_ty env ctxt_prec ty
+ppr_ty ctxt_prec (NoteTy (SynNote ty) expansion)
+ = ppr_ty ctxt_prec ty
+-- = ppr_ty ctxt_prec expansion -- if we don't want to see syntys
-ppr_theta env [] = empty
-ppr_theta env theta = braces (hsep (punctuate comma (map (ppr_dict env tOP_PREC) theta)))
+ppr_ty ctxt_prec (NoteTy (FTVNote _) ty) = ppr_ty ctxt_prec ty
-ppr_dict env ctxt (clas, tys) = ppr clas <+>
- hsep (map (ppr_ty env tYCON_PREC) tys)
+ppr_ty ctxt_prec (PredTy p) = braces (pprPred p)
\end{code}
-\begin{code}
-pprTyEnv = initPprEnv b b (Just ppr) b (Just (\site -> pprTyVarBndr)) b
- where
- b = panic "PprType:init_ppr_env"
-\end{code}
%************************************************************************
%* *
and when in debug mode.
\begin{code}
+pprTyVarBndr :: TyVar -> SDoc
pprTyVarBndr tyvar
= getPprStyle $ \ sty ->
- if (ifaceStyle sty || debugStyle sty) && kind /= boxedTypeKind then
+ if (ifaceStyle sty && kind /= liftedTypeKind) || debugStyle sty then
hsep [ppr tyvar, dcolon, pprParendKind kind]
-- See comments with ppDcolon in PprCore.lhs
else
TyConApp tycon _ -> getOccString tycon
NoteTy (FTVNote _) ty -> getTyDescription ty
NoteTy (SynNote ty1) _ -> getTyDescription ty1
+ PredTy p -> getTyDescription (predRepTy p)
ForAllTy _ ty -> getTyDescription ty
}
where
projects / ghc-hetmet.git / blobdiff