Use "true" rather than ":" for RANLIB, where we don't have ranlib
[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 #-}
11
12 module TypeRep (
13         TyThing(..), 
14         Type(..),
15         PredType(..),                   -- to friends
16         
17         Kind, ThetaType,                -- Synonyms
18
19         funTyCon, funTyConName,
20
21         -- Pretty-printing
22         pprType, pprParendType, pprTypeApp,
23         pprTyThing, pprTyThingCategory, 
24         pprPred, pprEqPred, pprTheta, pprForAll, pprThetaArrow, pprClassPred,
25
26         -- Kinds
27         liftedTypeKind, unliftedTypeKind, openTypeKind,
28         argTypeKind, ubxTupleKind,
29         isLiftedTypeKindCon, isLiftedTypeKind,
30         mkArrowKind, mkArrowKinds, isCoercionKind,
31         coVarPred,
32
33         -- Kind constructors...
34         liftedTypeKindTyCon, openTypeKindTyCon, unliftedTypeKindTyCon,
35         argTypeKindTyCon, ubxTupleKindTyCon,
36
37         -- And their names
38         unliftedTypeKindTyConName, openTypeKindTyConName,
39         ubxTupleKindTyConName, argTypeKindTyConName,
40         liftedTypeKindTyConName,
41
42         -- Super Kinds
43         tySuperKind, coSuperKind,
44         isTySuperKind, isCoSuperKind,
45         tySuperKindTyCon, coSuperKindTyCon,
46         
47         pprKind, pprParendKind
48     ) where
49
50 #include "HsVersions.h"
51
52 import {-# SOURCE #-} DataCon( DataCon, dataConName )
53
54 -- friends:
55 import Var
56 import Name
57 import BasicTypes
58 import TyCon
59 import Class
60
61 -- others
62 import PrelNames
63 import Outputable
64 import FastString
65
66 -- libraries
67 import Data.Data hiding ( TyCon )
68 \end{code}
69
70         ----------------------
71         A note about newtypes
72         ----------------------
73
74 Consider
75         newtype N = MkN Int
76
77 Then we want N to be represented as an Int, and that's what we arrange.
78 The front end of the compiler [TcType.lhs] treats N as opaque, 
79 the back end treats it as transparent [Type.lhs].
80
81 There's a bit of a problem with recursive newtypes
82         newtype P = MkP P
83         newtype Q = MkQ (Q->Q)
84
85 Here the 'implicit expansion' we get from treating P and Q as transparent
86 would give rise to infinite types, which in turn makes eqType diverge.
87 Similarly splitForAllTys and splitFunTys can get into a loop.  
88
89 Solution: 
90
91 * Newtypes are always represented using TyConApp.
92
93 * For non-recursive newtypes, P, treat P just like a type synonym after 
94   type-checking is done; i.e. it's opaque during type checking (functions
95   from TcType) but transparent afterwards (functions from Type).  
96   "Treat P as a type synonym" means "all functions expand NewTcApps 
97   on the fly".
98
99   Applications of the data constructor P simply vanish:
100         P x = x
101   
102
103 * For recursive newtypes Q, treat the Q and its representation as 
104   distinct right through the compiler.  Applications of the data consructor
105   use a coerce:
106         Q = \(x::Q->Q). coerce Q x
107   They are rare, so who cares if they are a tiny bit less efficient.
108
109 The typechecker (TcTyDecls) identifies enough type construtors as 'recursive'
110 to cut all loops.  The other members of the loop may be marked 'non-recursive'.
111
112
113 %************************************************************************
114 %*                                                                      *
115 \subsection{The data type}
116 %*                                                                      *
117 %************************************************************************
118
119
120 \begin{code}
121 -- | The key representation of types within the compiler
122 data Type
123   = TyVarTy TyVar       -- ^ Vanilla type variable
124
125   | AppTy
126         Type
127         Type            -- ^ Type application to something other than a 'TyCon'. Parameters:
128                         --
129                         --  1) Function: must /not/ be a 'TyConApp', must be another 'AppTy', or 'TyVarTy'
130                         --
131                         --  2) Argument type
132
133   | TyConApp
134         TyCon
135         [Type]          -- ^ Application of a 'TyCon', including newtypes /and/ synonyms.
136                         -- Invariant: saturated appliations of 'FunTyCon' must
137                         -- use 'FunTy' and saturated synonyms must use their own
138                         -- constructors. However, /unsaturated/ 'FunTyCon's do appear as 'TyConApp's.
139                         -- Parameters:
140                         --
141                         -- 1) Type constructor being applied to.
142                         --
143                         -- 2) Type arguments. Might not have enough type arguments here to saturate the constructor.
144                         -- Even type synonyms are not necessarily saturated; 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
151   | ForAllTy
152         TyVar
153         Type            -- ^ A polymorphic type
154
155   | PredTy
156         PredType        -- ^ The type of evidence for a type predictate.
157                         -- Note that a @PredTy (EqPred _ _)@ can appear only as the kind
158                         -- of a coercion variable; never as the argument or result
159                         -- of a 'FunTy' (unlike the 'PredType' constructors 'ClassP' or 'IParam')
160                         
161                         -- See Note [PredTy], and Note [Equality predicates]
162   deriving (Data, Typeable)
163
164 -- | The key type representing kinds in the compiler.
165 -- Invariant: a kind is always in one of these forms:
166 --
167 -- > FunTy k1 k2
168 -- > TyConApp PrimTyCon [...]
169 -- > TyVar kv   -- (during inference only)
170 -- > ForAll ... -- (for top-level coercions)
171 type Kind = Type
172
173 -- | "Super kinds", used to help encode 'Kind's as types.
174 -- Invariant: a super kind is always of this form:
175 --
176 -- > TyConApp SuperKindTyCon ...
177 type SuperKind = Type
178 \end{code}
179
180 -------------------------------------
181                 Note [PredTy]
182
183 \begin{code}
184 -- | A type of the form @PredTy p@ represents a value whose type is
185 -- the Haskell predicate @p@, where a predicate is what occurs before 
186 -- the @=>@ in a Haskell type.
187 -- It can be expanded into its representation, but: 
188 --
189 -- * The type checker must treat it as opaque
190 --
191 -- * The rest of the compiler treats it as transparent
192 --
193 -- Consider these examples:
194 --
195 -- > f :: (Eq a) => a -> Int
196 -- > g :: (?x :: Int -> Int) => a -> Int
197 -- > h :: (r\l) => {r} => {l::Int | r}
198 --
199 -- Here the @Eq a@ and @?x :: Int -> Int@ and @r\l@ are all called \"predicates\"
200 data PredType 
201   = ClassP Class [Type]         -- ^ Class predicate e.g. @Eq a@
202   | IParam (IPName Name) Type   -- ^ Implicit parameter e.g. @?x :: Int@
203   | EqPred Type Type            -- ^ Equality predicate e.g @ty1 ~ ty2@
204   deriving (Data, Typeable)
205
206 -- | A collection of 'PredType's
207 type ThetaType = [PredType]
208 \end{code}
209
210 (We don't support TREX records yet, but the setup is designed
211 to expand to allow them.)
212
213 A Haskell qualified type, such as that for f,g,h above, is
214 represented using 
215         * a FunTy for the double arrow
216         * with a PredTy as the function argument
217
218 The predicate really does turn into a real extra argument to the
219 function.  If the argument has type (PredTy p) then the predicate p is
220 represented by evidence (a dictionary, for example, of type (predRepTy p).
221
222 Note [Equality predicates]
223 ~~~~~~~~~~~~~~~~~~~~~~~~~~
224         forall a b. (a ~ S b) => a -> b
225 could be represented by
226         ForAllTy a (ForAllTy b (FunTy (PredTy (EqPred a (S b))) ...))
227 OR
228         ForAllTy a (ForAllTy b (ForAllTy (c::PredTy (EqPred a (S b))) ...))
229
230 The latter is what we do.  (Unlike for class and implicit parameter
231 constraints, which do use FunTy.)
232
233 Reason:
234         * FunTy is always a *value* function
235         * ForAllTy is discarded at runtime
236
237 We often need to make a "wildcard" (c::PredTy..).  We always use the same
238 name (wildCoVarName), since it's not mentioned.
239
240
241 %************************************************************************
242 %*                                                                      *
243                         TyThing
244 %*                                                                      *
245 %************************************************************************
246
247 Despite the fact that DataCon has to be imported via a hi-boot route, 
248 this module seems the right place for TyThing, because it's needed for
249 funTyCon and all the types in TysPrim.
250
251 \begin{code}
252 -- | A typecheckable-thing, essentially anything that has a name
253 data TyThing = AnId     Id
254              | ADataCon DataCon
255              | ATyCon   TyCon
256              | AClass   Class
257
258 instance Outputable TyThing where 
259   ppr = pprTyThing
260
261 pprTyThing :: TyThing -> SDoc
262 pprTyThing thing = pprTyThingCategory thing <+> quotes (ppr (getName thing))
263
264 pprTyThingCategory :: TyThing -> SDoc
265 pprTyThingCategory (ATyCon _)   = ptext (sLit "Type constructor")
266 pprTyThingCategory (AClass _)   = ptext (sLit "Class")
267 pprTyThingCategory (AnId   _)   = ptext (sLit "Identifier")
268 pprTyThingCategory (ADataCon _) = ptext (sLit "Data constructor")
269
270 instance NamedThing TyThing where       -- Can't put this with the type
271   getName (AnId id)     = getName id    -- decl, because the DataCon instance
272   getName (ATyCon tc)   = getName tc    -- isn't visible there
273   getName (AClass cl)   = getName cl
274   getName (ADataCon dc) = dataConName dc
275 \end{code}
276
277
278 %************************************************************************
279 %*                                                                      *
280                 Wired-in type constructors
281 %*                                                                      *
282 %************************************************************************
283
284 We define a few wired-in type constructors here to avoid module knots
285
286 \begin{code}
287 --------------------------
288 -- First the TyCons...
289
290 -- | See "Type#kind_subtyping" for details of the distinction between the 'Kind' 'TyCon's
291 funTyCon, tySuperKindTyCon, coSuperKindTyCon, liftedTypeKindTyCon,
292       openTypeKindTyCon, unliftedTypeKindTyCon,
293       ubxTupleKindTyCon, argTypeKindTyCon
294    :: TyCon
295 funTyConName, tySuperKindTyConName, coSuperKindTyConName, liftedTypeKindTyConName,
296       openTypeKindTyConName, unliftedTypeKindTyConName,
297       ubxTupleKindTyConName, argTypeKindTyConName
298    :: Name
299
300 funTyCon = mkFunTyCon funTyConName (mkArrowKinds [argTypeKind, openTypeKind] liftedTypeKind)
301         -- You might think that (->) should have type (?? -> ? -> *), and you'd be right
302         -- But if we do that we get kind errors when saying
303         --      instance Control.Arrow (->)
304         -- becuase the expected kind is (*->*->*).  The trouble is that the
305         -- expected/actual stuff in the unifier does not go contra-variant, whereas
306         -- the kind sub-typing does.  Sigh.  It really only matters if you use (->) in
307         -- a prefix way, thus:  (->) Int# Int#.  And this is unusual.
308
309
310 tySuperKindTyCon     = mkSuperKindTyCon tySuperKindTyConName
311 coSuperKindTyCon     = mkSuperKindTyCon coSuperKindTyConName
312
313 liftedTypeKindTyCon   = mkKindTyCon liftedTypeKindTyConName   tySuperKind
314 openTypeKindTyCon     = mkKindTyCon openTypeKindTyConName     tySuperKind
315 unliftedTypeKindTyCon = mkKindTyCon unliftedTypeKindTyConName tySuperKind
316 ubxTupleKindTyCon     = mkKindTyCon ubxTupleKindTyConName     tySuperKind
317 argTypeKindTyCon      = mkKindTyCon argTypeKindTyConName      tySuperKind
318
319 --------------------------
320 -- ... and now their names
321
322 tySuperKindTyConName      = mkPrimTyConName (fsLit "BOX") tySuperKindTyConKey tySuperKindTyCon
323 coSuperKindTyConName      = mkPrimTyConName (fsLit "COERCION") coSuperKindTyConKey coSuperKindTyCon
324 liftedTypeKindTyConName   = mkPrimTyConName (fsLit "*") liftedTypeKindTyConKey liftedTypeKindTyCon
325 openTypeKindTyConName     = mkPrimTyConName (fsLit "?") openTypeKindTyConKey openTypeKindTyCon
326 unliftedTypeKindTyConName = mkPrimTyConName (fsLit "#") unliftedTypeKindTyConKey unliftedTypeKindTyCon
327 ubxTupleKindTyConName     = mkPrimTyConName (fsLit "(#)") ubxTupleKindTyConKey ubxTupleKindTyCon
328 argTypeKindTyConName      = mkPrimTyConName (fsLit "??") argTypeKindTyConKey argTypeKindTyCon
329 funTyConName              = mkPrimTyConName (fsLit "(->)") funTyConKey funTyCon
330
331 mkPrimTyConName :: FastString -> Unique -> TyCon -> Name
332 mkPrimTyConName occ key tycon = mkWiredInName gHC_PRIM (mkTcOccFS occ) 
333                                               key 
334                                               (ATyCon tycon)
335                                               BuiltInSyntax
336         -- All of the super kinds and kinds are defined in Prim and use BuiltInSyntax,
337         -- because they are never in scope in the source
338
339 ------------------
340 -- We also need Kinds and SuperKinds, locally and in TyCon
341
342 kindTyConType :: TyCon -> Type
343 kindTyConType kind = TyConApp kind []
344
345 -- | See "Type#kind_subtyping" for details of the distinction between these 'Kind's
346 liftedTypeKind, unliftedTypeKind, openTypeKind, argTypeKind, ubxTupleKind :: Kind
347
348 liftedTypeKind   = kindTyConType liftedTypeKindTyCon
349 unliftedTypeKind = kindTyConType unliftedTypeKindTyCon
350 openTypeKind     = kindTyConType openTypeKindTyCon
351 argTypeKind      = kindTyConType argTypeKindTyCon
352 ubxTupleKind     = kindTyConType ubxTupleKindTyCon
353
354 -- | Given two kinds @k1@ and @k2@, creates the 'Kind' @k1 -> k2@
355 mkArrowKind :: Kind -> Kind -> Kind
356 mkArrowKind k1 k2 = FunTy k1 k2
357
358 -- | Iterated application of 'mkArrowKind'
359 mkArrowKinds :: [Kind] -> Kind -> Kind
360 mkArrowKinds arg_kinds result_kind = foldr mkArrowKind result_kind arg_kinds
361
362 tySuperKind, coSuperKind :: SuperKind
363 tySuperKind = kindTyConType tySuperKindTyCon 
364 coSuperKind = kindTyConType coSuperKindTyCon 
365
366 isTySuperKind :: SuperKind -> Bool
367 isTySuperKind (TyConApp kc []) = kc `hasKey` tySuperKindTyConKey
368 isTySuperKind _                = False
369
370 isCoSuperKind :: SuperKind -> Bool
371 isCoSuperKind (TyConApp kc []) = kc `hasKey` coSuperKindTyConKey
372 isCoSuperKind _                = False
373
374 -------------------
375 -- Lastly we need a few functions on Kinds
376
377 isLiftedTypeKindCon :: TyCon -> Bool
378 isLiftedTypeKindCon tc    = tc `hasKey` liftedTypeKindTyConKey
379
380 isLiftedTypeKind :: Kind -> Bool
381 isLiftedTypeKind (TyConApp tc []) = isLiftedTypeKindCon tc
382 isLiftedTypeKind _                = False
383
384 isCoercionKind :: Kind -> Bool
385 -- All coercions are of form (ty1 ~ ty2)
386 -- This function is here rather than in Coercion, 
387 -- because it's used in a knot-tied way to enforce invariants in Var
388 isCoercionKind (PredTy (EqPred {})) = True
389 isCoercionKind _                    = False
390
391 coVarPred :: CoVar -> PredType
392 coVarPred tv
393   = ASSERT( isCoVar tv )
394     case tyVarKind tv of
395         PredTy eq -> eq
396         other     -> pprPanic "coVarPred" (ppr tv $$ ppr other)
397 \end{code}
398
399
400
401 %************************************************************************
402 %*                                                                      *
403 \subsection{The external interface}
404 %*                                                                      *
405 %************************************************************************
406
407 @pprType@ is the standard @Type@ printer; the overloaded @ppr@ function is
408 defined to use this.  @pprParendType@ is the same, except it puts
409 parens around the type, except for the atomic cases.  @pprParendType@
410 works just by setting the initial context precedence very high.
411
412 \begin{code}
413 data Prec = TopPrec     -- No parens
414           | FunPrec     -- Function args; no parens for tycon apps
415           | TyConPrec   -- Tycon args; no parens for atomic
416           deriving( Eq, Ord )
417
418 maybeParen :: Prec -> Prec -> SDoc -> SDoc
419 maybeParen ctxt_prec inner_prec pretty
420   | ctxt_prec < inner_prec = pretty
421   | otherwise              = parens pretty
422
423 ------------------
424 pprType, pprParendType :: Type -> SDoc
425 pprType       ty = ppr_type TopPrec   ty
426 pprParendType ty = ppr_type TyConPrec ty
427
428 pprTypeApp :: NamedThing a => a -> [Type] -> SDoc
429 -- The first arg is the tycon, or sometimes class
430 -- Print infix if the tycon/class looks like an operator
431 pprTypeApp tc tys = ppr_type_app TopPrec (getName tc) tys
432
433 ------------------
434 pprPred :: PredType -> SDoc
435 pprPred (ClassP cls tys) = pprClassPred cls tys
436 pprPred (IParam ip ty)   = ppr ip <> dcolon <> pprType ty
437 pprPred (EqPred ty1 ty2) = pprEqPred (ty1,ty2)
438
439 pprEqPred :: (Type,Type) -> SDoc
440 pprEqPred (ty1,ty2) = sep [ ppr_type FunPrec ty1
441                           , nest 2 (ptext (sLit "~"))
442                           , ppr_type FunPrec ty2]
443                                -- Precedence looks like (->) so that we get
444                                --    Maybe a ~ Bool
445                                --    (a->a) ~ Bool
446                                -- Note parens on the latter!
447
448 pprClassPred :: Class -> [Type] -> SDoc
449 pprClassPred clas tys = ppr_type_app TopPrec (getName clas) tys
450
451 pprTheta :: ThetaType -> SDoc
452 -- pprTheta [pred] = pprPred pred        -- I'm in two minds about this
453 pprTheta theta  = parens (sep (punctuate comma (map pprPred theta)))
454
455 pprThetaArrow :: ThetaType -> SDoc
456 pprThetaArrow []     = empty
457 pprThetaArrow [pred] 
458   | noParenPred pred = pprPred pred <+> darrow
459 pprThetaArrow preds  = parens (sep (punctuate comma (map pprPred preds))) <+> darrow
460
461 noParenPred :: PredType -> Bool
462 -- A predicate that can appear without parens before a "=>"
463 --       C a => a -> a
464 --       a~b => a -> b
465 -- But   (?x::Int) => Int -> Int
466 noParenPred (ClassP {}) = True
467 noParenPred (EqPred {}) = True
468 noParenPred (IParam {}) = False
469
470 ------------------
471 instance Outputable Type where
472     ppr ty = pprType ty
473
474 instance Outputable PredType where
475     ppr = pprPred
476
477 instance Outputable name => OutputableBndr (IPName name) where
478     pprBndr _ n = ppr n -- Simple for now
479
480 ------------------
481         -- OK, here's the main printer
482
483 pprKind, pprParendKind :: Kind -> SDoc
484 pprKind = pprType
485 pprParendKind = pprParendType
486
487 ppr_type :: Prec -> Type -> SDoc
488 ppr_type _ (TyVarTy tv)       = ppr_tvar tv
489 ppr_type p (PredTy pred)      = maybeParen p TyConPrec $
490                                 ifPprDebug (ptext (sLit "<pred>")) <> (ppr pred)
491 ppr_type p (TyConApp tc tys)  = ppr_tc_app p tc tys
492
493 ppr_type p (AppTy t1 t2) = maybeParen p TyConPrec $
494                            pprType t1 <+> ppr_type TyConPrec t2
495
496 ppr_type p ty@(ForAllTy _ _)       = ppr_forall_type p ty
497 ppr_type p ty@(FunTy (PredTy _) _) = ppr_forall_type p ty
498
499 ppr_type p (FunTy ty1 ty2)
500   = -- We don't want to lose synonyms, so we mustn't use splitFunTys here.
501     maybeParen p FunPrec $
502     sep (ppr_type FunPrec ty1 : ppr_fun_tail ty2)
503   where
504     ppr_fun_tail (FunTy ty1 ty2) 
505       | not (is_pred ty1) = (arrow <+> ppr_type FunPrec ty1) : ppr_fun_tail ty2
506     ppr_fun_tail other_ty = [arrow <+> pprType other_ty]
507     is_pred (PredTy {}) = True
508     is_pred _           = False
509
510 ppr_forall_type :: Prec -> Type -> SDoc
511 ppr_forall_type p ty
512   = maybeParen p FunPrec $
513     sep [pprForAll tvs, pprThetaArrow ctxt, pprType tau]
514   where
515     (tvs,  rho) = split1 [] ty
516     (ctxt, tau) = split2 [] rho
517
518     -- We need to be extra careful here as equality constraints will occur as
519     -- type variables with an equality kind.  So, while collecting quantified
520     -- variables, we separate the coercion variables out and turn them into
521     -- equality predicates.
522     split1 tvs (ForAllTy tv ty) 
523       | not (isCoVar tv)     = split1 (tv:tvs) ty
524     split1 tvs ty            = (reverse tvs, ty)
525  
526     split2 ps (PredTy p `FunTy` ty) = split2 (p:ps) ty
527     split2 ps (ForAllTy tv ty) 
528         | isCoVar tv                = split2 (coVarPred tv : ps) ty
529     split2 ps ty                    = (reverse ps, ty)
530
531 ppr_tc_app :: Prec -> TyCon -> [Type] -> SDoc
532 ppr_tc_app _ tc []
533   = ppr_tc tc
534 ppr_tc_app _ tc [ty]
535   | tc `hasKey` listTyConKey = brackets (pprType ty)
536   | tc `hasKey` parrTyConKey = ptext (sLit "[:") <> pprType ty <> ptext (sLit ":]")
537   | tc `hasKey` liftedTypeKindTyConKey   = ptext (sLit "*")
538   | tc `hasKey` unliftedTypeKindTyConKey = ptext (sLit "#")
539   | tc `hasKey` openTypeKindTyConKey     = ptext (sLit "(?)")
540   | tc `hasKey` ubxTupleKindTyConKey     = ptext (sLit "(#)")
541   | tc `hasKey` argTypeKindTyConKey      = ptext (sLit "??")
542
543 ppr_tc_app p tc tys
544   | isTupleTyCon tc && tyConArity tc == length tys
545   = tupleParens (tupleTyConBoxity tc) (sep (punctuate comma (map pprType tys)))
546   | otherwise
547   = ppr_type_app p (getName tc) tys
548
549 ppr_type_app :: Prec -> Name -> [Type] -> SDoc
550 -- Used for classes as well as types; that's why it's separate from ppr_tc_app
551 ppr_type_app p tc tys
552   | is_sym_occ          -- Print infix if possible
553   , [ty1,ty2] <- tys    -- We know nothing of precedence though
554   = maybeParen p FunPrec (sep [ppr_type FunPrec ty1, 
555                                pprInfixVar True (ppr tc) <+> ppr_type FunPrec ty2])
556   | otherwise
557   = maybeParen p TyConPrec (hang (pprPrefixVar is_sym_occ (ppr tc))
558                                2 (sep (map pprParendType tys)))
559   where
560     is_sym_occ = isSymOcc (getOccName tc)
561
562 ppr_tc :: TyCon -> SDoc -- No brackets for SymOcc
563 ppr_tc tc 
564   = pp_nt_debug <> ppr tc
565   where
566    pp_nt_debug | isNewTyCon tc = ifPprDebug (if isRecursiveTyCon tc 
567                                              then ptext (sLit "<recnt>")
568                                              else ptext (sLit "<nt>"))
569                | otherwise     = empty
570
571 ppr_tvar :: TyVar -> SDoc
572 ppr_tvar tv  -- Note [Infix type variables]
573   | isSymOcc (getOccName tv)  = parens (ppr tv)
574   | otherwise                 = ppr tv
575
576 -------------------
577 pprForAll :: [TyVar] -> SDoc
578 pprForAll []  = empty
579 pprForAll tvs = ptext (sLit "forall") <+> sep (map pprTvBndr tvs) <> dot
580
581 pprTvBndr :: TyVar -> SDoc
582 pprTvBndr tv | isLiftedTypeKind kind = ppr_tvar tv
583              | otherwise             = parens (ppr_tvar tv <+> dcolon <+> pprKind kind)
584              where
585                kind = tyVarKind tv
586 \end{code}
587
588 Note [Infix type variables]
589 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
590 With TypeOperators you can say
591
592    f :: (a ~> b) -> b
593
594 and the (~>) is considered a type variable.  However, the type
595 pretty-printer in this module will just see (a ~> b) as
596
597    App (App (TyVarTy "~>") (TyVarTy "a")) (TyVarTy "b")
598
599 So it'll print the type in prefix form.  To avoid confusion we must
600 remember to parenthesise the operator, thus
601
602    (~>) a b -> b
603
604 See Trac #2766.
605
606
607
608