d6566203e0ff9b9abd6d7490d6821786e5a6c320
[ghc.git] / compiler / types / TypeRep.lhs
1 %
2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1998
4 %
5 \section[TypeRep]{Type - friends' interface}
6
7 \begin{code}
8 -- We expose the relevant stuff from this module via the Type module
9 {-# OPTIONS_HADDOCK hide #-}
10 {-# LANGUAGE DeriveDataTypeable, DeriveFunctor, DeriveFoldable, DeriveTraversable #-}
11 module TypeRep (
12         TyThing(..), 
13         Type(..),
14         Pred(..),                       -- to friends
15         
16         Kind, SuperKind,
17         PredType, ThetaType,      -- Synonyms
18
19         -- Functions over types
20         mkTyConApp, mkTyConTy, mkTyVarTy, mkTyVarTys,
21         isLiftedTypeKind, isCoercionKind, 
22
23         -- Pretty-printing
24         pprType, pprParendType, pprTypeApp,
25         pprTyThing, pprTyThingCategory, 
26         pprPredTy, pprEqPred, pprTheta, pprForAll, pprThetaArrowTy, pprClassPred,
27         pprKind, pprParendKind,
28         Prec(..), maybeParen, pprTcApp, pprTypeNameApp, 
29         pprPrefixApp, pprPred, pprArrowChain, pprThetaArrow,
30
31         -- Free variables
32         tyVarsOfType, tyVarsOfTypes,
33         tyVarsOfPred, tyVarsOfTheta,
34         varsOfPred, varsOfTheta,
35         predSize,
36
37         -- Substitutions
38         TvSubst(..), TvSubstEnv
39     ) where
40
41 #include "HsVersions.h"
42
43 import {-# SOURCE #-} DataCon( DataCon, dataConName )
44
45 -- friends:
46 import Var
47 import VarEnv
48 import VarSet
49 import Name
50 import BasicTypes
51 import TyCon
52 import Class
53
54 -- others
55 import PrelNames
56 import Outputable
57 import FastString
58 import Pair
59
60 -- libraries
61 import qualified Data.Data        as Data hiding ( TyCon )
62 import qualified Data.Foldable    as Data
63 import qualified Data.Traversable as Data
64 \end{code}
65
66         ----------------------
67         A note about newtypes
68         ----------------------
69
70 Consider
71         newtype N = MkN Int
72
73 Then we want N to be represented as an Int, and that's what we arrange.
74 The front end of the compiler [TcType.lhs] treats N as opaque, 
75 the back end treats it as transparent [Type.lhs].
76
77 There's a bit of a problem with recursive newtypes
78         newtype P = MkP P
79         newtype Q = MkQ (Q->Q)
80
81 Here the 'implicit expansion' we get from treating P and Q as transparent
82 would give rise to infinite types, which in turn makes eqType diverge.
83 Similarly splitForAllTys and splitFunTys can get into a loop.  
84
85 Solution: 
86
87 * Newtypes are always represented using TyConApp.
88
89 * For non-recursive newtypes, P, treat P just like a type synonym after 
90   type-checking is done; i.e. it's opaque during type checking (functions
91   from TcType) but transparent afterwards (functions from Type).  
92   "Treat P as a type synonym" means "all functions expand NewTcApps 
93   on the fly".
94
95   Applications of the data constructor P simply vanish:
96         P x = x
97   
98
99 * For recursive newtypes Q, treat the Q and its representation as 
100   distinct right through the compiler.  Applications of the data consructor
101   use a coerce:
102         Q = \(x::Q->Q). coerce Q x
103   They are rare, so who cares if they are a tiny bit less efficient.
104
105 The typechecker (TcTyDecls) identifies enough type construtors as 'recursive'
106 to cut all loops.  The other members of the loop may be marked 'non-recursive'.
107
108
109 %************************************************************************
110 %*                                                                      *
111 \subsection{The data type}
112 %*                                                                      *
113 %************************************************************************
114
115
116 \begin{code}
117 -- | The key representation of types within the compiler
118 data Type
119   = TyVarTy TyVar       -- ^ Vanilla type variable (*never* a coercion variable)
120
121   | AppTy
122         Type
123         Type            -- ^ Type application to something other than a 'TyCon'. Parameters:
124                         --
125                         --  1) Function: must /not/ be a 'TyConApp',
126                         --     must be another 'AppTy', or 'TyVarTy'
127                         --
128                         --  2) Argument type
129
130   | TyConApp
131         TyCon
132         [Type]          -- ^ Application of a 'TyCon', including newtypes /and/ synonyms.
133                         -- Invariant: saturated appliations of 'FunTyCon' must
134                         -- use 'FunTy' and saturated synonyms must use their own
135                         -- constructors. However, /unsaturated/ 'FunTyCon's
136                         -- do appear as 'TyConApp's.
137                         -- Parameters:
138                         --
139                         -- 1) Type constructor being applied to.
140                         --
141                         -- 2) Type arguments. Might not have enough type arguments
142                         --    here to saturate the constructor.
143                         --    Even type synonyms are not necessarily saturated;
144                         --    for example unsaturated type synonyms
145                         --    can appear as the right hand side of a type synonym.
146
147   | FunTy
148         Type            
149         Type            -- ^ Special case of 'TyConApp': @TyConApp FunTyCon [t1, t2]@
150                         -- See Note [Equality-constrained types]
151
152   | ForAllTy
153         TyVar         -- Type variable
154         Type            -- ^ A polymorphic type
155
156   | PredTy
157         PredType        -- ^ The type of evidence for a type predictate.
158                         -- See Note [PredTy]
159                         -- By the time we are in Core-land, PredTys are
160                         -- synonymous with their representation
161                         -- (see Type.predTypeRep)
162
163   deriving (Data.Data, Data.Typeable)
164
165 -- | The key type representing kinds in the compiler.
166 -- Invariant: a kind is always in one of these forms:
167 --
168 -- > FunTy k1 k2
169 -- > TyConApp PrimTyCon [...]
170 -- > TyVar kv   -- (during inference only)
171 -- > ForAll ... -- (for top-level coercions)
172 type Kind = Type
173
174 -- | "Super kinds", used to help encode 'Kind's as types.
175 -- Invariant: a super kind is always of this form:
176 --
177 -- > TyConApp SuperKindTyCon ...
178 type SuperKind = Type
179 \end{code}
180
181 Note [Equality-constrained types]
182 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
183 The type   forall ab. (a ~ [b]) => blah
184 is encoded like this:
185
186    ForAllTy (a:*) $ ForAllTy (b:*) $
187    FunTy (PredTy (EqPred a [b]) $
188    blah
189
190 -------------------------------------
191                 Note [PredTy]
192
193 \begin{code}
194 -- | A type of the form @PredTy p@ represents a value whose type is
195 -- the Haskell predicate @p@, where a predicate is what occurs before 
196 -- the @=>@ in a Haskell type.
197 -- It can be expanded into its representation, but: 
198 --
199 -- * The type checker must treat it as opaque
200 --
201 -- * The rest of the compiler treats it as transparent
202 --
203 -- Consider these examples:
204 --
205 -- > f :: (Eq a) => a -> Int
206 -- > g :: (?x :: Int -> Int) => a -> Int
207 -- > h :: (r\l) => {r} => {l::Int | r}
208 --
209 -- Here the @Eq a@ and @?x :: Int -> Int@ and @r\l@ are all called \"predicates\"
210 type PredType = Pred Type
211
212 data Pred a   -- Typically 'a' is instantiated with Type or Coercion
213   = ClassP Class [a]            -- ^ Class predicate e.g. @Eq a@
214   | IParam (IPName Name) a      -- ^ Implicit parameter e.g. @?x :: Int@
215   | EqPred a a                  -- ^ Equality predicate e.g @ty1 ~ ty2@
216   deriving (Data.Data, Data.Typeable, Data.Foldable, Data.Traversable, Functor)
217
218 -- | A collection of 'PredType's
219 type ThetaType = [PredType]
220 \end{code}
221
222 (We don't support TREX records yet, but the setup is designed
223 to expand to allow them.)
224
225 A Haskell qualified type, such as that for f,g,h above, is
226 represented using 
227         * a FunTy for the double arrow
228         * with a PredTy as the function argument
229
230 The predicate really does turn into a real extra argument to the
231 function.  If the argument has type (PredTy p) then the predicate p is
232 represented by evidence (a dictionary, for example, of type (predRepTy p).
233
234
235 %************************************************************************
236 %*                                                                      *
237             Simple constructors
238 %*                                                                      *
239 %************************************************************************
240
241 These functions are here so that they can be used by TysPrim,
242 which in turn is imported by Type
243
244 \begin{code}
245 mkTyVarTy  :: TyVar   -> Type
246 mkTyVarTy  = TyVarTy
247
248 mkTyVarTys :: [TyVar] -> [Type]
249 mkTyVarTys = map mkTyVarTy -- a common use of mkTyVarTy
250
251 -- | A key function: builds a 'TyConApp' or 'FunTy' as apppropriate to its arguments.
252 -- Applies its arguments to the constructor from left to right
253 mkTyConApp :: TyCon -> [Type] -> Type
254 mkTyConApp tycon tys
255   | isFunTyCon tycon, [ty1,ty2] <- tys
256   = FunTy ty1 ty2
257
258   | otherwise
259   = TyConApp tycon tys
260
261 -- | Create the plain type constructor type which has been applied to no type arguments at all.
262 mkTyConTy :: TyCon -> Type
263 mkTyConTy tycon = mkTyConApp tycon []
264
265 isLiftedTypeKind :: Kind -> Bool
266 -- This function is here because it's used in the pretty printer
267 isLiftedTypeKind (TyConApp tc []) = tc `hasKey` liftedTypeKindTyConKey
268 isLiftedTypeKind _                = False
269
270 isCoercionKind :: Kind -> Bool
271 -- All coercions are of form (ty1 ~ ty2)
272 -- This function is here rather than in Coercion, because it
273 -- is used in a knot-tied way to enforce invariants in Var
274 isCoercionKind (PredTy (EqPred {})) = True
275 isCoercionKind _                    = False
276 \end{code}
277
278
279 %************************************************************************
280 %*                                                                      *
281                         Free variables of types and coercions
282 %*                                                                      *
283 %************************************************************************
284
285 \begin{code}
286 tyVarsOfPred :: PredType -> TyVarSet
287 tyVarsOfPred = varsOfPred tyVarsOfType
288
289 tyVarsOfTheta :: ThetaType -> TyVarSet
290 tyVarsOfTheta = varsOfTheta tyVarsOfType
291
292 tyVarsOfType :: Type -> VarSet
293 -- ^ NB: for type synonyms tyVarsOfType does /not/ expand the synonym
294 tyVarsOfType (TyVarTy v)         = unitVarSet v
295 tyVarsOfType (TyConApp _ tys)    = tyVarsOfTypes tys
296 tyVarsOfType (PredTy sty)        = varsOfPred tyVarsOfType sty
297 tyVarsOfType (FunTy arg res)     = tyVarsOfType arg `unionVarSet` tyVarsOfType res
298 tyVarsOfType (AppTy fun arg)     = tyVarsOfType fun `unionVarSet` tyVarsOfType arg
299 tyVarsOfType (ForAllTy tyvar ty) = delVarSet (tyVarsOfType ty) tyvar
300
301 tyVarsOfTypes :: [Type] -> TyVarSet
302 tyVarsOfTypes tys = foldr (unionVarSet . tyVarsOfType) emptyVarSet tys
303
304 varsOfPred :: (a -> VarSet) -> Pred a -> VarSet
305 varsOfPred f (IParam _ ty)    = f ty
306 varsOfPred f (ClassP _ tys)   = foldr (unionVarSet . f) emptyVarSet tys
307 varsOfPred f (EqPred ty1 ty2) = f ty1 `unionVarSet` f ty2
308
309 varsOfTheta :: (a -> VarSet) -> [Pred a] -> VarSet
310 varsOfTheta f = foldr (unionVarSet . varsOfPred f) emptyVarSet
311
312 predSize :: (a -> Int) -> Pred a -> Int
313 predSize size (IParam _ t)   = 1 + size t
314 predSize size (ClassP _ ts)  = 1 + sum (map size ts)
315 predSize size (EqPred t1 t2) = size t1 + size t2
316 \end{code}
317
318 %************************************************************************
319 %*                                                                      *
320                         TyThing
321 %*                                                                      *
322 %************************************************************************
323
324 Despite the fact that DataCon has to be imported via a hi-boot route, 
325 this module seems the right place for TyThing, because it's needed for
326 funTyCon and all the types in TysPrim.
327
328 \begin{code}
329 -- | A typecheckable-thing, essentially anything that has a name
330 data TyThing = AnId     Id
331              | ADataCon DataCon
332              | ATyCon   TyCon
333              | ACoAxiom CoAxiom
334              | AClass   Class
335
336 instance Outputable TyThing where 
337   ppr = pprTyThing
338
339 pprTyThing :: TyThing -> SDoc
340 pprTyThing thing = pprTyThingCategory thing <+> quotes (ppr (getName thing))
341
342 pprTyThingCategory :: TyThing -> SDoc
343 pprTyThingCategory (ATyCon _)   = ptext (sLit "Type constructor")
344 pprTyThingCategory (ACoAxiom _) = ptext (sLit "Coercion axiom")
345 pprTyThingCategory (AClass _)   = ptext (sLit "Class")
346 pprTyThingCategory (AnId   _)   = ptext (sLit "Identifier")
347 pprTyThingCategory (ADataCon _) = ptext (sLit "Data constructor")
348
349 instance NamedThing TyThing where       -- Can't put this with the type
350   getName (AnId id)     = getName id    -- decl, because the DataCon instance
351   getName (ATyCon tc)   = getName tc    -- isn't visible there
352   getName (ACoAxiom cc) = getName cc
353   getName (AClass cl)   = getName cl
354   getName (ADataCon dc) = dataConName dc
355 \end{code}
356
357
358 %************************************************************************
359 %*                                                                      *
360                         Substitutions
361       Data type defined here to avoid unnecessary mutual recursion
362 %*                                                                      *
363 %************************************************************************
364
365 \begin{code}
366 -- | Type substitution
367 --
368 -- #tvsubst_invariant#
369 -- The following invariants must hold of a 'TvSubst':
370 -- 
371 -- 1. The in-scope set is needed /only/ to
372 -- guide the generation of fresh uniques
373 --
374 -- 2. In particular, the /kind/ of the type variables in 
375 -- the in-scope set is not relevant
376 --
377 -- 3. The substition is only applied ONCE! This is because
378 -- in general such application will not reached a fixed point.
379 data TvSubst            
380   = TvSubst InScopeSet  -- The in-scope type variables
381             TvSubstEnv  -- Substitution of types
382         -- See Note [Apply Once]
383         -- and Note [Extending the TvSubstEnv]
384
385 -- | A substitition of 'Type's for 'TyVar's
386 type TvSubstEnv = TyVarEnv Type
387         -- A TvSubstEnv is used both inside a TvSubst (with the apply-once
388         -- invariant discussed in Note [Apply Once]), and also independently
389         -- in the middle of matching, and unification (see Types.Unify)
390         -- So you have to look at the context to know if it's idempotent or
391         -- apply-once or whatever
392 \end{code}
393
394 Note [Apply Once]
395 ~~~~~~~~~~~~~~~~~
396 We use TvSubsts to instantiate things, and we might instantiate
397         forall a b. ty
398 \with the types
399         [a, b], or [b, a].
400 So the substition might go [a->b, b->a].  A similar situation arises in Core
401 when we find a beta redex like
402         (/\ a /\ b -> e) b a
403 Then we also end up with a substition that permutes type variables. Other
404 variations happen to; for example [a -> (a, b)].  
405
406         ***************************************************
407         *** So a TvSubst must be applied precisely once ***
408         ***************************************************
409
410 A TvSubst is not idempotent, but, unlike the non-idempotent substitution
411 we use during unifications, it must not be repeatedly applied.
412
413 Note [Extending the TvSubst]
414 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
415 See #tvsubst_invariant# for the invariants that must hold.
416
417 This invariant allows a short-cut when the TvSubstEnv is empty:
418 if the TvSubstEnv is empty --- i.e. (isEmptyTvSubt subst) holds ---
419 then (substTy subst ty) does nothing.
420
421 For example, consider:
422         (/\a. /\b:(a~Int). ...b..) Int
423 We substitute Int for 'a'.  The Unique of 'b' does not change, but
424 nevertheless we add 'b' to the TvSubstEnv, because b's kind does change
425
426 This invariant has several crucial consequences:
427
428 * In substTyVarBndr, we need extend the TvSubstEnv 
429         - if the unique has changed
430         - or if the kind has changed
431
432 * In substTyVar, we do not need to consult the in-scope set;
433   the TvSubstEnv is enough
434
435 * In substTy, substTheta, we can short-circuit when the TvSubstEnv is empty
436 \end{code}
437
438
439
440 %************************************************************************
441 %*                                                                      *
442                    Pretty-printing types
443
444        Defined very early because of debug printing in assertions
445 %*                                                                      *
446 %************************************************************************
447
448 @pprType@ is the standard @Type@ printer; the overloaded @ppr@ function is
449 defined to use this.  @pprParendType@ is the same, except it puts
450 parens around the type, except for the atomic cases.  @pprParendType@
451 works just by setting the initial context precedence very high.
452
453 \begin{code}
454 data Prec = TopPrec     -- No parens
455           | FunPrec     -- Function args; no parens for tycon apps
456           | TyConPrec   -- Tycon args; no parens for atomic
457           deriving( Eq, Ord )
458
459 maybeParen :: Prec -> Prec -> SDoc -> SDoc
460 maybeParen ctxt_prec inner_prec pretty
461   | ctxt_prec < inner_prec = pretty
462   | otherwise              = parens pretty
463
464 ------------------
465 pprType, pprParendType :: Type -> SDoc
466 pprType       ty = ppr_type TopPrec ty
467 pprParendType ty = ppr_type TyConPrec ty
468
469 pprKind, pprParendKind :: Kind -> SDoc
470 pprKind       = pprType
471 pprParendKind = pprParendType
472
473 ------------------
474 pprPredTy :: PredType -> SDoc
475 pprPredTy = pprPred ppr_type
476
477 pprPred :: (Prec -> a -> SDoc) -> Pred a -> SDoc
478 pprPred pp (ClassP cls tys) = ppr_class_pred pp cls tys
479 pprPred pp (IParam ip ty)   = ppr ip <> dcolon <> pp TopPrec ty
480 pprPred pp (EqPred ty1 ty2) = ppr_eq_pred pp (Pair ty1 ty2)
481
482 ------------
483 pprEqPred :: Pair Type -> SDoc
484 pprEqPred = ppr_eq_pred ppr_type
485
486 ppr_eq_pred :: (Prec -> a -> SDoc) -> Pair a -> SDoc
487 ppr_eq_pred pp (Pair ty1 ty2) = sep [ pp FunPrec ty1
488                                     , nest 2 (ptext (sLit "~"))
489                                     , pp FunPrec ty2]
490                                -- Precedence looks like (->) so that we get
491                                --    Maybe a ~ Bool
492                                --    (a->a) ~ Bool
493                                -- Note parens on the latter!
494
495 ------------
496 pprClassPred :: Class -> [Type] -> SDoc
497 pprClassPred = ppr_class_pred ppr_type
498
499 ppr_class_pred :: (Prec -> a -> SDoc) -> Class -> [a] -> SDoc
500 ppr_class_pred pp clas tys = pprTypeNameApp TopPrec pp (getName clas) tys
501
502 ------------
503 pprTheta :: ThetaType -> SDoc
504 -- pprTheta [pred] = pprPred pred        -- I'm in two minds about this
505 pprTheta theta  = parens (sep (punctuate comma (map pprPredTy theta)))
506
507 pprThetaArrowTy :: ThetaType -> SDoc
508 pprThetaArrowTy = pprThetaArrow ppr_type
509
510 pprThetaArrow :: (Prec -> a -> SDoc) -> [Pred a] -> SDoc
511 pprThetaArrow _ []      = empty
512 pprThetaArrow pp [pred]
513       | noParenPred pred = pprPred pp pred <+> darrow
514 pprThetaArrow pp preds   = parens (fsep (punctuate comma (map (pprPred pp) preds)))
515                             <+> darrow
516     -- Notice 'fsep' here rather that 'sep', so that
517     -- type contexts don't get displayed in a giant column
518     -- Rather than
519     --  instance (Eq a,
520     --            Eq b,
521     --            Eq c,
522     --            Eq d,
523     --            Eq e,
524     --            Eq f,
525     --            Eq g,
526     --            Eq h,
527     --            Eq i,
528     --            Eq j,
529     --            Eq k,
530     --            Eq l) =>
531     --           Eq (a, b, c, d, e, f, g, h, i, j, k, l)
532     -- we get
533     --
534     --  instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i,
535     --            Eq j, Eq k, Eq l) =>
536     --           Eq (a, b, c, d, e, f, g, h, i, j, k, l)
537                            
538 noParenPred :: Pred a -> Bool
539 -- A predicate that can appear without parens before a "=>"
540 --       C a => a -> a
541 --       a~b => a -> b
542 -- But   (?x::Int) => Int -> Int
543 noParenPred (ClassP {}) = True
544 noParenPred (EqPred {}) = True
545 noParenPred (IParam {}) = False
546
547 ------------------
548 instance Outputable Type where
549     ppr ty = pprType ty
550
551 instance Outputable (Pred Type) where
552     ppr = pprPredTy   -- Not for arbitrary (Pred a), because the
553                       -- (Outputable a) doesn't give precedence
554
555 instance Outputable name => OutputableBndr (IPName name) where
556     pprBndr _ n = ppr n -- Simple for now
557
558 ------------------
559         -- OK, here's the main printer
560
561 ppr_type :: Prec -> Type -> SDoc
562 ppr_type _ (TyVarTy tv)       = ppr_tvar tv
563 ppr_type p (PredTy pred)      = maybeParen p TyConPrec $
564                                 ifPprDebug (ptext (sLit "<pred>")) <> (pprPredTy pred)
565 ppr_type p (TyConApp tc tys)  = pprTcApp p ppr_type tc tys
566
567 ppr_type p (AppTy t1 t2) = maybeParen p TyConPrec $
568                            pprType t1 <+> ppr_type TyConPrec t2
569
570 ppr_type p ty@(ForAllTy {})        = ppr_forall_type p ty
571 ppr_type p ty@(FunTy (PredTy _) _) = ppr_forall_type p ty
572
573 ppr_type p (FunTy ty1 ty2)
574   = pprArrowChain p (ppr_type FunPrec ty1 : ppr_fun_tail ty2)
575   where
576     -- We don't want to lose synonyms, so we mustn't use splitFunTys here.
577     ppr_fun_tail (FunTy ty1 ty2)
578       | not (is_pred ty1) = ppr_type FunPrec ty1 : ppr_fun_tail ty2
579     ppr_fun_tail other_ty = [ppr_type TopPrec other_ty]
580
581     is_pred (PredTy {}) = True
582     is_pred _           = False
583
584 ppr_forall_type :: Prec -> Type -> SDoc
585 ppr_forall_type p ty
586   = maybeParen p FunPrec $
587     sep [pprForAll tvs, pprThetaArrowTy ctxt, pprType tau]
588   where
589     (tvs,  rho) = split1 [] ty
590     (ctxt, tau) = split2 [] rho
591
592     split1 tvs (ForAllTy tv ty) = split1 (tv:tvs) ty
593     split1 tvs ty               = (reverse tvs, ty)
594  
595     split2 ps (PredTy p `FunTy` ty) = split2 (p:ps) ty
596     split2 ps ty                    = (reverse ps, ty)
597
598 ppr_tvar :: TyVar -> SDoc
599 ppr_tvar tv  -- Note [Infix type variables]
600   = parenSymOcc (getOccName tv) (ppr tv)
601
602 -------------------
603 pprForAll :: [TyVar] -> SDoc
604 pprForAll []  = empty
605 pprForAll tvs = ptext (sLit "forall") <+> sep (map pprTvBndr tvs) <> dot
606
607 pprTvBndr :: TyVar -> SDoc
608 pprTvBndr tv 
609   | isLiftedTypeKind kind = ppr_tvar tv
610   | otherwise             = parens (ppr_tvar tv <+> dcolon <+> pprKind kind)
611              where
612                kind = tyVarKind tv
613 \end{code}
614
615 Note [Infix type variables]
616 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
617 With TypeOperators you can say
618
619    f :: (a ~> b) -> b
620
621 and the (~>) is considered a type variable.  However, the type
622 pretty-printer in this module will just see (a ~> b) as
623
624    App (App (TyVarTy "~>") (TyVarTy "a")) (TyVarTy "b")
625
626 So it'll print the type in prefix form.  To avoid confusion we must
627 remember to parenthesise the operator, thus
628
629    (~>) a b -> b
630
631 See Trac #2766.
632
633 \begin{code}
634 pprTcApp :: Prec -> (Prec -> a -> SDoc) -> TyCon -> [a] -> SDoc
635 pprTcApp _ _ tc []      -- No brackets for SymOcc
636   = pp_nt_debug <> ppr tc
637   where
638    pp_nt_debug | isNewTyCon tc = ifPprDebug (if isRecursiveTyCon tc 
639                                              then ptext (sLit "<recnt>")
640                                              else ptext (sLit "<nt>"))
641                | otherwise     = empty
642
643 pprTcApp _ pp tc [ty]
644   | tc `hasKey` listTyConKey = brackets (pp TopPrec ty)
645   | tc `hasKey` parrTyConKey = ptext (sLit "[:") <> pp TopPrec ty <> ptext (sLit ":]")
646   | tc `hasKey` liftedTypeKindTyConKey   = ptext (sLit "*")
647   | tc `hasKey` unliftedTypeKindTyConKey = ptext (sLit "#")
648   | tc `hasKey` openTypeKindTyConKey     = ptext (sLit "(?)")
649   | tc `hasKey` ubxTupleKindTyConKey     = ptext (sLit "(#)")
650   | tc `hasKey` argTypeKindTyConKey      = ptext (sLit "??")
651
652 pprTcApp p pp tc tys
653   | isTupleTyCon tc && tyConArity tc == length tys
654   = tupleParens (tupleTyConBoxity tc) (sep (punctuate comma (map (pp TopPrec) tys)))
655   | otherwise
656   = pprTypeNameApp p pp (getName tc) tys
657
658 ----------------
659 pprTypeApp :: NamedThing a => a -> [Type] -> SDoc
660 -- The first arg is the tycon, or sometimes class
661 -- Print infix if the tycon/class looks like an operator
662 pprTypeApp tc tys = pprTypeNameApp TopPrec ppr_type (getName tc) tys
663
664 pprTypeNameApp :: Prec -> (Prec -> a -> SDoc) -> Name -> [a] -> SDoc
665 -- Used for classes and coercions as well as types; that's why it's separate from pprTcApp
666 pprTypeNameApp p pp tc tys
667   | is_sym_occ           -- Print infix if possible
668   , [ty1,ty2] <- tys  -- We know nothing of precedence though
669   = maybeParen p FunPrec $
670     sep [pp FunPrec ty1, pprInfixVar True (ppr tc) <+> pp FunPrec ty2]
671   | otherwise
672   = pprPrefixApp p (pprPrefixVar is_sym_occ (ppr tc)) (map (pp TyConPrec) tys)
673   where
674     is_sym_occ = isSymOcc (getOccName tc)
675
676 ----------------
677 pprPrefixApp :: Prec -> SDoc -> [SDoc] -> SDoc
678 pprPrefixApp p pp_fun pp_tys = maybeParen p TyConPrec $
679                                hang pp_fun 2 (sep pp_tys)
680
681 ----------------
682 pprArrowChain :: Prec -> [SDoc] -> SDoc
683 -- pprArrowChain p [a,b,c]  generates   a -> b -> c
684 pprArrowChain _ []         = empty
685 pprArrowChain p (arg:args) = maybeParen p FunPrec $
686                              sep [arg, sep (map (arrow <+>) args)]
687 \end{code}
688