module PprType(
pprKind, pprParendKind,
pprType, pprParendType,
- pprConstraint, pprTheta,
+ pprConstraint, pprPred, pprTheta,
pprTyVarBndr, pprTyVarBndrs,
-- Junk
-- friends:
-- (PprType can see all the representations it's trying to print)
-import Type ( Type(..), TyNote(..), Kind, ThetaType,
- splitFunTys, splitDictTy_maybe,
+import TypeRep ( Type(..), TyNote(..), Kind, UsageAnn(..),
+ boxedTypeKind,
+ ) -- friend
+import Type ( PredType(..), ThetaType,
+ splitPredTy_maybe,
splitForAllTys, splitSigmaTy, splitRhoTy,
isDictTy, splitTyConApp_maybe, splitFunTy_maybe,
- boxedTypeKind
+ splitUsForAllTys
)
import Var ( TyVar, tyVarKind,
tyVarName, setTyVarName
maybeTyConSingleCon, isEnumerationTyCon,
tyConArity, tyConUnique
)
-import Class ( Class )
+import Class ( Class, className )
-- others:
import Maybes ( maybeToBool )
pprKind = pprType
pprParendKind = pprParendType
+pprPred :: PredType -> SDoc
+pprPred (Class clas tys) = pprConstraint clas tys
+pprPred (IParam n ty) = hsep [ppr n, ptext SLIT("::"), ppr ty]
+
pprConstraint :: Class -> [Type] -> SDoc
pprConstraint 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
case ty1 of
TyConApp bx [] -> ppr bx
other -> maybeParen ctxt_prec tYCON_PREC
- (ppr tycon <+> tys_w_spaces)
+ (sep [ppr tycon, nest 4 tys_w_spaces])
-- TUPLE CASE (boxed and unboxed)
-- 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 (ppr_pred env 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
+ Just pred = maybe_pred
+ maybe_pred = splitPredTy_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)
+ tys_w_spaces = sep (map (ppr_ty env tYCON_PREC) tys)
= getPprStyle $ \ sty ->
maybeParen ctxt_prec fUN_PREC $
if ifaceStyle sty then
- sep [ ptext SLIT("__forall") <+> brackets pp_tyvars, pp_ctxt, pp_body ]
+ sep [ ptext SLIT("__forall") <+> brackets pp_tyvars <+> ptext SLIT("=>"),
+ ppr_ty env tOP_PREC rho
+ ]
else
- sep [ ptext SLIT("forall") <+> pp_tyvars <> ptext SLIT("."), pp_maybe_ctxt, pp_body ]
+ -- The type checker occasionally prints a type in an error message,
+ -- and it had better come out looking like a user type
+ sep [ ptext SLIT("forall") <+> pp_tyvars <> ptext SLIT("."),
+ ppr_theta theta,
+ ppr_ty env tOP_PREC tau
+ ]
where
- (tyvars, rho_ty) = splitForAllTys ty
- (theta, body_ty) = splitRhoTy rho_ty
+ (tyvars, rho) = splitForAllTys ty -- don't treat theta specially any more (KSW 1999-04)
+ (theta, tau) = splitRhoTy rho
pp_tyvars = hsep (map (pBndr env LambdaBind) tyvars)
- pp_body = ppr_ty env tOP_PREC body_ty
- pp_maybe_ctxt | null theta = empty
- | otherwise = pp_ctxt
-
- pp_ctxt = ppr_theta env theta <+> ptext SLIT("=>")
+ ppr_theta [] = empty
+ ppr_theta theta = parens (hsep (punctuate comma (map ppr_pred theta)))
+ <+> ptext SLIT("=>")
+ ppr_pred (Class clas tys) = ppr clas <+> hsep (map (ppr_ty env tYCON_PREC) tys)
+ ppr_pred (IParam n ty) = hsep [{- char '?' <> -} ppr n, text "::",
+ ppr_ty env tYCON_PREC ty]
ppr_ty env ctxt_prec (FunTy ty1 ty2)
- -- We fiddle the precedences passed to left/right branches,
- -- so that right associativity comes out nicely...
- = maybeParen ctxt_prec fUN_PREC (sep (ppr_ty env fUN_PREC ty1 : pp_rest))
+ = maybeParen ctxt_prec fUN_PREC (sep (ppr_ty env fUN_PREC ty1 : pp_rest ty2))
+ -- we don't want to lose usage annotations or synonyms,
+ -- so we mustn't use splitFunTys here.
where
- (arg_tys, result_ty) = splitFunTys ty2
- pp_rest = [ ptext SLIT("-> ") <> ppr_ty env fUN_PREC ty | ty <- arg_tys ++ [result_ty] ]
+ 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
ppr_ty env ctxt_prec (AppTy ty1 ty2)
= maybeParen ctxt_prec tYCON_PREC $
ppr_ty env ctxt_prec (NoteTy (SynNote ty) expansion)
= ppr_ty env ctxt_prec ty
+-- = ppr_ty env ctxt_prec expansion -- if we don't want to see syntys
ppr_ty env ctxt_prec (NoteTy (FTVNote _) ty) = ppr_ty env ctxt_prec ty
+ppr_ty env ctxt_prec ty@(NoteTy (UsgForAll _) _)
+ = maybeParen ctxt_prec fUN_PREC $
+ sep [ ptext SLIT("__fuall") <+> brackets pp_uvars <+> ptext SLIT("=>"),
+ ppr_ty env tOP_PREC sigma
+ ]
+ where
+ (uvars,sigma) = splitUsForAllTys ty
+ pp_uvars = hsep (map ppr uvars)
+
+ppr_ty env ctxt_prec (NoteTy (UsgNote u) ty)
+ = maybeParen ctxt_prec tYCON_PREC $
+ ptext SLIT("__u") <+> ppr u <+> ppr_ty env tYCON_PREC ty
+
+ppr_ty env ctxt_prec (NoteTy (IPNote nm) ty)
+ = braces (ppr_pred env (IParam nm ty))
+
ppr_theta env [] = empty
-ppr_theta env theta = braces (hsep (punctuate comma (map (ppr_dict env tOP_PREC) theta)))
+ppr_theta env theta = braces (hsep (punctuate comma (map (ppr_pred env) theta)))
+ppr_pred env (Class clas tys) = ppr clas <+>
+ hsep (map (ppr_ty env tYCON_PREC) tys)
+ppr_pred env (IParam n ty) = hsep [char '?' <> ppr n, text "::",
+ ppr_ty env tYCON_PREC ty]
+
+{-
ppr_dict env ctxt (clas, tys) = ppr clas <+>
hsep (map (ppr_ty env tYCON_PREC) tys)
+-}
\end{code}
\begin{code}
-pprTyEnv = initPprEnv b b (Just ppr) b (Just (\site -> pprTyVarBndr)) b
+pprTyEnv = initPprEnv b (Just ppr) b (Just (\site -> pprTyVarBndr)) b
where
b = panic "PprType:init_ppr_env"
\end{code}
+\begin{code}
+instance Outputable UsageAnn where
+ ppr UsOnce = ptext SLIT("-")
+ ppr UsMany = ptext SLIT("!")
+ ppr (UsVar uv) = ppr uv
+\end{code}
+
+
%************************************************************************
%* *
\subsection[TyVar]{@TyVar@}
TyConApp tycon _ -> getOccString tycon
NoteTy (FTVNote _) ty -> getTyDescription ty
NoteTy (SynNote ty1) _ -> getTyDescription ty1
+ NoteTy (UsgNote _) ty -> getTyDescription ty
ForAllTy _ ty -> getTyDescription ty
}
where
projects / ghc-hetmet.git / blobdiff