module PprType(
pprKind, pprParendKind,
pprType, pprParendType,
- pprConstraint, pprTheta,
+ pprConstraint, pprPred, pprTheta,
pprTyVarBndr, pprTyVarBndrs,
- getTyDescription,
-
- nmbrType, nmbrGlobalType
+ -- Junk
+ getTyDescription, showTypeCategory
) where
#include "HsVersions.h"
-- friends:
-- (PprType can see all the representations it's trying to print)
-import Type ( GenType(..), TyNote(..), Kind, Type, ThetaType,
- splitFunTys, splitDictTy_maybe,
+import TypeRep ( Type(..), TyNote(..), Kind, boxedTypeKind ) -- friend
+import Type ( PredType(..), ThetaType,
+ splitPredTy_maybe,
splitForAllTys, splitSigmaTy, splitRhoTy,
- boxedTypeKind
+ isDictTy, splitTyConApp_maybe, splitFunTy_maybe,
+ predRepTy, isUTyVar
)
-import Var ( GenTyVar, TyVar, tyVarKind,
- tyVarName, setTyVarName
+import Var ( TyVar, tyVarKind )
+import TyCon ( TyCon, isPrimTyCon, isTupleTyCon, isUnboxedTupleTyCon,
+ maybeTyConSingleCon, isEnumerationTyCon,
+ tyConArity, tyConName
)
-import VarEnv
-import TyCon ( TyCon, isTupleTyCon, isUnboxedTupleTyCon, tyConArity )
import Class ( Class )
-- others:
+import CmdLineOpts ( opt_PprStyle_RawTypes )
import Maybes ( maybeToBool )
-import Name ( getOccString, setNameVisibility, NamedThing(..) )
+import Name ( getOccString, getOccName )
import Outputable
import PprEnv
-import Unique ( Unique, Uniquable(..),
- incrUnique, listTyConKey, initTyVarUnique
- )
-import Util
+import Unique ( Uniquable(..) )
+import PrelNames -- quite a few *Keys
\end{code}
%************************************************************************
works just by setting the initial context precedence very high.
\begin{code}
-pprType, pprParendType :: GenType flexi -> SDoc
+pprType, pprParendType :: Type -> SDoc
pprType ty = ppr_ty pprTyEnv tOP_PREC ty
pprParendType ty = ppr_ty pprTyEnv tYCON_PREC ty
pprKind = pprType
pprParendKind = pprParendType
-pprConstraint :: Class -> [GenType flexi] -> SDoc
-pprConstraint clas tys = ppr clas <+> hsep (map (pprParendType) tys)
+pprPred :: PredType -> SDoc
+pprPred (Class clas tys) = pprConstraint clas tys
+pprPred (IParam n ty) = hsep [ptext SLIT("?") <> 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 (GenType flexi) where
+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 (GenTyVar flexi) flexi -> Int
- -> GenType flexi
- -> SDoc
-
+ppr_ty :: PprEnv TyVar -> Int -> Type -> SDoc
ppr_ty env ctxt_prec (TyVarTy tyvar)
= pTyVarO env tyvar
+ppr_ty env ctxt_prec ty@(TyConApp tycon tys)
+ -- KIND CASE; it's of the form (Type x)
+ | 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 (getOccName bx) -- Always unqualified
+ other -> maybeParen ctxt_prec tYCON_PREC
+ (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)
-ppr_ty env ctxt_prec (TyConApp tycon tys)
| 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 '#')
- where
- tys_w_commas = sep (punctuate comma (map (ppr_ty env tOP_PREC) tys))
-- LIST CASE
-ppr_ty env ctxt_prec (TyConApp tycon [ty])
- | getUnique tycon == listTyConKey
- = brackets (ppr_ty env tOP_PREC ty)
+ | tycon `hasKey` listTyConKey && n_tys == 1
+ = brackets (ppr_ty env 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
-ppr_ty env ctxt_prec ty@(TyConApp tycon tys)
- | maybeToBool maybe_dict
- = braces (ppr_dict env tYCON_PREC ctys)
- where
- Just ctys = maybe_dict
- maybe_dict = splitDictTy_maybe ty
-
+ | maybeToBool maybe_pred
+ = braces (ppr_pred env pred)
+
-- NO-ARGUMENT CASE (=> no parens)
-ppr_ty env ctxt_prec (TyConApp tycon [])
+ | null tys
= ppr tycon
-- GENERAL CASE
-ppr_ty env ctxt_prec (TyConApp tycon tys)
- = maybeParen ctxt_prec tYCON_PREC (hsep [ppr tycon, tys_w_spaces])
+ | otherwise
+ = maybeParen ctxt_prec tYCON_PREC (sep [ppr tycon, nest 4 tys_w_spaces])
+
where
- tys_w_spaces = hsep (map (ppr_ty env tYCON_PREC) tys)
+ n_tys = length tys
+ (ty1:_) = tys
+ 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 = sep (map (ppr_ty env tYCON_PREC) tys)
+
ppr_ty env ctxt_prec ty@(ForAllTy _ _)
= getPprStyle $ \ sty ->
maybeParen ctxt_prec fUN_PREC $
- if userStyle sty then
- sep [ ptext SLIT("forall"), pp_tyvars, ptext SLIT("."), pp_maybe_ctxt, pp_body ]
- else
- sep [ ptext SLIT("__forall"), brackets pp_tyvars, pp_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 env 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 (pBndr env LambdaBind) 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 = parens (hsep (punctuate comma (map (ppr_pred env) theta)))
+ <+> ptext SLIT("=>")
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))
- where
- (arg_tys, result_ty) = splitFunTys ty2
- pp_rest = [ ptext SLIT("-> ") <> ppr_ty env fUN_PREC ty | ty <- arg_tys ++ [result_ty] ]
+ -- we don't want to lose usage annotations or synonyms,
+ -- so we mustn't use splitFunTys here.
+ = maybeParen ctxt_prec fUN_PREC $
+ sep [ ppr_ty env fUN_PREC ty1
+ , ptext SLIT("->") <+> ppr_ty env tOP_PREC ty2
+ ]
ppr_ty env ctxt_prec (AppTy ty1 ty2)
= maybeParen ctxt_prec tYCON_PREC $
- ppr_ty env tOP_PREC ty1 <+> ppr_ty env tYCON_PREC ty2
+ ppr_ty env fUN_PREC ty1 <+> ppr_ty env tYCON_PREC ty2
+
+ppr_ty env ctxt_prec (UsageTy u ty)
+ = maybeParen ctxt_prec tYCON_PREC $
+ ptext SLIT("__u") <+> ppr_ty env tYCON_PREC u
+ <+> ppr_ty env 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 (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_theta env [] = empty
-ppr_theta env theta = braces (hsep (punctuate comma (map (ppr_dict env tOP_PREC) theta)))
+ppr_ty env ctxt_prec (PredTy p) = braces (ppr_pred env p)
-ppr_dict env ctxt (clas, tys) = ppr clas <+>
+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]
\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}
+
%************************************************************************
%* *
\subsection[TyVar]{@TyVar@}
\begin{code}
pprTyVarBndr tyvar
= getPprStyle $ \ sty ->
- if (ifaceStyle sty || debugStyle sty) && kind /= boxedTypeKind then
- hcat [ppr tyvar, text " :: ", pprParendKind kind]
+ if (ifaceStyle sty && kind /= boxedTypeKind) || debugStyle sty then
+ hsep [ppr tyvar, dcolon, pprParendKind kind]
-- See comments with ppDcolon in PprCore.lhs
else
ppr tyvar
TyConApp tycon _ -> getOccString tycon
NoteTy (FTVNote _) ty -> getTyDescription ty
NoteTy (SynNote ty1) _ -> getTyDescription ty1
+ PredTy p -> getTyDescription (predRepTy p)
ForAllTy _ ty -> getTyDescription ty
}
where
\end{code}
-%************************************************************************
-%* *
-\subsection{Renumbering types}
-%* *
-%************************************************************************
-
-We tend to {\em renumber} everything before printing, so that we get
-consistent Uniques on everything from run to run.
-
-
-\begin{code}
-nmbrGlobalType :: Type -> Type -- Renumber a top-level type
-nmbrGlobalType ty = nmbrType emptyVarEnv initTyVarUnique ty
-
-nmbrType :: TyVarEnv Type -- Substitution
- -> Unique -- This unique and its successors are not
- -- free in the range of the substitution
- -> Type
- -> Type
-
-nmbrType tyvar_env uniq ty
- = initNmbr tyvar_env uniq (nmbrTy ty)
-
-nmbrTy :: Type -> NmbrM Type
-
-nmbrTy (TyVarTy tv)
- = lookupTyVar tv
-
-nmbrTy (AppTy t1 t2)
- = nmbrTy t1 `thenNmbr` \ new_t1 ->
- nmbrTy t2 `thenNmbr` \ new_t2 ->
- returnNmbr (AppTy new_t1 new_t2)
-
-nmbrTy (TyConApp tc tys)
- = mapNmbr nmbrTy tys `thenNmbr` \ new_tys ->
- returnNmbr (TyConApp tc new_tys)
-
-nmbrTy (NoteTy (SynNote ty1) ty2)
- = nmbrTy ty1 `thenNmbr` \ new_ty1 ->
- nmbrTy ty2 `thenNmbr` \ new_ty2 ->
- returnNmbr (NoteTy (SynNote new_ty1) new_ty2)
-
-nmbrTy (NoteTy (FTVNote _) ty2) = nmbrTy ty2
-
-nmbrTy (ForAllTy tv ty)
- = addTyVar tv $ \ new_tv ->
- nmbrTy ty `thenNmbr` \ new_ty ->
- returnNmbr (ForAllTy new_tv new_ty)
-
-nmbrTy (FunTy t1 t2)
- = nmbrTy t1 `thenNmbr` \ new_t1 ->
- nmbrTy t2 `thenNmbr` \ new_t2 ->
- returnNmbr (FunTy new_t1 new_t2)
-
-
-lookupTyVar tyvar env uniq
- = (uniq, ty)
- where
- ty = case lookupVarEnv env tyvar of
- Just ty -> ty
- Nothing -> TyVarTy tyvar
-
-addTyVar tv m env u
- = m tv' env' u'
- where
- env' = extendVarEnv env tv (TyVarTy tv')
- tv' = setTyVarName tv (setNameVisibility Nothing u (tyVarName tv))
- u' = incrUnique u
-\end{code}
-
-Monad stuff
-
\begin{code}
-type NmbrM a = TyVarEnv Type -> Unique -> (Unique, a) -- Unique is name supply
-
-initNmbr :: TyVarEnv Type -> Unique -> NmbrM a -> a
-initNmbr env uniq m
- = snd (m env uniq)
-
-returnNmbr x nenv u = (u, x)
-
-thenNmbr m k nenv u
- = let
- (u', res) = m nenv u
- in
- k res nenv u'
-
-
-mapNmbr f [] = returnNmbr []
-mapNmbr f (x:xs)
- = f x `thenNmbr` \ r ->
- mapNmbr f xs `thenNmbr` \ rs ->
- returnNmbr (r:rs)
+showTypeCategory :: Type -> Char
+ {-
+ {C,I,F,D} char, int, float, double
+ T tuple
+ S other single-constructor type
+ {c,i,f,d} unboxed ditto
+ t *unpacked* tuple
+ s *unpacked" single-cons...
+
+ v void#
+ a primitive array
+
+ E enumeration type
+ + dictionary, unless it's a ...
+ L List
+ > function
+ M other (multi-constructor) data-con type
+ . other type
+ - reserved for others to mark as "uninteresting"
+ -}
+showTypeCategory ty
+ = if isDictTy ty
+ then '+'
+ else
+ case splitTyConApp_maybe ty of
+ Nothing -> if maybeToBool (splitFunTy_maybe ty)
+ then '>'
+ else '.'
+
+ Just (tycon, _) ->
+ let utc = getUnique tycon in
+ if utc == charDataConKey then 'C'
+ else if utc == intDataConKey then 'I'
+ else if utc == floatDataConKey then 'F'
+ else if utc == doubleDataConKey then 'D'
+ else if utc == smallIntegerDataConKey ||
+ utc == largeIntegerDataConKey then 'J'
+ else if utc == charPrimTyConKey then 'c'
+ else if (utc == intPrimTyConKey || utc == wordPrimTyConKey
+ || utc == addrPrimTyConKey) then 'i'
+ else if utc == floatPrimTyConKey then 'f'
+ else if utc == doublePrimTyConKey then 'd'
+ else if isPrimTyCon tycon {- array, we hope -} then 'A'
+ else if isEnumerationTyCon tycon then 'E'
+ else if isTupleTyCon tycon then 'T'
+ else if maybeToBool (maybeTyConSingleCon tycon) then 'S'
+ else if utc == listTyConKey then 'L'
+ else 'M' -- oh, well...
\end{code}
projects / ghc-hetmet.git / blobdiff