Nicer pretty printing for tuple kinds
[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 Note [The Type-related module hierarchy]
8 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9   Class
10   TyCon    imports Class
11   TypeRep 
12   TysPrim  imports TypeRep ( including mkTyConTy )
13   Kind     imports TysPrim ( mainly for primitive kinds )
14   Type     imports Kind
15   Coercion imports Type
16
17 \begin{code}
18 {-# OPTIONS -fno-warn-tabs #-}
19 -- The above warning supression flag is a temporary kludge.
20 -- While working on this module you are encouraged to remove it and
21 -- detab the module (please do the detabbing in a separate patch). See
22 --     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#TabsvsSpaces
23 -- for details
24
25 -- We expose the relevant stuff from this module via the Type module
26 {-# OPTIONS_HADDOCK hide #-}
27 {-# LANGUAGE DeriveDataTypeable, DeriveFunctor, DeriveFoldable, DeriveTraversable #-}
28 module TypeRep (
29         TyThing(..),
30         Type(..),
31         TyLit(..),
32         KindOrType, Kind, SuperKind,
33         PredType, ThetaType,      -- Synonyms
34
35         -- Functions over types
36         mkNakedTyConApp, mkTyConTy, mkTyVarTy, mkTyVarTys,
37         isLiftedTypeKind, isSuperKind, isTypeVar, isKindVar,
38         
39         -- Pretty-printing
40         pprType, pprParendType, pprTypeApp, pprTvBndr, pprTvBndrs,
41         pprTyThing, pprTyThingCategory, pprSigmaType,
42         pprEqPred, pprTheta, pprForAll, pprThetaArrowTy, pprClassPred,
43         pprKind, pprParendKind, pprTyLit,
44         Prec(..), maybeParen, pprTcApp, pprTypeNameApp, 
45         pprPrefixApp, pprArrowChain, ppr_type,
46
47         -- Free variables
48         tyVarsOfType, tyVarsOfTypes,
49
50         -- Substitutions
51         TvSubst(..), TvSubstEnv
52     ) where
53
54 #include "HsVersions.h"
55
56 import {-# SOURCE #-} DataCon( DataCon, dataConTyCon, dataConName )
57 import {-# SOURCE #-} Type( noParenPred, isPredTy ) -- Transitively pulls in a LOT of stuff, better to break the loop
58
59 -- friends:
60 import Var
61 import VarEnv
62 import VarSet
63 import Name
64 import BasicTypes
65 import TyCon
66 import Class
67
68 -- others
69 import PrelNames
70 import Outputable
71 import FastString
72 import Pair
73 import StaticFlags( opt_PprStyle_Debug )
74 import Util
75
76 -- libraries
77 import qualified Data.Data        as Data hiding ( TyCon )
78 \end{code}
79
80
81 %************************************************************************
82 %*                                                                      *
83 \subsection{The data type}
84 %*                                                                      *
85 %************************************************************************
86
87
88 \begin{code}
89 -- | The key representation of types within the compiler
90 data Type
91   = TyVarTy Var -- ^ Vanilla type or kind variable (*never* a coercion variable)
92
93   | AppTy         -- See Note [AppTy invariant]
94         Type
95         Type            -- ^ Type application to something other than a 'TyCon'. Parameters:
96                         --
97                         --  1) Function: must /not/ be a 'TyConApp',
98                         --     must be another 'AppTy', or 'TyVarTy'
99                         --
100                         --  2) Argument type
101
102   | TyConApp      -- See Note [AppTy invariant]
103         TyCon
104         [KindOrType]    -- ^ Application of a 'TyCon', including newtypes /and/ synonyms.
105                         -- Invariant: saturated appliations of 'FunTyCon' must
106                         -- use 'FunTy' and saturated synonyms must use their own
107                         -- constructors. However, /unsaturated/ 'FunTyCon's
108                         -- do appear as 'TyConApp's.
109                         -- Parameters:
110                         --
111                         -- 1) Type constructor being applied to.
112                         --
113                         -- 2) Type arguments. Might not have enough type arguments
114                         --    here to saturate the constructor.
115                         --    Even type synonyms are not necessarily saturated;
116                         --    for example unsaturated type synonyms
117                         --    can appear as the right hand side of a type synonym.
118
119   | FunTy
120         Type            
121         Type            -- ^ Special case of 'TyConApp': @TyConApp FunTyCon [t1, t2]@
122                         -- See Note [Equality-constrained types]
123
124   | ForAllTy
125         Var         -- Type or kind variable
126         Type            -- ^ A polymorphic type
127
128   | LitTy TyLit     -- ^ Type literals are simillar to type constructors.
129
130   deriving (Data.Data, Data.Typeable)
131
132
133 -- NOTE:  Other parts of the code assume that type literals do not contain
134 -- types or type variables.
135 data TyLit
136   = NumTyLit Integer
137   | StrTyLit FastString
138   deriving (Eq, Ord, Data.Data, Data.Typeable)
139
140 type KindOrType = Type -- See Note [Arguments to type constructors]
141
142 -- | The key type representing kinds in the compiler.
143 -- Invariant: a kind is always in one of these forms:
144 --
145 -- > FunTy k1 k2
146 -- > TyConApp PrimTyCon [...]
147 -- > TyVar kv   -- (during inference only)
148 -- > ForAll ... -- (for top-level coercions)
149 type Kind = Type
150
151 -- | "Super kinds", used to help encode 'Kind's as types.
152 -- Invariant: a super kind is always of this form:
153 --
154 -- > TyConApp SuperKindTyCon ...
155 type SuperKind = Type
156 \end{code}
157
158 Note [The kind invariant]
159 ~~~~~~~~~~~~~~~~~~~~~~~~~
160 The kinds
161    #          UnliftedTypeKind
162    OpenKind   super-kind of *, #
163
164 can never appear under an arrow or type constructor in a kind; they
165 can only be at the top level of a kind.  It follows that primitive TyCons,
166 which have a naughty pseudo-kind
167    State# :: * -> #
168 must always be saturated, so that we can never get a type whose kind
169 has a UnliftedTypeKind or ArgTypeKind underneath an arrow.
170
171 Nor can we abstract over a type variable with any of these kinds.
172
173     k :: = kk | # | ArgKind | (#) | OpenKind 
174     kk :: = * | kk -> kk | T kk1 ... kkn
175
176 So a type variable can only be abstracted kk.
177
178 Note [Arguments to type constructors]
179 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
180 Because of kind polymorphism, in addition to type application we now
181 have kind instantiation. We reuse the same notations to do so.
182
183 For example:
184
185   Just (* -> *) Maybe
186   Right * Nat Zero
187
188 are represented by:
189
190   TyConApp (PromotedDataCon Just) [* -> *, Maybe]
191   TyConApp (PromotedDataCon Right) [*, Nat, (PromotedDataCon Zero)]
192
193 Important note: Nat is used as a *kind* and not as a type. This can be
194 confusing, since type-level Nat and kind-level Nat are identical. We
195 use the kind of (PromotedDataCon Right) to know if its arguments are
196 kinds or types.
197
198 This kind instantiation only happens in TyConApp currently.
199
200
201 Note [Equality-constrained types]
202 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
203 The type   forall ab. (a ~ [b]) => blah
204 is encoded like this:
205
206    ForAllTy (a:*) $ ForAllTy (b:*) $
207    FunTy (TyConApp (~) [a, [b]]) $
208    blah
209
210 -------------------------------------
211                 Note [PredTy]
212
213 \begin{code}
214 -- | A type of the form @p@ of kind @Constraint@ represents a value whose type is
215 -- the Haskell predicate @p@, where a predicate is what occurs before 
216 -- the @=>@ in a Haskell type.
217 --
218 -- We use 'PredType' as documentation to mark those types that we guarantee to have
219 -- this kind.
220 --
221 -- It can be expanded into its representation, but: 
222 --
223 -- * The type checker must treat it as opaque
224 --
225 -- * The rest of the compiler treats it as transparent
226 --
227 -- Consider these examples:
228 --
229 -- > f :: (Eq a) => a -> Int
230 -- > g :: (?x :: Int -> Int) => a -> Int
231 -- > h :: (r\l) => {r} => {l::Int | r}
232 --
233 -- Here the @Eq a@ and @?x :: Int -> Int@ and @r\l@ are all called \"predicates\"
234 type PredType = Type
235
236 -- | A collection of 'PredType's
237 type ThetaType = [PredType]
238 \end{code}
239
240 (We don't support TREX records yet, but the setup is designed
241 to expand to allow them.)
242
243 A Haskell qualified type, such as that for f,g,h above, is
244 represented using 
245         * a FunTy for the double arrow
246         * with a type of kind Constraint as the function argument
247
248 The predicate really does turn into a real extra argument to the
249 function.  If the argument has type (p :: Constraint) then the predicate p is
250 represented by evidence of type p.
251
252 %************************************************************************
253 %*                                                                      *
254             Simple constructors
255 %*                                                                      *
256 %************************************************************************
257
258 These functions are here so that they can be used by TysPrim,
259 which in turn is imported by Type
260
261 \begin{code}
262 mkTyVarTy  :: TyVar   -> Type
263 mkTyVarTy  = TyVarTy
264
265 mkTyVarTys :: [TyVar] -> [Type]
266 mkTyVarTys = map mkTyVarTy -- a common use of mkTyVarTy
267
268 mkNakedTyConApp :: TyCon -> [Type] -> Type
269 -- Builds a TyConApp 
270 --   * without being strict in TyCon,
271 --   * the TyCon should never be a saturated FunTyCon 
272 -- Type.mkTyConApp is the usual one
273 mkNakedTyConApp tc tys
274   = TyConApp (ASSERT( not (isFunTyCon tc && length tys == 2) ) tc) tys
275
276 -- | Create the plain type constructor type which has been applied to no type arguments at all.
277 mkTyConTy :: TyCon -> Type
278 mkTyConTy tycon = TyConApp tycon []
279 \end{code}
280
281 Some basic functions, put here to break loops eg with the pretty printer
282
283 \begin{code}
284 isLiftedTypeKind :: Kind -> Bool
285 isLiftedTypeKind (TyConApp tc []) = tc `hasKey` liftedTypeKindTyConKey
286 isLiftedTypeKind _                = False
287
288 -- | Is this a super-kind (i.e. a type-of-kinds)?
289 isSuperKind :: Type -> Bool
290 isSuperKind (TyConApp skc []) = skc `hasKey` superKindTyConKey
291 isSuperKind _                 = False
292
293 isTypeVar :: Var -> Bool
294 isTypeVar v = isTKVar v && not (isSuperKind (varType v))
295
296 isKindVar :: Var -> Bool 
297 isKindVar v = isTKVar v && isSuperKind (varType v)
298 \end{code}
299
300
301 %************************************************************************
302 %*                                                                      *
303                         Free variables of types and coercions
304 %*                                                                      *
305 %************************************************************************
306
307 \begin{code}  
308 tyVarsOfType :: Type -> VarSet
309 -- ^ NB: for type synonyms tyVarsOfType does /not/ expand the synonym
310 -- tyVarsOfType returns only the free variables of a type
311 -- For example, tyVarsOfType (a::k) returns {a}, not including the
312 -- kind variable {k}
313 tyVarsOfType (TyVarTy v)         = unitVarSet v
314 tyVarsOfType (TyConApp _ tys)    = tyVarsOfTypes tys
315 tyVarsOfType (LitTy {})          = emptyVarSet
316 tyVarsOfType (FunTy arg res)     = tyVarsOfType arg `unionVarSet` tyVarsOfType res
317 tyVarsOfType (AppTy fun arg)     = tyVarsOfType fun `unionVarSet` tyVarsOfType arg
318 tyVarsOfType (ForAllTy tyvar ty) = delVarSet (tyVarsOfType ty) tyvar
319                                    `unionVarSet` tyVarsOfType (tyVarKind tyvar)
320
321 tyVarsOfTypes :: [Type] -> TyVarSet
322 tyVarsOfTypes tys = foldr (unionVarSet . tyVarsOfType) emptyVarSet tys
323 \end{code}
324
325 %************************************************************************
326 %*                                                                      *
327                         TyThing
328 %*                                                                      *
329 %************************************************************************
330
331 Despite the fact that DataCon has to be imported via a hi-boot route, 
332 this module seems the right place for TyThing, because it's needed for
333 funTyCon and all the types in TysPrim.
334
335 Note [ATyCon for classes]
336 ~~~~~~~~~~~~~~~~~~~~~~~~~
337 Both classes and type constructors are represented in the type environment
338 as ATyCon.  You can tell the difference, and get to the class, with
339    isClassTyCon :: TyCon -> Bool
340    tyConClass_maybe :: TyCon -> Maybe Class
341 The Class and its associated TyCon have the same Name.
342
343 \begin{code}
344 -- | A typecheckable-thing, essentially anything that has a name
345 data TyThing 
346   = AnId     Id
347   | ADataCon DataCon
348   | ATyCon   TyCon       -- TyCons and classes; see Note [ATyCon for classes]
349   | ACoAxiom CoAxiom
350   deriving (Eq, Ord)
351
352 instance Outputable TyThing where 
353   ppr = pprTyThing
354
355 pprTyThing :: TyThing -> SDoc
356 pprTyThing thing = pprTyThingCategory thing <+> quotes (ppr (getName thing))
357
358 pprTyThingCategory :: TyThing -> SDoc
359 pprTyThingCategory (ATyCon tc)
360   | isClassTyCon tc = ptext (sLit "Class")
361   | otherwise       = ptext (sLit "Type constructor")
362 pprTyThingCategory (ACoAxiom _) = ptext (sLit "Coercion axiom")
363 pprTyThingCategory (AnId   _)   = ptext (sLit "Identifier")
364 pprTyThingCategory (ADataCon _) = ptext (sLit "Data constructor")
365
366
367 instance NamedThing TyThing where       -- Can't put this with the type
368   getName (AnId id)     = getName id    -- decl, because the DataCon instance
369   getName (ATyCon tc)   = getName tc    -- isn't visible there
370   getName (ACoAxiom cc) = getName cc
371   getName (ADataCon dc) = dataConName dc
372
373 \end{code}
374
375
376 %************************************************************************
377 %*                                                                      *
378                         Substitutions
379       Data type defined here to avoid unnecessary mutual recursion
380 %*                                                                      *
381 %************************************************************************
382
383 \begin{code}
384 -- | Type substitution
385 --
386 -- #tvsubst_invariant#
387 -- The following invariants must hold of a 'TvSubst':
388 -- 
389 -- 1. The in-scope set is needed /only/ to
390 -- guide the generation of fresh uniques
391 --
392 -- 2. In particular, the /kind/ of the type variables in 
393 -- the in-scope set is not relevant
394 --
395 -- 3. The substition is only applied ONCE! This is because
396 -- in general such application will not reached a fixed point.
397 data TvSubst            
398   = TvSubst InScopeSet  -- The in-scope type and kind variables
399             TvSubstEnv  -- Substitutes both type and kind variables
400         -- See Note [Apply Once]
401         -- and Note [Extending the TvSubstEnv]
402
403 -- | A substitition of 'Type's for 'TyVar's
404 --                 and 'Kind's for 'KindVar's
405 type TvSubstEnv = TyVarEnv Type
406         -- A TvSubstEnv is used both inside a TvSubst (with the apply-once
407         -- invariant discussed in Note [Apply Once]), and also independently
408         -- in the middle of matching, and unification (see Types.Unify)
409         -- So you have to look at the context to know if it's idempotent or
410         -- apply-once or whatever
411 \end{code}
412
413 Note [Apply Once]
414 ~~~~~~~~~~~~~~~~~
415 We use TvSubsts to instantiate things, and we might instantiate
416         forall a b. ty
417 \with the types
418         [a, b], or [b, a].
419 So the substition might go [a->b, b->a].  A similar situation arises in Core
420 when we find a beta redex like
421         (/\ a /\ b -> e) b a
422 Then we also end up with a substition that permutes type variables. Other
423 variations happen to; for example [a -> (a, b)].  
424
425         ***************************************************
426         *** So a TvSubst must be applied precisely once ***
427         ***************************************************
428
429 A TvSubst is not idempotent, but, unlike the non-idempotent substitution
430 we use during unifications, it must not be repeatedly applied.
431
432 Note [Extending the TvSubst]
433 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
434 See #tvsubst_invariant# for the invariants that must hold.
435
436 This invariant allows a short-cut when the TvSubstEnv is empty:
437 if the TvSubstEnv is empty --- i.e. (isEmptyTvSubt subst) holds ---
438 then (substTy subst ty) does nothing.
439
440 For example, consider:
441         (/\a. /\b:(a~Int). ...b..) Int
442 We substitute Int for 'a'.  The Unique of 'b' does not change, but
443 nevertheless we add 'b' to the TvSubstEnv, because b's kind does change
444
445 This invariant has several crucial consequences:
446
447 * In substTyVarBndr, we need extend the TvSubstEnv 
448         - if the unique has changed
449         - or if the kind has changed
450
451 * In substTyVar, we do not need to consult the in-scope set;
452   the TvSubstEnv is enough
453
454 * In substTy, substTheta, we can short-circuit when the TvSubstEnv is empty
455 \end{code}
456
457
458
459 %************************************************************************
460 %*                                                                      *
461                    Pretty-printing types
462
463        Defined very early because of debug printing in assertions
464 %*                                                                      *
465 %************************************************************************
466
467 @pprType@ is the standard @Type@ printer; the overloaded @ppr@ function is
468 defined to use this.  @pprParendType@ is the same, except it puts
469 parens around the type, except for the atomic cases.  @pprParendType@
470 works just by setting the initial context precedence very high.
471
472 \begin{code}
473 data Prec = TopPrec     -- No parens
474           | FunPrec     -- Function args; no parens for tycon apps
475           | TyConPrec   -- Tycon args; no parens for atomic
476           deriving( Eq, Ord )
477
478 maybeParen :: Prec -> Prec -> SDoc -> SDoc
479 maybeParen ctxt_prec inner_prec pretty
480   | ctxt_prec < inner_prec = pretty
481   | otherwise              = parens pretty
482
483 ------------------
484 pprType, pprParendType :: Type -> SDoc
485 pprType       ty = ppr_type TopPrec ty
486 pprParendType ty = ppr_type TyConPrec ty
487
488 pprTyLit :: TyLit -> SDoc
489 pprTyLit = ppr_tylit TopPrec
490
491 pprKind, pprParendKind :: Kind -> SDoc
492 pprKind       = pprType
493 pprParendKind = pprParendType
494
495 ------------------
496 pprEqPred :: Pair Type -> SDoc
497 -- NB: Maybe move to Coercion? It's only called after coercionKind anyway. 
498 pprEqPred (Pair ty1 ty2) 
499   = sep [ ppr_type FunPrec ty1
500         , nest 2 (ptext (sLit "~#"))
501         , ppr_type FunPrec ty2]
502     -- Precedence looks like (->) so that we get
503     --    Maybe a ~ Bool
504     --    (a->a) ~ Bool
505     -- Note parens on the latter!
506
507 ------------
508 pprClassPred :: Class -> [Type] -> SDoc
509 pprClassPred = ppr_class_pred ppr_type
510
511 ppr_class_pred :: (Prec -> a -> SDoc) -> Class -> [a] -> SDoc
512 ppr_class_pred pp clas tys = pprTypeNameApp TopPrec pp (getName clas) tys
513
514 ------------
515 pprTheta :: ThetaType -> SDoc
516 -- pprTheta [pred] = pprPred pred        -- I'm in two minds about this
517 pprTheta theta  = parens (sep (punctuate comma (map (ppr_type TopPrec) theta)))
518
519 pprThetaArrowTy :: ThetaType -> SDoc
520 pprThetaArrowTy []      = empty
521 pprThetaArrowTy [pred]
522       | noParenPred pred = ppr_type TopPrec pred <+> darrow
523 pprThetaArrowTy preds   = parens (fsep (punctuate comma (map (ppr_type TopPrec) preds)))
524                             <+> darrow
525     -- Notice 'fsep' here rather that 'sep', so that
526     -- type contexts don't get displayed in a giant column
527     -- Rather than
528     --  instance (Eq a,
529     --            Eq b,
530     --            Eq c,
531     --            Eq d,
532     --            Eq e,
533     --            Eq f,
534     --            Eq g,
535     --            Eq h,
536     --            Eq i,
537     --            Eq j,
538     --            Eq k,
539     --            Eq l) =>
540     --           Eq (a, b, c, d, e, f, g, h, i, j, k, l)
541     -- we get
542     --
543     --  instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i,
544     --            Eq j, Eq k, Eq l) =>
545     --           Eq (a, b, c, d, e, f, g, h, i, j, k, l)
546
547 ------------------
548 instance Outputable Type where
549     ppr ty = pprType ty
550
551 instance Outputable TyLit where
552    ppr = pprTyLit
553
554 ------------------
555         -- OK, here's the main printer
556
557 ppr_type :: Prec -> Type -> SDoc
558 ppr_type _ (TyVarTy tv)       = ppr_tvar tv
559
560 ppr_type _ (TyConApp tc [LitTy (StrTyLit n),ty])
561   | tc `hasKey` ipClassNameKey
562   = char '?' <> ftext n <> ptext (sLit "::") <> ppr_type TopPrec ty
563
564 ppr_type p (TyConApp tc tys)  = pprTcApp p ppr_type tc tys
565
566 ppr_type p (LitTy l)          = ppr_tylit p l
567 ppr_type p ty@(ForAllTy {})   = ppr_forall_type p ty
568
569 ppr_type p (AppTy t1 t2) = maybeParen p TyConPrec $
570                            pprType t1 <+> ppr_type TyConPrec t2
571
572 ppr_type p fun_ty@(FunTy ty1 ty2)
573   | isPredTy ty1
574   = ppr_forall_type p fun_ty
575   | otherwise
576   = pprArrowChain p (ppr_type FunPrec ty1 : ppr_fun_tail ty2)
577   where
578     -- We don't want to lose synonyms, so we mustn't use splitFunTys here.
579     ppr_fun_tail (FunTy ty1 ty2)
580       | not (isPredTy ty1) = ppr_type FunPrec ty1 : ppr_fun_tail ty2
581     ppr_fun_tail other_ty = [ppr_type TopPrec other_ty]
582
583
584 ppr_forall_type :: Prec -> Type -> SDoc
585 ppr_forall_type p ty
586   = maybeParen p FunPrec $ (ppr_sigma_type True ty)
587
588 ppr_tvar :: TyVar -> SDoc
589 ppr_tvar tv  -- Note [Infix type variables]
590   = parenSymOcc (getOccName tv) (ppr tv)
591
592 ppr_tylit :: Prec -> TyLit -> SDoc
593 ppr_tylit _ tl =
594   case tl of
595     NumTyLit n -> integer n
596     StrTyLit s -> text (show s)
597
598 -------------------
599 ppr_sigma_type :: Bool -> Type -> SDoc
600 -- Bool <=> Show the foralls
601 ppr_sigma_type show_foralls ty
602   =  sep [ if show_foralls then pprForAll tvs else empty
603         , pprThetaArrowTy ctxt
604         , pprType tau ]
605   where
606     (tvs,  rho) = split1 [] ty
607     (ctxt, tau) = split2 [] rho
608
609     split1 tvs (ForAllTy tv ty) = split1 (tv:tvs) ty
610     split1 tvs ty          = (reverse tvs, ty)
611  
612     split2 ps (ty1 `FunTy` ty2) | isPredTy ty1 = split2 (ty1:ps) ty2
613     split2 ps ty                               = (reverse ps, ty)
614
615
616 pprSigmaType :: Type -> SDoc
617 pprSigmaType ty = ppr_sigma_type opt_PprStyle_Debug ty
618
619 pprForAll :: [TyVar] -> SDoc
620 pprForAll []  = empty
621 pprForAll tvs = ptext (sLit "forall") <+> pprTvBndrs tvs <> dot
622
623 pprTvBndrs :: [TyVar] -> SDoc
624 pprTvBndrs tvs = sep (map pprTvBndr tvs)
625
626 pprTvBndr :: TyVar -> SDoc
627 pprTvBndr tv 
628   | isLiftedTypeKind kind = ppr_tvar tv
629   | otherwise             = parens (ppr_tvar tv <+> dcolon <+> pprKind kind)
630              where
631                kind = tyVarKind tv
632 \end{code}
633
634 Note [Infix type variables]
635 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
636 With TypeOperators you can say
637
638    f :: (a ~> b) -> b
639
640 and the (~>) is considered a type variable.  However, the type
641 pretty-printer in this module will just see (a ~> b) as
642
643    App (App (TyVarTy "~>") (TyVarTy "a")) (TyVarTy "b")
644
645 So it'll print the type in prefix form.  To avoid confusion we must
646 remember to parenthesise the operator, thus
647
648    (~>) a b -> b
649
650 See Trac #2766.
651
652 \begin{code}
653 pprTcApp :: Prec -> (Prec -> a -> SDoc) -> TyCon -> [a] -> SDoc
654 pprTcApp _ _ tc []      -- No brackets for SymOcc
655   = pp_nt_debug <> ppr tc
656   where
657    pp_nt_debug | isNewTyCon tc = ifPprDebug (if isRecursiveTyCon tc 
658                                              then ptext (sLit "<recnt>")
659                                              else ptext (sLit "<nt>"))
660                | otherwise     = empty
661
662 pprTcApp _ pp tc [ty]
663   | tc `hasKey` listTyConKey   = pprPromotionQuote tc <> brackets   (pp TopPrec ty)
664   | tc `hasKey` parrTyConKey   = pprPromotionQuote tc <> paBrackets (pp TopPrec ty)
665
666 pprTcApp p pp tc tys
667   | isTupleTyCon tc && tyConArity tc == length tys
668   = pprPromotionQuote tc <>
669     tupleParens (tupleTyConSort tc) (sep (punctuate comma (map (pp TopPrec) tys)))
670
671   | Just dc <- isPromotedDataCon_maybe tc
672   , let dc_tc = dataConTyCon dc
673   , isTupleTyCon dc_tc 
674   , let arity = tyConArity dc_tc    -- E.g. 3 for (,,) k1 k2 k3 t1 t2 t3
675         ty_args = drop arity tys    -- Drop the kind args
676   , ty_args `lengthIs` arity        -- Result is saturated
677   = pprPromotionQuote tc <>
678     (tupleParens (tupleTyConSort dc_tc) $
679      sep (punctuate comma (map (pp TopPrec) ty_args)))
680
681   | not opt_PprStyle_Debug
682   , getUnique tc `elem` [eqTyConKey, eqPrimTyConKey] 
683                            -- We need to special case the type equality TyCons because
684   , [_, ty1,ty2] <- tys    -- with kind polymorphism it has 3 args, so won't get printed infix
685                            -- With -dppr-debug switch this off so we can see the kind
686   = pprInfixApp p pp (ppr tc) ty1 ty2
687
688   | otherwise
689   = ppr_type_name_app p pp (ppr tc) (isSymOcc (getOccName tc)) tys
690
691 ----------------
692 pprTypeApp :: NamedThing a => a -> [Type] -> SDoc
693 -- The first arg is the tycon, or sometimes class
694 -- Print infix if the tycon/class looks like an operator
695 pprTypeApp tc tys 
696   = pprTypeNameApp TopPrec ppr_type (getName tc) tys
697
698 pprTypeNameApp :: Prec -> (Prec -> a -> SDoc) -> Name -> [a] -> SDoc
699 -- Used for classes and coercions as well as types; that's why it's separate from pprTcApp
700 pprTypeNameApp p pp name tys
701   = ppr_type_name_app p pp (ppr name) (isSymOcc (getOccName name)) tys
702
703 ppr_type_name_app :: Prec -> (Prec -> a -> SDoc) -> SDoc -> Bool -> [a] -> SDoc
704 ppr_type_name_app p pp pp_tc is_sym_occ tys
705   | is_sym_occ           -- Print infix if possible
706   , [ty1,ty2] <- tys  -- We know nothing of precedence though
707   = pprInfixApp p pp pp_tc ty1 ty2
708   | otherwise
709   = pprPrefixApp p (pprPrefixVar is_sym_occ pp_tc) (map (pp TyConPrec) tys)
710
711 ----------------
712 pprInfixApp :: Prec -> (Prec -> a -> SDoc) -> SDoc -> a -> a -> SDoc
713 pprInfixApp p pp pp_tc ty1 ty2
714   = maybeParen p FunPrec $
715     sep [pp FunPrec ty1, pprInfixVar True pp_tc <+> pp FunPrec ty2]
716
717 pprPrefixApp :: Prec -> SDoc -> [SDoc] -> SDoc
718 pprPrefixApp p pp_fun pp_tys = maybeParen p TyConPrec $
719                                hang pp_fun 2 (sep pp_tys)
720
721 ----------------
722 pprArrowChain :: Prec -> [SDoc] -> SDoc
723 -- pprArrowChain p [a,b,c]  generates   a -> b -> c
724 pprArrowChain _ []         = empty
725 pprArrowChain p (arg:args) = maybeParen p FunPrec $
726                              sep [arg, sep (map (arrow <+>) args)]
727 \end{code}
728