Refactoring around TyCon.isSynTyCon
[ghc.git] / compiler / types / TyCon.lhs
1 %
2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 %
5
6 The @TyCon@ datatype
7
8 \begin{code}
9 {-# LANGUAGE CPP, DeriveDataTypeable #-}
10
11 module TyCon(
12         -- * Main TyCon data types
13         TyCon, FieldLabel,
14
15         AlgTyConRhs(..), visibleDataCons,
16         TyConParent(..), isNoParent,
17         SynTyConRhs(..), Role(..),
18
19         -- ** Constructing TyCons
20         mkAlgTyCon,
21         mkClassTyCon,
22         mkFunTyCon,
23         mkPrimTyCon,
24         mkKindTyCon,
25         mkLiftedPrimTyCon,
26         mkTupleTyCon,
27         mkSynTyCon,
28         mkForeignTyCon,
29         mkPromotedDataCon,
30         mkPromotedTyCon,
31
32         -- ** Predicates on TyCons
33         isAlgTyCon,
34         isClassTyCon, isFamInstTyCon,
35         isFunTyCon,
36         isPrimTyCon,
37         isTupleTyCon, isUnboxedTupleTyCon, isBoxedTupleTyCon,
38         isSynTyCon, isTypeSynonymTyCon,
39         isDecomposableTyCon,
40         isForeignTyCon, 
41         isPromotedDataCon, isPromotedTyCon,
42         isPromotedDataCon_maybe, isPromotedTyCon_maybe,
43         promotableTyCon_maybe, promoteTyCon,
44
45         isDataTyCon, isProductTyCon, isDataProductTyCon_maybe,
46         isEnumerationTyCon,
47         isNewTyCon, isAbstractTyCon,
48         isFamilyTyCon, isOpenFamilyTyCon,
49         isSynFamilyTyCon, isDataFamilyTyCon,
50         isOpenSynFamilyTyCon, isClosedSynFamilyTyCon_maybe,
51         isBuiltInSynFamTyCon_maybe,
52         isUnLiftedTyCon,
53         isGadtSyntaxTyCon, isDistinctTyCon, isDistinctAlgRhs,
54         isTyConAssoc, tyConAssoc_maybe,
55         isRecursiveTyCon,
56         isImplicitTyCon,
57
58         -- ** Extracting information out of TyCons
59         tyConName,
60         tyConKind,
61         tyConUnique,
62         tyConTyVars,
63         tyConCType, tyConCType_maybe,
64         tyConDataCons, tyConDataCons_maybe, 
65         tyConSingleDataCon_maybe, tyConSingleAlgDataCon_maybe,
66         tyConFamilySize,
67         tyConStupidTheta,
68         tyConArity,
69         tyConRoles,
70         tyConParent,
71         tyConTuple_maybe, tyConClass_maybe,
72         tyConFamInst_maybe, tyConFamInstSig_maybe, tyConFamilyCoercion_maybe,
73         synTyConDefn_maybe, synTyConRhs_maybe, 
74         tyConExtName,           -- External name for foreign types
75         algTyConRhs,
76         newTyConRhs, newTyConEtadArity, newTyConEtadRhs, unwrapNewTyCon_maybe,
77         tupleTyConBoxity, tupleTyConSort, tupleTyConArity,
78
79         -- ** Manipulating TyCons
80         tcExpandTyCon_maybe, coreExpandTyCon_maybe,
81         makeTyConAbstract,
82         newTyConCo, newTyConCo_maybe,
83         pprPromotionQuote,
84
85         -- * Primitive representations of Types
86         PrimRep(..), PrimElemRep(..),
87         tyConPrimRep, isVoidRep, isGcPtrRep,
88         primRepSizeW, primElemRepSizeB,
89
90         -- * Recursion breaking
91         RecTcChecker, initRecTc, checkRecTc
92
93 ) where
94
95 #include "HsVersions.h"
96
97 import {-# SOURCE #-} TypeRep ( Kind, Type, PredType )
98 import {-# SOURCE #-} DataCon ( DataCon, isVanillaDataCon )
99
100 import Var
101 import Class
102 import BasicTypes
103 import DynFlags
104 import ForeignCall
105 import Name
106 import NameSet
107 import CoAxiom
108 import PrelNames
109 import Maybes
110 import Outputable
111 import FastString
112 import Constants
113 import Util
114 import qualified Data.Data as Data
115 import Data.Typeable (Typeable)
116 \end{code}
117
118 -----------------------------------------------
119         Notes about type families
120 -----------------------------------------------
121
122 Note [Type synonym families]
123 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
124 * Type synonym families, also known as "type functions", map directly
125   onto the type functions in FC:
126
127         type family F a :: *
128         type instance F Int = Bool
129         ..etc...
130
131 * Reply "yes" to isSynFamilyTyCon, and isFamilyTyCon
132
133 * From the user's point of view (F Int) and Bool are simply
134   equivalent types.
135
136 * A Haskell 98 type synonym is a degenerate form of a type synonym
137   family.
138
139 * Type functions can't appear in the LHS of a type function:
140         type instance F (F Int) = ...   -- BAD!
141
142 * Translation of type family decl:
143         type family F a :: *
144   translates to
145     a SynTyCon 'F', whose SynTyConRhs is OpenSynFamilyTyCon
146
147         type family G a :: * where
148           G Int = Bool
149           G Bool = Char
150           G a = ()
151   translates to
152     a SynTyCon 'G', whose SynTyConRhs is ClosedSynFamilyTyCon, with the
153     appropriate CoAxiom representing the equations
154
155 * In the future we might want to support
156     * injective type families (allow decomposition)
157   but we don't at the moment [2013]
158
159 Note [Data type families]
160 ~~~~~~~~~~~~~~~~~~~~~~~~~
161 See also Note [Wrappers for data instance tycons] in MkId.lhs
162
163 * Data type families are declared thus
164         data family T a :: *
165         data instance T Int = T1 | T2 Bool
166
167   Here T is the "family TyCon".
168
169 * Reply "yes" to isDataFamilyTyCon, and isFamilyTyCon
170
171 * The user does not see any "equivalent types" as he did with type
172   synonym families.  He just sees constructors with types
173         T1 :: T Int
174         T2 :: Bool -> T Int
175
176 * Here's the FC version of the above declarations:
177
178         data T a
179         data R:TInt = T1 | T2 Bool
180         axiom ax_ti : T Int ~ R:TInt
181
182   The R:TInt is the "representation TyCons".
183   It has an AlgTyConParent of
184         FamInstTyCon T [Int] ax_ti
185
186 * The data contructor T2 has a wrapper (which is what the
187   source-level "T2" invokes):
188
189         $WT2 :: Bool -> T Int
190         $WT2 b = T2 b `cast` sym ax_ti
191
192 * A data instance can declare a fully-fledged GADT:
193
194         data instance T (a,b) where
195           X1 :: T (Int,Bool)
196           X2 :: a -> b -> T (a,b)
197
198   Here's the FC version of the above declaration:
199
200         data R:TPair a where
201           X1 :: R:TPair Int Bool
202           X2 :: a -> b -> R:TPair a b
203         axiom ax_pr :: T (a,b) ~ R:TPair a b
204
205         $WX1 :: forall a b. a -> b -> T (a,b)
206         $WX1 a b (x::a) (y::b) = X2 a b x y `cast` sym (ax_pr a b)
207
208   The R:TPair are the "representation TyCons".
209   We have a bit of work to do, to unpick the result types of the
210   data instance declaration for T (a,b), to get the result type in the
211   representation; e.g.  T (a,b) --> R:TPair a b
212
213   The representation TyCon R:TList, has an AlgTyConParent of
214
215         FamInstTyCon T [(a,b)] ax_pr
216
217 * Notice that T is NOT translated to a FC type function; it just
218   becomes a "data type" with no constructors, which can be coerced inot
219   into R:TInt, R:TPair by the axioms.  These axioms
220   axioms come into play when (and *only* when) you
221         - use a data constructor
222         - do pattern matching
223   Rather like newtype, in fact
224
225   As a result
226
227   - T behaves just like a data type so far as decomposition is concerned
228
229   - (T Int) is not implicitly converted to R:TInt during type inference.
230     Indeed the latter type is unknown to the programmer.
231
232   - There *is* an instance for (T Int) in the type-family instance
233     environment, but it is only used for overlap checking
234
235   - It's fine to have T in the LHS of a type function:
236     type instance F (T a) = [a]
237
238   It was this last point that confused me!  The big thing is that you
239   should not think of a data family T as a *type function* at all, not
240   even an injective one!  We can't allow even injective type functions
241   on the LHS of a type function:
242         type family injective G a :: *
243         type instance F (G Int) = Bool
244   is no good, even if G is injective, because consider
245         type instance G Int = Bool
246         type instance F Bool = Char
247
248   So a data type family is not an injective type function. It's just a
249   data type with some axioms that connect it to other data types.
250
251 Note [Associated families and their parent class]
252 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
253 *Associated* families are just like *non-associated* families, except
254 that they have a TyConParent of AssocFamilyTyCon, which identifies the
255 parent class.
256
257 However there is an important sharing relationship between
258   * the tyConTyVars of the parent Class
259   * the tyConTyvars of the associated TyCon
260
261    class C a b where
262      data T p a
263      type F a q b
264
265 Here the 'a' and 'b' are shared with the 'Class'; that is, they have
266 the same Unique.
267
268 This is important. In an instance declaration we expect
269   * all the shared variables to be instantiated the same way
270   * the non-shared variables of the associated type should not
271     be instantiated at all
272
273   instance C [x] (Tree y) where
274      data T p [x] = T1 x | T2 p
275      type F [x] q (Tree y) = (x,y,q)
276
277 Note [TyCon Role signatures]
278 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
279
280 Every tycon has a role signature, assigning a role to each of the tyConTyVars
281 (or of equal length to the tyConArity, if there are no tyConTyVars). An
282 example demonstrates these best: say we have a tycon T, with parameters a at
283 nominal, b at representational, and c at phantom. Then, to prove
284 representational equality between T a1 b1 c1 and T a2 b2 c2, we need to have
285 nominal equality between a1 and a2, representational equality between b1 and
286 b2, and nothing in particular (i.e., phantom equality) between c1 and c2. This
287 might happen, say, with the following declaration:
288
289   data T a b c where
290     MkT :: b -> T Int b c
291
292 Data and class tycons have their roles inferred (see inferRoles in TcTyDecls),
293 as do vanilla synonym tycons. Family tycons have all parameters at role N,
294 though it is conceivable that we could relax this restriction. (->)'s and
295 tuples' parameters are at role R. Each primitive tycon declares its roles;
296 it's worth noting that (~#)'s parameters are at role N. Promoted data
297 constructors' type arguments are at role R. All kind arguments are at role
298 N.
299
300 %************************************************************************
301 %*                                                                      *
302 \subsection{The data type}
303 %*                                                                      *
304 %************************************************************************
305
306 \begin{code}
307 -- | TyCons represent type constructors. Type constructors are introduced by things such as:
308 --
309 -- 1) Data declarations: @data Foo = ...@ creates the @Foo@ type constructor of kind @*@
310 --
311 -- 2) Type synonyms: @type Foo = ...@ creates the @Foo@ type constructor
312 --
313 -- 3) Newtypes: @newtype Foo a = MkFoo ...@ creates the @Foo@ type constructor of kind @* -> *@
314 --
315 -- 4) Class declarations: @class Foo where@ creates the @Foo@ type constructor of kind @*@
316 --
317 -- This data type also encodes a number of primitive, built in type constructors such as those
318 -- for function and tuple types.
319
320 -- If you edit this type, you may need to update the GHC formalism
321 -- See Note [GHC Formalism] in coreSyn/CoreLint.lhs
322 data TyCon
323   = -- | The function type constructor, @(->)@
324     FunTyCon {
325         tyConUnique :: Unique,
326         tyConName   :: Name,
327         tc_kind   :: Kind,
328         tyConArity  :: Arity
329     }
330
331   -- | Algebraic type constructors, which are defined to be those
332   -- arising @data@ type and @newtype@ declarations.  All these
333   -- constructors are lifted and boxed. See 'AlgTyConRhs' for more
334   -- information.
335   | AlgTyCon {
336         tyConUnique :: Unique,
337         tyConName   :: Name,
338         tc_kind     :: Kind,
339         tyConArity  :: Arity,
340
341         tyConTyVars :: [TyVar],   -- ^ The kind and type variables used in the type constructor.
342                                   -- Invariant: length tyvars = arity
343                                   -- Precisely, this list scopes over:
344                                   --
345                                   -- 1. The 'algTcStupidTheta'
346                                   -- 2. The cached types in 'algTyConRhs.NewTyCon'
347                                   -- 3. The family instance types if present
348                                   --
349                                   -- Note that it does /not/ scope over the data constructors.
350         tc_roles     :: [Role],   -- ^ The role for each type variable
351                                   -- This list has the same length as tyConTyVars
352                                   -- See also Note [TyCon Role signatures]
353         
354         tyConCType   :: Maybe CType, -- The C type that should be used
355                                      -- for this type when using the FFI
356                                      -- and CAPI
357
358         algTcGadtSyntax  :: Bool,       -- ^ Was the data type declared with GADT syntax?
359                                         -- If so, that doesn't mean it's a true GADT;
360                                         -- only that the "where" form was used.
361                                         -- This field is used only to guide pretty-printing
362
363         algTcStupidTheta :: [PredType], -- ^ The \"stupid theta\" for the data type
364                                         -- (always empty for GADTs).
365                                         -- A \"stupid theta\" is the context to the left
366                                         -- of an algebraic type declaration,
367                                         -- e.g. @Eq a@ in the declaration
368                                         --    @data Eq a => T a ...@.
369
370         algTcRhs :: AlgTyConRhs,  -- ^ Contains information about the
371                                   -- data constructors of the algebraic type
372
373         algTcRec :: RecFlag,      -- ^ Tells us whether the data type is part
374                                   -- of a mutually-recursive group or not
375
376         algTcParent :: TyConParent,     -- ^ Gives the class or family declaration 'TyCon'
377                                         -- for derived 'TyCon's representing class
378                                         -- or family instances, respectively.
379                                         -- See also 'synTcParent'
380         
381         tcPromoted :: Maybe TyCon    -- ^ Promoted TyCon, if any
382     }
383
384   -- | Represents the infinite family of tuple type constructors,
385   --   @()@, @(a,b)@, @(# a, b #)@ etc.
386   | TupleTyCon {
387         tyConUnique    :: Unique,
388         tyConName      :: Name,
389         tc_kind        :: Kind,
390         tyConArity     :: Arity,
391         tyConTupleSort :: TupleSort,
392         tyConTyVars    :: [TyVar],
393         dataCon        :: DataCon, -- ^ Corresponding tuple data constructor
394         tcPromoted     :: Maybe TyCon    -- Nothing for unboxed tuples
395     }
396
397   -- | Represents type synonyms
398   | SynTyCon {
399         tyConUnique  :: Unique,
400         tyConName    :: Name,
401         tc_kind    :: Kind,
402         tyConArity   :: Arity,
403
404         tyConTyVars  :: [TyVar],        -- Bound tyvars
405         tc_roles     :: [Role],
406
407         synTcRhs     :: SynTyConRhs,       -- ^ Contains information about the
408                                            -- expansion of the synonym
409
410         synTcParent  :: TyConParent     -- ^ Gives the family declaration 'TyCon'
411                                         -- of 'TyCon's representing family instances
412
413     }
414
415   -- | Primitive types; cannot be defined in Haskell. This includes
416   -- the usual suspects (such as @Int#@) as well as foreign-imported
417   -- types and kinds
418   | PrimTyCon {
419         tyConUnique   :: Unique,
420         tyConName     :: Name,
421         tc_kind       :: Kind,
422         tyConArity    :: Arity,         
423         tc_roles      :: [Role],
424
425         primTyConRep  :: PrimRep,       -- ^ Many primitive tycons are unboxed, but some are
426                                         --   boxed (represented by pointers). This 'PrimRep'
427                                         --   holds that information.
428                                         -- Only relevant if tc_kind = *
429
430         isUnLifted   :: Bool,           -- ^ Most primitive tycons are unlifted
431                                         --   (may not contain bottom)
432                                         --   but foreign-imported ones may be lifted
433
434         tyConExtName :: Maybe FastString   -- ^ @Just e@ for foreign-imported types,
435                                            --   holds the name of the imported thing
436     }
437
438   -- | Represents promoted data constructor.
439   | PromotedDataCon {         -- See Note [Promoted data constructors]
440         tyConUnique :: Unique, -- ^ Same Unique as the data constructor
441         tyConName   :: Name,   -- ^ Same Name as the data constructor
442         tyConArity  :: Arity,
443         tc_roles    :: [Role], -- ^ Roles: N for kind vars, R for type vars
444         tc_kind     :: Kind,   -- ^ Translated type of the data constructor
445         dataCon     :: DataCon -- ^ Corresponding data constructor
446     }
447
448   -- | Represents promoted type constructor.
449   | PromotedTyCon {
450         tyConUnique :: Unique, -- ^ Same Unique as the type constructor
451         tyConName   :: Name,   -- ^ Same Name as the type constructor
452         tyConArity  :: Arity,  -- ^ n if ty_con :: * -> ... -> *  n times
453         tc_kind     :: Kind,   -- ^ Always TysPrim.superKind
454         ty_con      :: TyCon   -- ^ Corresponding type constructor
455     }
456
457   deriving Typeable
458
459 -- | Names of the fields in an algebraic record type
460 type FieldLabel = Name
461
462 -- | Represents right-hand-sides of 'TyCon's for algebraic types
463 data AlgTyConRhs
464
465     -- | Says that we know nothing about this data type, except that
466     -- it's represented by a pointer.  Used when we export a data type
467     -- abstractly into an .hi file.
468   = AbstractTyCon
469       Bool      -- True  <=> It's definitely a distinct data type,
470                 --           equal only to itself; ie not a newtype
471                 -- False <=> Not sure
472                 -- See Note [AbstractTyCon and type equality]
473
474     -- | Represents an open type family without a fixed right hand
475     -- side.  Additional instances can appear at any time.
476     --
477     -- These are introduced by either a top level declaration:
478     --
479     -- > data T a :: *
480     --
481     -- Or an associated data type declaration, within a class declaration:
482     --
483     -- > class C a b where
484     -- >   data T b :: *
485   | DataFamilyTyCon
486
487     -- | Information about those 'TyCon's derived from a @data@
488     -- declaration. This includes data types with no constructors at
489     -- all.
490   | DataTyCon {
491         data_cons :: [DataCon],
492                           -- ^ The data type constructors; can be empty if the user
493                           --   declares the type to have no constructors
494                           --
495                           -- INVARIANT: Kept in order of increasing 'DataCon' tag
496                           --      (see the tag assignment in DataCon.mkDataCon)
497
498         is_enum :: Bool   -- ^ Cached value: is this an enumeration type?
499                           --   See Note [Enumeration types]
500     }
501
502   -- | Information about those 'TyCon's derived from a @newtype@ declaration
503   | NewTyCon {
504         data_con :: DataCon,    -- ^ The unique constructor for the @newtype@.
505                                 --   It has no existentials
506
507         nt_rhs :: Type,         -- ^ Cached value: the argument type of the constructor,
508                                 -- which is just the representation type of the 'TyCon'
509                                 -- (remember that @newtype@s do not exist at runtime
510                                 -- so need a different representation type).
511                                 --
512                                 -- The free 'TyVar's of this type are the 'tyConTyVars'
513                                 -- from the corresponding 'TyCon'
514
515         nt_etad_rhs :: ([TyVar], Type),
516                         -- ^ Same as the 'nt_rhs', but this time eta-reduced.
517                         -- Hence the list of 'TyVar's in this field may be
518                         -- shorter than the declared arity of the 'TyCon'.
519
520                         -- See Note [Newtype eta]
521         nt_co :: CoAxiom Unbranched
522                              -- The axiom coercion that creates the @newtype@ from
523                              -- the representation 'Type'.
524
525                              -- See Note [Newtype coercions]
526                              -- Invariant: arity = #tvs in nt_etad_rhs;
527                              -- See Note [Newtype eta]
528                              -- Watch out!  If any newtypes become transparent
529                              -- again check Trac #1072.
530     }
531
532 \end{code}
533
534 Note [AbstractTyCon and type equality]
535 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
536 TODO
537
538 \begin{code}
539
540 -- | Extract those 'DataCon's that we are able to learn about.  Note
541 -- that visibility in this sense does not correspond to visibility in
542 -- the context of any particular user program!
543 visibleDataCons :: AlgTyConRhs -> [DataCon]
544 visibleDataCons (AbstractTyCon {})            = []
545 visibleDataCons DataFamilyTyCon {}            = []
546 visibleDataCons (DataTyCon{ data_cons = cs }) = cs
547 visibleDataCons (NewTyCon{ data_con = c })    = [c]
548
549 -- ^ Both type classes as well as family instances imply implicit
550 -- type constructors.  These implicit type constructors refer to their parent
551 -- structure (ie, the class or family from which they derive) using a type of
552 -- the following form.  We use 'TyConParent' for both algebraic and synonym
553 -- types, but the variant 'ClassTyCon' will only be used by algebraic 'TyCon's.
554 data TyConParent
555   = -- | An ordinary type constructor has no parent.
556     NoParentTyCon
557
558   -- | Type constructors representing a class dictionary.
559   -- See Note [ATyCon for classes] in TypeRep
560   | ClassTyCon
561         Class           -- INVARIANT: the classTyCon of this Class is the current tycon
562
563   -- | An *associated* type of a class.
564   | AssocFamilyTyCon
565         Class           -- The class in whose declaration the family is declared
566                         -- See Note [Associated families and their parent class]
567
568   -- | Type constructors representing an instance of a *data* family. Parameters:
569   --
570   --  1) The type family in question
571   --
572   --  2) Instance types; free variables are the 'tyConTyVars'
573   --  of the current 'TyCon' (not the family one). INVARIANT:
574   --  the number of types matches the arity of the family 'TyCon'
575   --
576   --  3) A 'CoTyCon' identifying the representation
577   --  type with the type instance family
578   | FamInstTyCon          -- See Note [Data type families]
579         (CoAxiom Unbranched)  -- The coercion constructor,
580                               -- always of kind   T ty1 ty2 ~ R:T a b c
581                               -- where T is the family TyCon,
582                               -- and R:T is the representation TyCon (ie this one)
583                               -- and a,b,c are the tyConTyVars of this TyCon
584
585           -- Cached fields of the CoAxiom, but adjusted to
586           -- use the tyConTyVars of this TyCon
587         TyCon   -- The family TyCon
588         [Type]  -- Argument types (mentions the tyConTyVars of this TyCon)
589                 -- Match in length the tyConTyVars of the family TyCon
590
591         -- E.g.  data intance T [a] = ...
592         -- gives a representation tycon:
593         --      data R:TList a = ...
594         --      axiom co a :: T [a] ~ R:TList a
595         -- with R:TList's algTcParent = FamInstTyCon T [a] co
596
597 instance Outputable TyConParent where
598     ppr NoParentTyCon           = text "No parent"
599     ppr (ClassTyCon cls)        = text "Class parent" <+> ppr cls
600     ppr (AssocFamilyTyCon cls)  = text "Class parent (assoc. family)" <+> ppr cls
601     ppr (FamInstTyCon _ tc tys) = text "Family parent (family instance)" <+> ppr tc <+> sep (map ppr tys)
602
603 -- | Checks the invariants of a 'TyConParent' given the appropriate type class name, if any
604 okParent :: Name -> TyConParent -> Bool
605 okParent _       NoParentTyCon               = True
606 okParent tc_name (AssocFamilyTyCon cls)      = tc_name `elem` map tyConName (classATs cls)
607 okParent tc_name (ClassTyCon cls)            = tc_name == tyConName (classTyCon cls)
608 okParent _       (FamInstTyCon _ fam_tc tys) = tyConArity fam_tc == length tys
609
610 isNoParent :: TyConParent -> Bool
611 isNoParent NoParentTyCon = True
612 isNoParent _             = False
613
614 --------------------
615
616 -- | Information pertaining to the expansion of a type synonym (@type@)
617 data SynTyConRhs
618   = -- | An ordinary type synonyn.
619     SynonymTyCon
620        Type           -- This 'Type' is the rhs, and may mention from 'tyConTyVars'.
621                       -- It acts as a template for the expansion when the 'TyCon'
622                       -- is applied to some types.
623
624    -- | An open type synonym family  e.g. @type family F x y :: * -> *@
625    | OpenSynFamilyTyCon 
626
627    -- | A closed type synonym family  e.g. @type family F x where { F Int = Bool }@
628    | ClosedSynFamilyTyCon
629        (CoAxiom Branched) -- The one axiom for this family
630
631    -- | A closed type synonym family declared in an hs-boot file with
632    -- type family F a where ..
633    | AbstractClosedSynFamilyTyCon
634
635    | BuiltInSynFamTyCon BuiltInSynFamily
636 \end{code}
637
638 Note [Closed type families]
639 ~~~~~~~~~~~~~~~~~~~~~~~~~
640 * In an open type family you can add new instances later.  This is the 
641   usual case.  
642
643 * In a closed type family you can only put equations where the family
644   is defined.
645
646
647 Note [Promoted data constructors]
648 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
649 A data constructor can be promoted to become a type constructor,
650 via the PromotedTyCon alternative in TyCon.
651
652 * Only data constructors with  
653      (a) no kind polymorphism
654      (b) no constraints in its type (eg GADTs)
655   are promoted.  Existentials are ok; see Trac #7347.
656
657 * The TyCon promoted from a DataCon has the *same* Name and Unique as
658   the DataCon.  Eg. If the data constructor Data.Maybe.Just(unique 78,
659   say) is promoted to a TyCon whose name is Data.Maybe.Just(unique 78)
660
661 * The *kind* of a promoted DataCon may be polymorphic.  Example:
662     type of DataCon           Just :: forall (a:*). a -> Maybe a
663     kind of (promoted) tycon  Just :: forall (a:box). a -> Maybe a
664   The kind is not identical to the type, because of the */box
665   kind signature on the forall'd variable; so the tc_kind field of
666   PromotedTyCon is not identical to the dataConUserType of the
667   DataCon.  But it's the same modulo changing the variable kinds,
668   done by DataCon.promoteType.
669
670 * Small note: We promote the *user* type of the DataCon.  Eg
671      data T = MkT {-# UNPACK #-} !(Bool, Bool)
672   The promoted kind is
673      MkT :: (Bool,Bool) -> T
674   *not*
675      MkT :: Bool -> Bool -> T
676
677 Note [Enumeration types]
678 ~~~~~~~~~~~~~~~~~~~~~~~~
679 We define datatypes with no constructors to *not* be
680 enumerations; this fixes trac #2578,  Otherwise we
681 end up generating an empty table for
682   <mod>_<type>_closure_tbl
683 which is used by tagToEnum# to map Int# to constructors
684 in an enumeration. The empty table apparently upset
685 the linker.
686
687 Moreover, all the data constructor must be enumerations, meaning
688 they have type  (forall abc. T a b c).  GADTs are not enumerations.
689 For example consider
690     data T a where
691       T1 :: T Int
692       T2 :: T Bool
693       T3 :: T a
694 What would [T1 ..] be?  [T1,T3] :: T Int? Easiest thing is to exclude them.
695 See Trac #4528.
696
697 Note [Newtype coercions]
698 ~~~~~~~~~~~~~~~~~~~~~~~~
699 The NewTyCon field nt_co is a CoAxiom which is used for coercing from
700 the representation type of the newtype, to the newtype itself. For
701 example,
702
703    newtype T a = MkT (a -> a)
704
705 the NewTyCon for T will contain nt_co = CoT where CoT t : T t ~ t -> t.
706
707 In the case that the right hand side is a type application
708 ending with the same type variables as the left hand side, we
709 "eta-contract" the coercion.  So if we had
710
711    newtype S a = MkT [a]
712
713 then we would generate the arity 0 axiom CoS : S ~ [].  The
714 primary reason we do this is to make newtype deriving cleaner.
715
716 In the paper we'd write
717         axiom CoT : (forall t. T t) ~ (forall t. [t])
718 and then when we used CoT at a particular type, s, we'd say
719         CoT @ s
720 which encodes as (TyConApp instCoercionTyCon [TyConApp CoT [], s])
721
722 Note [Newtype eta]
723 ~~~~~~~~~~~~~~~~~~
724 Consider
725         newtype Parser a = MkParser (IO a) derriving( Monad )
726 Are these two types equal (to Core)?
727         Monad Parser
728         Monad IO
729 which we need to make the derived instance for Monad Parser.
730
731 Well, yes.  But to see that easily we eta-reduce the RHS type of
732 Parser, in this case to ([], Froogle), so that even unsaturated applications
733 of Parser will work right.  This eta reduction is done when the type
734 constructor is built, and cached in NewTyCon.  The cached field is
735 only used in coreExpandTyCon_maybe.
736
737 Here's an example that I think showed up in practice
738 Source code:
739         newtype T a = MkT [a]
740         newtype Foo m = MkFoo (forall a. m a -> Int)
741
742         w1 :: Foo []
743         w1 = ...
744
745         w2 :: Foo T
746         w2 = MkFoo (\(MkT x) -> case w1 of MkFoo f -> f x)
747
748 After desugaring, and discarding the data constructors for the newtypes,
749 we get:
750         w2 :: Foo T
751         w2 = w1
752 And now Lint complains unless Foo T == Foo [], and that requires T==[]
753
754 This point carries over to the newtype coercion, because we need to
755 say
756         w2 = w1 `cast` Foo CoT
757
758 so the coercion tycon CoT must have
759         kind:    T ~ []
760  and    arity:   0
761
762 %************************************************************************
763 %*                                                                      *
764 \subsection{PrimRep}
765 %*                                                                      *
766 %************************************************************************
767
768 Note [rep swamp]
769
770 GHC has a rich selection of types that represent "primitive types" of
771 one kind or another.  Each of them makes a different set of
772 distinctions, and mostly the differences are for good reasons,
773 although it's probably true that we could merge some of these.
774
775 Roughly in order of "includes more information":
776
777  - A Width (cmm/CmmType) is simply a binary value with the specified
778    number of bits.  It may represent a signed or unsigned integer, a
779    floating-point value, or an address.
780
781     data Width = W8 | W16 | W32 | W64 | W80 | W128
782
783  - Size, which is used in the native code generator, is Width +
784    floating point information.
785
786    data Size = II8 | II16 | II32 | II64 | FF32 | FF64 | FF80
787
788    it is necessary because e.g. the instruction to move a 64-bit float
789    on x86 (movsd) is different from the instruction to move a 64-bit
790    integer (movq), so the mov instruction is parameterised by Size.
791
792  - CmmType wraps Width with more information: GC ptr, float, or
793    other value.
794
795     data CmmType = CmmType CmmCat Width
796     
797     data CmmCat     -- "Category" (not exported)
798        = GcPtrCat   -- GC pointer
799        | BitsCat    -- Non-pointer
800        | FloatCat   -- Float
801
802    It is important to have GcPtr information in Cmm, since we generate
803    info tables containing pointerhood for the GC from this.  As for
804    why we have float (and not signed/unsigned) here, see Note [Signed
805    vs unsigned].
806
807  - ArgRep makes only the distinctions necessary for the call and
808    return conventions of the STG machine.  It is essentially CmmType
809    + void.
810
811  - PrimRep makes a few more distinctions than ArgRep: it divides
812    non-GC-pointers into signed/unsigned and addresses, information
813    that is necessary for passing these values to foreign functions.
814
815 There's another tension here: whether the type encodes its size in
816 bytes, or whether its size depends on the machine word size.  Width
817 and CmmType have the size built-in, whereas ArgRep and PrimRep do not.
818
819 This means to turn an ArgRep/PrimRep into a CmmType requires DynFlags.
820
821 On the other hand, CmmType includes some "nonsense" values, such as
822 CmmType GcPtrCat W32 on a 64-bit machine.
823
824 \begin{code}
825 -- | A 'PrimRep' is an abstraction of a type.  It contains information that
826 -- the code generator needs in order to pass arguments, return results,
827 -- and store values of this type.
828 data PrimRep
829   = VoidRep
830   | PtrRep
831   | IntRep              -- ^ Signed, word-sized value
832   | WordRep             -- ^ Unsigned, word-sized value
833   | Int64Rep            -- ^ Signed, 64 bit value (with 32-bit words only)
834   | Word64Rep           -- ^ Unsigned, 64 bit value (with 32-bit words only)
835   | AddrRep             -- ^ A pointer, but /not/ to a Haskell value (use 'PtrRep')
836   | FloatRep
837   | DoubleRep
838   | VecRep Int PrimElemRep  -- ^ A vector
839   deriving( Eq, Show )
840
841 data PrimElemRep
842   = Int8ElemRep
843   | Int16ElemRep
844   | Int32ElemRep
845   | Int64ElemRep
846   | Word8ElemRep
847   | Word16ElemRep
848   | Word32ElemRep
849   | Word64ElemRep
850   | FloatElemRep
851   | DoubleElemRep
852    deriving( Eq, Show )
853
854 instance Outputable PrimRep where
855   ppr r = text (show r)
856
857 instance Outputable PrimElemRep where
858   ppr r = text (show r)
859
860 isVoidRep :: PrimRep -> Bool
861 isVoidRep VoidRep = True
862 isVoidRep _other  = False
863
864 isGcPtrRep :: PrimRep -> Bool
865 isGcPtrRep PtrRep = True
866 isGcPtrRep _      = False
867
868 -- | Find the size of a 'PrimRep', in words
869 primRepSizeW :: DynFlags -> PrimRep -> Int
870 primRepSizeW _      IntRep           = 1
871 primRepSizeW _      WordRep          = 1
872 primRepSizeW dflags Int64Rep         = wORD64_SIZE `quot` wORD_SIZE dflags
873 primRepSizeW dflags Word64Rep        = wORD64_SIZE `quot` wORD_SIZE dflags
874 primRepSizeW _      FloatRep         = 1    -- NB. might not take a full word
875 primRepSizeW dflags DoubleRep        = dOUBLE_SIZE dflags `quot` wORD_SIZE dflags
876 primRepSizeW _      AddrRep          = 1
877 primRepSizeW _      PtrRep           = 1
878 primRepSizeW _      VoidRep          = 0
879 primRepSizeW dflags (VecRep len rep) = len * primElemRepSizeB rep `quot` wORD_SIZE dflags
880
881 primElemRepSizeB :: PrimElemRep -> Int
882 primElemRepSizeB Int8ElemRep   = 1
883 primElemRepSizeB Int16ElemRep  = 2
884 primElemRepSizeB Int32ElemRep  = 4
885 primElemRepSizeB Int64ElemRep  = 8
886 primElemRepSizeB Word8ElemRep  = 1
887 primElemRepSizeB Word16ElemRep = 2
888 primElemRepSizeB Word32ElemRep = 4
889 primElemRepSizeB Word64ElemRep = 8
890 primElemRepSizeB FloatElemRep  = 4
891 primElemRepSizeB DoubleElemRep = 8
892 \end{code}
893
894 %************************************************************************
895 %*                                                                      *
896 \subsection{TyCon Construction}
897 %*                                                                      *
898 %************************************************************************
899
900 Note: the TyCon constructors all take a Kind as one argument, even though
901 they could, in principle, work out their Kind from their other arguments.
902 But to do so they need functions from Types, and that makes a nasty
903 module mutual-recursion.  And they aren't called from many places.
904 So we compromise, and move their Kind calculation to the call site.
905
906 \begin{code}
907 -- | Given the name of the function type constructor and it's kind, create the
908 -- corresponding 'TyCon'. It is reccomended to use 'TypeRep.funTyCon' if you want
909 -- this functionality
910 mkFunTyCon :: Name -> Kind -> TyCon
911 mkFunTyCon name kind
912   = FunTyCon {
913         tyConUnique = nameUnique name,
914         tyConName   = name,
915         tc_kind   = kind,
916         tyConArity  = 2
917     }
918
919 -- | This is the making of an algebraic 'TyCon'. Notably, you have to
920 -- pass in the generic (in the -XGenerics sense) information about the
921 -- type constructor - you can get hold of it easily (see Generics
922 -- module)
923 mkAlgTyCon :: Name
924            -> Kind              -- ^ Kind of the resulting 'TyCon'
925            -> [TyVar]           -- ^ 'TyVar's scoped over: see 'tyConTyVars'.
926                                 --   Arity is inferred from the length of this list
927            -> [Role]            -- ^ The roles for each TyVar
928            -> Maybe CType       -- ^ The C type this type corresponds to
929                                 --   when using the CAPI FFI
930            -> [PredType]        -- ^ Stupid theta: see 'algTcStupidTheta'
931            -> AlgTyConRhs       -- ^ Information about dat aconstructors
932            -> TyConParent
933            -> RecFlag           -- ^ Is the 'TyCon' recursive?
934            -> Bool              -- ^ Was the 'TyCon' declared with GADT syntax?
935            -> Maybe TyCon       -- ^ Promoted version
936            -> TyCon
937 mkAlgTyCon name kind tyvars roles cType stupid rhs parent is_rec gadt_syn prom_tc
938   = AlgTyCon {
939         tyConName        = name,
940         tyConUnique      = nameUnique name,
941         tc_kind          = kind,
942         tyConArity       = length tyvars,
943         tyConTyVars      = tyvars,
944         tc_roles         = roles,
945         tyConCType       = cType,
946         algTcStupidTheta = stupid,
947         algTcRhs         = rhs,
948         algTcParent      = ASSERT2( okParent name parent, ppr name $$ ppr parent ) parent,
949         algTcRec         = is_rec,
950         algTcGadtSyntax  = gadt_syn,
951         tcPromoted       = prom_tc
952     }
953
954 -- | Simpler specialization of 'mkAlgTyCon' for classes
955 mkClassTyCon :: Name -> Kind -> [TyVar] -> [Role] -> AlgTyConRhs -> Class -> RecFlag -> TyCon
956 mkClassTyCon name kind tyvars roles rhs clas is_rec
957   = mkAlgTyCon name kind tyvars roles Nothing [] rhs (ClassTyCon clas) 
958                is_rec False 
959                Nothing    -- Class TyCons are not pormoted
960
961 mkTupleTyCon :: Name
962              -> Kind    -- ^ Kind of the resulting 'TyCon'
963              -> Arity   -- ^ Arity of the tuple
964              -> [TyVar] -- ^ 'TyVar's scoped over: see 'tyConTyVars'
965              -> DataCon
966              -> TupleSort    -- ^ Whether the tuple is boxed or unboxed
967              -> Maybe TyCon  -- ^ Promoted version
968              -> TyCon
969 mkTupleTyCon name kind arity tyvars con sort prom_tc
970   = TupleTyCon {
971         tyConUnique = nameUnique name,
972         tyConName = name,
973         tc_kind = kind,
974         tyConArity = arity,
975         tyConTupleSort = sort,
976         tyConTyVars = tyvars,
977         dataCon = con,
978         tcPromoted = prom_tc
979     }
980
981 -- ^ Foreign-imported (.NET) type constructors are represented
982 -- as primitive, but /lifted/, 'TyCons' for now. They are lifted
983 -- because the Haskell type @T@ representing the (foreign) .NET
984 -- type @T@ is actually implemented (in ILX) as a @thunk<T>@
985 mkForeignTyCon :: Name
986                -> Maybe FastString -- ^ Name of the foreign imported thing, maybe
987                -> Kind
988                -> TyCon
989 mkForeignTyCon name ext_name kind
990   = PrimTyCon {
991         tyConName    = name,
992         tyConUnique  = nameUnique name,
993         tc_kind    = kind,
994         tyConArity   = 0,
995         tc_roles     = [],
996         primTyConRep = PtrRep, -- they all do
997         isUnLifted   = False,
998         tyConExtName = ext_name
999     }
1000
1001
1002 -- | Create an unlifted primitive 'TyCon', such as @Int#@
1003 mkPrimTyCon :: Name  -> Kind -> [Role] -> PrimRep -> TyCon
1004 mkPrimTyCon name kind roles rep
1005   = mkPrimTyCon' name kind roles rep True
1006
1007 -- | Kind constructors
1008 mkKindTyCon :: Name -> Kind -> TyCon
1009 mkKindTyCon name kind
1010   = mkPrimTyCon' name kind [] VoidRep True
1011
1012 -- | Create a lifted primitive 'TyCon' such as @RealWorld@
1013 mkLiftedPrimTyCon :: Name  -> Kind -> [Role] -> PrimRep -> TyCon
1014 mkLiftedPrimTyCon name kind roles rep
1015   = mkPrimTyCon' name kind roles rep False
1016
1017 mkPrimTyCon' :: Name  -> Kind -> [Role] -> PrimRep -> Bool -> TyCon
1018 mkPrimTyCon' name kind roles rep is_unlifted
1019   = PrimTyCon {
1020         tyConName    = name,
1021         tyConUnique  = nameUnique name,
1022         tc_kind    = kind,
1023         tyConArity   = length roles,
1024         tc_roles     = roles,
1025         primTyConRep = rep,
1026         isUnLifted   = is_unlifted,
1027         tyConExtName = Nothing
1028     }
1029
1030 -- | Create a type synonym 'TyCon'
1031 mkSynTyCon :: Name -> Kind -> [TyVar] -> [Role] -> SynTyConRhs -> TyConParent -> TyCon
1032 mkSynTyCon name kind tyvars roles rhs parent
1033   = SynTyCon {
1034         tyConName = name,
1035         tyConUnique = nameUnique name,
1036         tc_kind = kind,
1037         tyConArity = length tyvars,
1038         tyConTyVars = tyvars,
1039         tc_roles = roles,
1040         synTcRhs = rhs,
1041         synTcParent = parent
1042     }
1043
1044 -- | Create a promoted data constructor 'TyCon'
1045 -- Somewhat dodgily, we give it the same Name
1046 -- as the data constructor itself; when we pretty-print
1047 -- the TyCon we add a quote; see the Outputable TyCon instance
1048 mkPromotedDataCon :: DataCon -> Name -> Unique -> Kind -> [Role] -> TyCon
1049 mkPromotedDataCon con name unique kind roles
1050   = PromotedDataCon {
1051         tyConName   = name,
1052         tyConUnique = unique,
1053         tyConArity  = arity,
1054         tc_roles    = roles,
1055         tc_kind     = kind,
1056         dataCon     = con
1057   }
1058   where
1059     arity = length roles
1060
1061 -- | Create a promoted type constructor 'TyCon'
1062 -- Somewhat dodgily, we give it the same Name
1063 -- as the type constructor itself
1064 mkPromotedTyCon :: TyCon -> Kind -> TyCon
1065 mkPromotedTyCon tc kind
1066   = PromotedTyCon {
1067         tyConName   = getName tc,
1068         tyConUnique = getUnique tc,
1069         tyConArity  = tyConArity tc,
1070         tc_kind     = kind,
1071         ty_con      = tc
1072   }
1073 \end{code}
1074
1075 \begin{code}
1076 isFunTyCon :: TyCon -> Bool
1077 isFunTyCon (FunTyCon {}) = True
1078 isFunTyCon _             = False
1079
1080 -- | Test if the 'TyCon' is algebraic but abstract (invisible data constructors)
1081 isAbstractTyCon :: TyCon -> Bool
1082 isAbstractTyCon (AlgTyCon { algTcRhs = AbstractTyCon {} }) = True
1083 isAbstractTyCon _ = False
1084
1085 -- | Make an algebraic 'TyCon' abstract. Panics if the supplied 'TyCon' is not algebraic
1086 makeTyConAbstract :: TyCon -> TyCon
1087 makeTyConAbstract tc@(AlgTyCon { algTcRhs = rhs })
1088   = tc { algTcRhs = AbstractTyCon (isDistinctAlgRhs rhs) }
1089 makeTyConAbstract tc = pprPanic "makeTyConAbstract" (ppr tc)
1090
1091 -- | Does this 'TyCon' represent something that cannot be defined in Haskell?
1092 isPrimTyCon :: TyCon -> Bool
1093 isPrimTyCon (PrimTyCon {}) = True
1094 isPrimTyCon _              = False
1095
1096 -- | Is this 'TyCon' unlifted (i.e. cannot contain bottom)? Note that this can only
1097 -- be true for primitive and unboxed-tuple 'TyCon's
1098 isUnLiftedTyCon :: TyCon -> Bool
1099 isUnLiftedTyCon (PrimTyCon  {isUnLifted = is_unlifted}) = is_unlifted
1100 isUnLiftedTyCon (TupleTyCon {tyConTupleSort = sort})    = not (isBoxed (tupleSortBoxity sort))
1101 isUnLiftedTyCon _                                       = False
1102
1103 -- | Returns @True@ if the supplied 'TyCon' resulted from either a
1104 -- @data@ or @newtype@ declaration
1105 isAlgTyCon :: TyCon -> Bool
1106 isAlgTyCon (AlgTyCon {})   = True
1107 isAlgTyCon (TupleTyCon {}) = True
1108 isAlgTyCon _               = False
1109
1110 isDataTyCon :: TyCon -> Bool
1111 -- ^ Returns @True@ for data types that are /definitely/ represented by
1112 -- heap-allocated constructors.  These are scrutinised by Core-level
1113 -- @case@ expressions, and they get info tables allocated for them.
1114 --
1115 -- Generally, the function will be true for all @data@ types and false
1116 -- for @newtype@s, unboxed tuples and type family 'TyCon's. But it is
1117 -- not guaranteed to return @True@ in all cases that it could.
1118 --
1119 -- NB: for a data type family, only the /instance/ 'TyCon's
1120 --     get an info table.  The family declaration 'TyCon' does not
1121 isDataTyCon (AlgTyCon {algTcRhs = rhs})
1122   = case rhs of
1123         DataTyCon {}       -> True
1124         NewTyCon {}        -> False
1125         DataFamilyTyCon {} -> False
1126         AbstractTyCon {}   -> False      -- We don't know, so return False
1127 isDataTyCon (TupleTyCon {tyConTupleSort = sort}) = isBoxed (tupleSortBoxity sort)
1128 isDataTyCon _ = False
1129
1130 -- | 'isDistinctTyCon' is true of 'TyCon's that are equal only to
1131 -- themselves, even via coercions (except for unsafeCoerce).
1132 -- This excludes newtypes, type functions, type synonyms.
1133 -- It relates directly to the FC consistency story:
1134 --     If the axioms are consistent,
1135 --     and  co : S tys ~ T tys, and S,T are "distinct" TyCons,
1136 --     then S=T.
1137 -- Cf Note [Pruning dead case alternatives] in Unify
1138 isDistinctTyCon :: TyCon -> Bool
1139 isDistinctTyCon (AlgTyCon {algTcRhs = rhs}) = isDistinctAlgRhs rhs
1140 isDistinctTyCon (FunTyCon {})               = True
1141 isDistinctTyCon (TupleTyCon {})             = True
1142 isDistinctTyCon (PrimTyCon {})              = True
1143 isDistinctTyCon (PromotedDataCon {})        = True
1144 isDistinctTyCon _                           = False
1145
1146 isDistinctAlgRhs :: AlgTyConRhs -> Bool
1147 isDistinctAlgRhs (DataTyCon {})           = True
1148 isDistinctAlgRhs (DataFamilyTyCon {})     = True
1149 isDistinctAlgRhs (AbstractTyCon distinct) = distinct
1150 isDistinctAlgRhs (NewTyCon {})            = False
1151
1152 -- | Is this 'TyCon' that for a @newtype@
1153 isNewTyCon :: TyCon -> Bool
1154 isNewTyCon (AlgTyCon {algTcRhs = NewTyCon {}}) = True
1155 isNewTyCon _                                   = False
1156
1157 -- | Take a 'TyCon' apart into the 'TyVar's it scopes over, the 'Type' it expands
1158 -- into, and (possibly) a coercion from the representation type to the @newtype@.
1159 -- Returns @Nothing@ if this is not possible.
1160 unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)
1161 unwrapNewTyCon_maybe (AlgTyCon { tyConTyVars = tvs,
1162                                  algTcRhs = NewTyCon { nt_co = co,
1163                                                        nt_rhs = rhs }})
1164                            = Just (tvs, rhs, co)
1165 unwrapNewTyCon_maybe _     = Nothing
1166
1167 isProductTyCon :: TyCon -> Bool
1168 -- True of datatypes or newtypes that have
1169 --   one, vanilla, data constructor
1170 isProductTyCon tc@(AlgTyCon {}) = case algTcRhs tc of
1171                                     DataTyCon{ data_cons = [data_con] }
1172                                                 -> isVanillaDataCon data_con
1173                                     NewTyCon {} -> True
1174                                     _           -> False
1175 isProductTyCon (TupleTyCon {})  = True
1176 isProductTyCon _                = False
1177
1178
1179 isDataProductTyCon_maybe :: TyCon -> Maybe DataCon
1180 -- True of datatypes (not newtypes) with 
1181 --   one, vanilla, data constructor
1182 isDataProductTyCon_maybe (AlgTyCon { algTcRhs = DataTyCon { data_cons = cons } })
1183   | [con] <- cons         -- Singleton
1184   , isVanillaDataCon con  -- Vanilla
1185   = Just con
1186 isDataProductTyCon_maybe (TupleTyCon { dataCon = con })
1187   = Just con
1188 isDataProductTyCon_maybe _ = Nothing
1189
1190 -- | Is this a 'TyCon' representing a regular H98 type synonym (@type@)?
1191 isTypeSynonymTyCon :: TyCon -> Bool
1192 isTypeSynonymTyCon (SynTyCon { synTcRhs = SynonymTyCon {} }) = True
1193 isTypeSynonymTyCon _ = False
1194
1195 -- | Is this 'TyCon' a type synonym or type family?
1196 isSynTyCon :: TyCon -> Bool
1197 isSynTyCon (SynTyCon {}) = True
1198 isSynTyCon _             = False
1199
1200
1201 -- As for newtypes, it is in some contexts important to distinguish between
1202 -- closed synonyms and synonym families, as synonym families have no unique
1203 -- right hand side to which a synonym family application can expand.
1204 --
1205
1206 isDecomposableTyCon :: TyCon -> Bool
1207 -- True iff we can decompose (T a b c) into ((T a b) c)
1208 --   I.e. is it injective?
1209 -- Specifically NOT true of synonyms (open and otherwise)
1210 -- Ultimately we may have injective associated types
1211 -- in which case this test will become more interesting
1212 --
1213 -- It'd be unusual to call isInjectiveTyCon on a regular H98
1214 -- type synonym, because you should probably have expanded it first
1215 -- But regardless, it's not decomposable
1216 isDecomposableTyCon (SynTyCon {}) = False
1217 isDecomposableTyCon _other        = True
1218
1219 -- | Is this an algebraic 'TyCon' declared with the GADT syntax?
1220 isGadtSyntaxTyCon :: TyCon -> Bool
1221 isGadtSyntaxTyCon (AlgTyCon { algTcGadtSyntax = res }) = res
1222 isGadtSyntaxTyCon _                                    = False
1223
1224 -- | Is this an algebraic 'TyCon' which is just an enumeration of values?
1225 isEnumerationTyCon :: TyCon -> Bool
1226 -- See Note [Enumeration types] in TyCon
1227 isEnumerationTyCon (AlgTyCon {algTcRhs = DataTyCon { is_enum = res }}) = res
1228 isEnumerationTyCon (TupleTyCon {tyConArity = arity}) = arity == 0
1229 isEnumerationTyCon _                                                   = False
1230
1231 -- | Is this a 'TyCon', synonym or otherwise, that defines a family?
1232 isFamilyTyCon :: TyCon -> Bool
1233 isFamilyTyCon (SynTyCon {synTcRhs = OpenSynFamilyTyCon })              = True
1234 isFamilyTyCon (SynTyCon {synTcRhs = ClosedSynFamilyTyCon {} })         = True
1235 isFamilyTyCon (SynTyCon {synTcRhs = AbstractClosedSynFamilyTyCon {} }) = True
1236 isFamilyTyCon (SynTyCon {synTcRhs = BuiltInSynFamTyCon {} })           = True
1237 isFamilyTyCon (AlgTyCon {algTcRhs = DataFamilyTyCon {}})               = True
1238 isFamilyTyCon _ = False
1239
1240 -- | Is this a 'TyCon', synonym or otherwise, that defines an family with
1241 -- instances?
1242 isOpenFamilyTyCon :: TyCon -> Bool
1243 isOpenFamilyTyCon (SynTyCon {synTcRhs = OpenSynFamilyTyCon }) = True
1244 isOpenFamilyTyCon (AlgTyCon {algTcRhs = DataFamilyTyCon })    = True
1245 isOpenFamilyTyCon _ = False
1246
1247 -- | Is this a synonym 'TyCon' that can have may have further instances appear?
1248 isSynFamilyTyCon :: TyCon -> Bool
1249 isSynFamilyTyCon (SynTyCon {synTcRhs = OpenSynFamilyTyCon {}})           = True
1250 isSynFamilyTyCon (SynTyCon {synTcRhs = ClosedSynFamilyTyCon {}})         = True
1251 isSynFamilyTyCon (SynTyCon {synTcRhs = AbstractClosedSynFamilyTyCon {}}) = True
1252 isSynFamilyTyCon (SynTyCon {synTcRhs = BuiltInSynFamTyCon {}})           = True
1253 isSynFamilyTyCon _ = False
1254
1255 isOpenSynFamilyTyCon :: TyCon -> Bool
1256 isOpenSynFamilyTyCon (SynTyCon {synTcRhs = OpenSynFamilyTyCon }) = True
1257 isOpenSynFamilyTyCon _ = False
1258
1259 -- leave out abstract closed families here
1260 isClosedSynFamilyTyCon_maybe :: TyCon -> Maybe (CoAxiom Branched)
1261 isClosedSynFamilyTyCon_maybe
1262   (SynTyCon {synTcRhs = ClosedSynFamilyTyCon ax}) = Just ax
1263 isClosedSynFamilyTyCon_maybe _ = Nothing
1264
1265 isBuiltInSynFamTyCon_maybe :: TyCon -> Maybe BuiltInSynFamily
1266 isBuiltInSynFamTyCon_maybe
1267   SynTyCon {synTcRhs = BuiltInSynFamTyCon ops } = Just ops
1268 isBuiltInSynFamTyCon_maybe _ = Nothing
1269
1270 -- | Is this a synonym 'TyCon' that can have may have further instances appear?
1271 isDataFamilyTyCon :: TyCon -> Bool
1272 isDataFamilyTyCon (AlgTyCon {algTcRhs = DataFamilyTyCon {}}) = True
1273 isDataFamilyTyCon _ = False
1274
1275 -- | Are we able to extract informationa 'TyVar' to class argument list
1276 -- mappping from a given 'TyCon'?
1277 isTyConAssoc :: TyCon -> Bool
1278 isTyConAssoc tc = isJust (tyConAssoc_maybe tc)
1279
1280 tyConAssoc_maybe :: TyCon -> Maybe Class
1281 tyConAssoc_maybe tc = case tyConParent tc of
1282                         AssocFamilyTyCon cls -> Just cls
1283                         _                    -> Nothing
1284
1285 -- The unit tycon didn't used to be classed as a tuple tycon
1286 -- but I thought that was silly so I've undone it
1287 -- If it can't be for some reason, it should be a AlgTyCon
1288 isTupleTyCon :: TyCon -> Bool
1289 -- ^ Does this 'TyCon' represent a tuple?
1290 --
1291 -- NB: when compiling @Data.Tuple@, the tycons won't reply @True@ to
1292 -- 'isTupleTyCon', because they are built as 'AlgTyCons'.  However they
1293 -- get spat into the interface file as tuple tycons, so I don't think
1294 -- it matters.
1295 isTupleTyCon (TupleTyCon {}) = True
1296 isTupleTyCon _               = False
1297
1298 -- | Is this the 'TyCon' for an unboxed tuple?
1299 isUnboxedTupleTyCon :: TyCon -> Bool
1300 isUnboxedTupleTyCon (TupleTyCon {tyConTupleSort = sort}) = not (isBoxed (tupleSortBoxity sort))
1301 isUnboxedTupleTyCon _                                    = False
1302
1303 -- | Is this the 'TyCon' for a boxed tuple?
1304 isBoxedTupleTyCon :: TyCon -> Bool
1305 isBoxedTupleTyCon (TupleTyCon {tyConTupleSort = sort}) = isBoxed (tupleSortBoxity sort)
1306 isBoxedTupleTyCon _                                    = False
1307
1308 -- | Extract the boxity of the given 'TyCon', if it is a 'TupleTyCon'.
1309 -- Panics otherwise
1310 tupleTyConBoxity :: TyCon -> Boxity
1311 tupleTyConBoxity tc = tupleSortBoxity (tyConTupleSort tc)
1312
1313 -- | Extract the 'TupleSort' of the given 'TyCon', if it is a 'TupleTyCon'.
1314 -- Panics otherwise
1315 tupleTyConSort :: TyCon -> TupleSort
1316 tupleTyConSort tc = tyConTupleSort tc
1317
1318 -- | Extract the arity of the given 'TyCon', if it is a 'TupleTyCon'.
1319 -- Panics otherwise
1320 tupleTyConArity :: TyCon -> Arity
1321 tupleTyConArity tc = tyConArity tc
1322
1323 -- | Is this a recursive 'TyCon'?
1324 isRecursiveTyCon :: TyCon -> Bool
1325 isRecursiveTyCon (AlgTyCon {algTcRec = Recursive}) = True
1326 isRecursiveTyCon _                                 = False
1327
1328 promotableTyCon_maybe :: TyCon -> Maybe TyCon
1329 promotableTyCon_maybe (AlgTyCon { tcPromoted = prom })   = prom
1330 promotableTyCon_maybe (TupleTyCon { tcPromoted = prom }) = prom
1331 promotableTyCon_maybe _                                  = Nothing
1332
1333 promoteTyCon :: TyCon -> TyCon
1334 promoteTyCon tc = case promotableTyCon_maybe tc of
1335                     Just prom_tc -> prom_tc
1336                     Nothing      -> pprPanic "promoteTyCon" (ppr tc)
1337
1338 -- | Is this the 'TyCon' of a foreign-imported type constructor?
1339 isForeignTyCon :: TyCon -> Bool
1340 isForeignTyCon (PrimTyCon {tyConExtName = Just _}) = True
1341 isForeignTyCon _                                   = False
1342
1343 -- | Is this a PromotedTyCon?
1344 isPromotedTyCon :: TyCon -> Bool
1345 isPromotedTyCon (PromotedTyCon {}) = True
1346 isPromotedTyCon _                  = False
1347
1348 -- | Retrieves the promoted TyCon if this is a PromotedTyCon;
1349 isPromotedTyCon_maybe :: TyCon -> Maybe TyCon
1350 isPromotedTyCon_maybe (PromotedTyCon { ty_con = tc }) = Just tc
1351 isPromotedTyCon_maybe _ = Nothing
1352
1353 -- | Is this a PromotedDataCon?
1354 isPromotedDataCon :: TyCon -> Bool
1355 isPromotedDataCon (PromotedDataCon {}) = True
1356 isPromotedDataCon _                    = False
1357
1358 -- | Retrieves the promoted DataCon if this is a PromotedDataCon;
1359 isPromotedDataCon_maybe :: TyCon -> Maybe DataCon
1360 isPromotedDataCon_maybe (PromotedDataCon { dataCon = dc }) = Just dc
1361 isPromotedDataCon_maybe _ = Nothing
1362
1363 -- | Identifies implicit tycons that, in particular, do not go into interface
1364 -- files (because they are implicitly reconstructed when the interface is
1365 -- read).
1366 --
1367 -- Note that:
1368 --
1369 -- * Associated families are implicit, as they are re-constructed from
1370 --   the class declaration in which they reside, and
1371 --
1372 -- * Family instances are /not/ implicit as they represent the instance body
1373 --   (similar to a @dfun@ does that for a class instance).
1374 isImplicitTyCon :: TyCon -> Bool
1375 isImplicitTyCon (FunTyCon {})        = True
1376 isImplicitTyCon (TupleTyCon {})      = True
1377 isImplicitTyCon (PrimTyCon {})       = True
1378 isImplicitTyCon (PromotedDataCon {}) = True
1379 isImplicitTyCon (PromotedTyCon {})   = True
1380 isImplicitTyCon (AlgTyCon { algTcParent = AssocFamilyTyCon {} }) = True
1381 isImplicitTyCon (AlgTyCon {})                                    = False
1382 isImplicitTyCon (SynTyCon { synTcParent = AssocFamilyTyCon {} }) = True
1383 isImplicitTyCon (SynTyCon {})                                    = False
1384
1385 tyConCType_maybe :: TyCon -> Maybe CType
1386 tyConCType_maybe tc@(AlgTyCon {}) = tyConCType tc
1387 tyConCType_maybe _ = Nothing
1388 \end{code}
1389
1390
1391 -----------------------------------------------
1392 --      Expand type-constructor applications
1393 -----------------------------------------------
1394
1395 \begin{code}
1396 tcExpandTyCon_maybe, coreExpandTyCon_maybe
1397         :: TyCon
1398         -> [tyco]                 -- ^ Arguments to 'TyCon'
1399         -> Maybe ([(TyVar,tyco)],
1400                   Type,
1401                   [tyco])         -- ^ Returns a 'TyVar' substitution, the body type
1402                                   -- of the synonym (not yet substituted) and any arguments
1403                                   -- remaining from the application
1404
1405 -- ^ Used to create the view the /typechecker/ has on 'TyCon's.
1406 -- We expand (closed) synonyms only, cf. 'coreExpandTyCon_maybe'
1407 tcExpandTyCon_maybe (SynTyCon {tyConTyVars = tvs,
1408                                synTcRhs = SynonymTyCon rhs }) tys
1409    = expand tvs rhs tys
1410 tcExpandTyCon_maybe _ _ = Nothing
1411
1412 ---------------
1413
1414 -- ^ Used to create the view /Core/ has on 'TyCon's. We expand
1415 -- not only closed synonyms like 'tcExpandTyCon_maybe',
1416 -- but also non-recursive @newtype@s
1417 coreExpandTyCon_maybe tycon tys = tcExpandTyCon_maybe tycon tys
1418
1419
1420 ----------------
1421 expand  :: [TyVar] -> Type                 -- Template
1422         -> [a]                             -- Args
1423         -> Maybe ([(TyVar,a)], Type, [a])  -- Expansion
1424 expand tvs rhs tys
1425   = case n_tvs `compare` length tys of
1426         LT -> Just (tvs `zip` tys, rhs, drop n_tvs tys)
1427         EQ -> Just (tvs `zip` tys, rhs, [])
1428         GT -> Nothing
1429    where
1430      n_tvs = length tvs
1431 \end{code}
1432
1433 \begin{code}
1434 tyConKind :: TyCon -> Kind
1435 tyConKind = tc_kind
1436
1437 -- | As 'tyConDataCons_maybe', but returns the empty list of constructors if no constructors
1438 -- could be found
1439 tyConDataCons :: TyCon -> [DataCon]
1440 -- It's convenient for tyConDataCons to return the
1441 -- empty list for type synonyms etc
1442 tyConDataCons tycon = tyConDataCons_maybe tycon `orElse` []
1443
1444 -- | Determine the 'DataCon's originating from the given 'TyCon', if the 'TyCon' is the
1445 -- sort that can have any constructors (note: this does not include abstract algebraic types)
1446 tyConDataCons_maybe :: TyCon -> Maybe [DataCon]
1447 tyConDataCons_maybe (AlgTyCon {algTcRhs = DataTyCon { data_cons = cons }}) = Just cons
1448 tyConDataCons_maybe (AlgTyCon {algTcRhs = NewTyCon { data_con = con }})    = Just [con]
1449 tyConDataCons_maybe (TupleTyCon {dataCon = con})                           = Just [con]
1450 tyConDataCons_maybe _                                                      = Nothing
1451
1452 -- | Determine the number of value constructors a 'TyCon' has. Panics if the 'TyCon'
1453 -- is not algebraic or a tuple
1454 tyConFamilySize  :: TyCon -> Int
1455 tyConFamilySize (AlgTyCon   {algTcRhs = DataTyCon {data_cons = cons}}) =
1456   length cons
1457 tyConFamilySize (AlgTyCon   {algTcRhs = NewTyCon {}})        = 1
1458 tyConFamilySize (AlgTyCon   {algTcRhs = DataFamilyTyCon {}}) = 0
1459 tyConFamilySize (TupleTyCon {})                              = 1
1460 tyConFamilySize other = pprPanic "tyConFamilySize:" (ppr other)
1461
1462 -- | Extract an 'AlgTyConRhs' with information about data constructors from an algebraic or tuple
1463 -- 'TyCon'. Panics for any other sort of 'TyCon'
1464 algTyConRhs :: TyCon -> AlgTyConRhs
1465 algTyConRhs (AlgTyCon {algTcRhs = rhs}) = rhs
1466 algTyConRhs (TupleTyCon {dataCon = con, tyConArity = arity})
1467     = DataTyCon { data_cons = [con], is_enum = arity == 0 }
1468 algTyConRhs other = pprPanic "algTyConRhs" (ppr other)
1469
1470 -- | Get the list of roles for the type parameters of a TyCon
1471 tyConRoles :: TyCon -> [Role]
1472 -- See also Note [TyCon Role signatures]
1473 tyConRoles tc
1474   = case tc of
1475     { FunTyCon {}                          -> const_role Representational
1476     ; AlgTyCon { tc_roles = roles }        -> roles
1477     ; TupleTyCon {}                        -> const_role Representational
1478     ; SynTyCon { tc_roles = roles }        -> roles
1479     ; PrimTyCon { tc_roles = roles }       -> roles
1480     ; PromotedDataCon { tc_roles = roles } -> roles
1481     ; PromotedTyCon {}                     -> const_role Nominal
1482     }
1483   where
1484     const_role r = replicate (tyConArity tc) r
1485
1486 \end{code}
1487
1488 \begin{code}
1489 -- | Extract the bound type variables and type expansion of a type synonym 'TyCon'. Panics if the
1490 -- 'TyCon' is not a synonym
1491 newTyConRhs :: TyCon -> ([TyVar], Type)
1492 newTyConRhs (AlgTyCon {tyConTyVars = tvs, algTcRhs = NewTyCon { nt_rhs = rhs }}) = (tvs, rhs)
1493 newTyConRhs tycon = pprPanic "newTyConRhs" (ppr tycon)
1494
1495 -- | The number of type parameters that need to be passed to a newtype to resolve it. May be less than in the definition if it can be eta-contracted.
1496 newTyConEtadArity :: TyCon -> Int
1497 newTyConEtadArity (AlgTyCon {algTcRhs = NewTyCon { nt_etad_rhs = tvs_rhs }})
1498         = length (fst tvs_rhs)
1499 newTyConEtadArity tycon = pprPanic "newTyConEtadArity" (ppr tycon)
1500
1501 -- | Extract the bound type variables and type expansion of an eta-contracted type synonym 'TyCon'.
1502 -- Panics if the 'TyCon' is not a synonym
1503 newTyConEtadRhs :: TyCon -> ([TyVar], Type)
1504 newTyConEtadRhs (AlgTyCon {algTcRhs = NewTyCon { nt_etad_rhs = tvs_rhs }}) = tvs_rhs
1505 newTyConEtadRhs tycon = pprPanic "newTyConEtadRhs" (ppr tycon)
1506
1507 -- | Extracts the @newtype@ coercion from such a 'TyCon', which can be used to construct something
1508 -- with the @newtype@s type from its representation type (right hand side). If the supplied 'TyCon'
1509 -- is not a @newtype@, returns @Nothing@
1510 newTyConCo_maybe :: TyCon -> Maybe (CoAxiom Unbranched)
1511 newTyConCo_maybe (AlgTyCon {algTcRhs = NewTyCon { nt_co = co }}) = Just co
1512 newTyConCo_maybe _                                               = Nothing
1513
1514 newTyConCo :: TyCon -> CoAxiom Unbranched
1515 newTyConCo tc = case newTyConCo_maybe tc of
1516                  Just co -> co
1517                  Nothing -> pprPanic "newTyConCo" (ppr tc)
1518
1519 -- | Find the primitive representation of a 'TyCon'
1520 tyConPrimRep :: TyCon -> PrimRep
1521 tyConPrimRep (PrimTyCon {primTyConRep = rep}) = rep
1522 tyConPrimRep tc = ASSERT(not (isUnboxedTupleTyCon tc)) PtrRep
1523 \end{code}
1524
1525 \begin{code}
1526 -- | Find the \"stupid theta\" of the 'TyCon'. A \"stupid theta\" is the context to the left of
1527 -- an algebraic type declaration, e.g. @Eq a@ in the declaration @data Eq a => T a ...@
1528 tyConStupidTheta :: TyCon -> [PredType]
1529 tyConStupidTheta (AlgTyCon {algTcStupidTheta = stupid}) = stupid
1530 tyConStupidTheta (TupleTyCon {})                        = []
1531 tyConStupidTheta tycon = pprPanic "tyConStupidTheta" (ppr tycon)
1532 \end{code}
1533
1534 \begin{code}
1535 -- | Extract the 'TyVar's bound by a vanilla type synonym (not familiy)
1536 -- and the corresponding (unsubstituted) right hand side.
1537 synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)
1538 synTyConDefn_maybe (SynTyCon {tyConTyVars = tyvars, synTcRhs = SynonymTyCon ty})
1539   = Just (tyvars, ty)
1540 synTyConDefn_maybe _ = Nothing
1541
1542 -- | Extract the information pertaining to the right hand side of a type synonym (@type@) declaration.
1543 synTyConRhs_maybe :: TyCon -> Maybe SynTyConRhs
1544 synTyConRhs_maybe (SynTyCon {synTcRhs = rhs}) = Just rhs
1545 synTyConRhs_maybe _                           = Nothing
1546 \end{code}
1547
1548 \begin{code}
1549 -- | If the given 'TyCon' has a /single/ data constructor, i.e. it is a @data@ type with one
1550 -- alternative, a tuple type or a @newtype@ then that constructor is returned. If the 'TyCon'
1551 -- has more than one constructor, or represents a primitive or function type constructor then
1552 -- @Nothing@ is returned. In any other case, the function panics
1553 tyConSingleDataCon_maybe :: TyCon -> Maybe DataCon
1554 tyConSingleDataCon_maybe (TupleTyCon {dataCon = c})                            = Just c
1555 tyConSingleDataCon_maybe (AlgTyCon {algTcRhs = DataTyCon { data_cons = [c] }}) = Just c
1556 tyConSingleDataCon_maybe (AlgTyCon {algTcRhs = NewTyCon { data_con = c }})     = Just c
1557 tyConSingleDataCon_maybe _                                                     = Nothing
1558
1559 tyConSingleAlgDataCon_maybe :: TyCon -> Maybe DataCon
1560 -- Returns (Just con) for single-constructor *algebraic* data types
1561 -- *not* newtypes
1562 tyConSingleAlgDataCon_maybe (TupleTyCon {dataCon = c})                            = Just c
1563 tyConSingleAlgDataCon_maybe (AlgTyCon {algTcRhs = DataTyCon { data_cons = [c] }}) = Just c
1564 tyConSingleAlgDataCon_maybe _                                                     = Nothing
1565 \end{code}
1566
1567 \begin{code}
1568 -- | Is this 'TyCon' that for a class instance?
1569 isClassTyCon :: TyCon -> Bool
1570 isClassTyCon (AlgTyCon {algTcParent = ClassTyCon _}) = True
1571 isClassTyCon _                                       = False
1572
1573 -- | If this 'TyCon' is that for a class instance, return the class it is for.
1574 -- Otherwise returns @Nothing@
1575 tyConClass_maybe :: TyCon -> Maybe Class
1576 tyConClass_maybe (AlgTyCon {algTcParent = ClassTyCon clas}) = Just clas
1577 tyConClass_maybe _                                          = Nothing
1578
1579 tyConTuple_maybe :: TyCon -> Maybe TupleSort
1580 tyConTuple_maybe (TupleTyCon {tyConTupleSort = sort}) = Just sort
1581 tyConTuple_maybe _                                    = Nothing
1582
1583 ----------------------------------------------------------------------------
1584 tyConParent :: TyCon -> TyConParent
1585 tyConParent (AlgTyCon {algTcParent = parent}) = parent
1586 tyConParent (SynTyCon {synTcParent = parent}) = parent
1587 tyConParent _                                 = NoParentTyCon
1588
1589 ----------------------------------------------------------------------------
1590 -- | Is this 'TyCon' that for a data family instance?
1591 isFamInstTyCon :: TyCon -> Bool
1592 isFamInstTyCon tc = case tyConParent tc of
1593                       FamInstTyCon {} -> True
1594                       _               -> False
1595
1596 tyConFamInstSig_maybe :: TyCon -> Maybe (TyCon, [Type], CoAxiom Unbranched)
1597 tyConFamInstSig_maybe tc
1598   = case tyConParent tc of
1599       FamInstTyCon ax f ts -> Just (f, ts, ax)
1600       _                    -> Nothing
1601
1602 -- | If this 'TyCon' is that of a family instance, return the family in question
1603 -- and the instance types. Otherwise, return @Nothing@
1604 tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])
1605 tyConFamInst_maybe tc
1606   = case tyConParent tc of
1607       FamInstTyCon _ f ts -> Just (f, ts)
1608       _                   -> Nothing
1609
1610 -- | If this 'TyCon' is that of a family instance, return a 'TyCon' which represents
1611 -- a coercion identifying the representation type with the type instance family.
1612 -- Otherwise, return @Nothing@
1613 tyConFamilyCoercion_maybe :: TyCon -> Maybe (CoAxiom Unbranched)
1614 tyConFamilyCoercion_maybe tc
1615   = case tyConParent tc of
1616       FamInstTyCon co _ _ -> Just co
1617       _                   -> Nothing
1618 \end{code}
1619
1620
1621 %************************************************************************
1622 %*                                                                      *
1623 \subsection[TyCon-instances]{Instance declarations for @TyCon@}
1624 %*                                                                      *
1625 %************************************************************************
1626
1627 @TyCon@s are compared by comparing their @Unique@s.
1628
1629 The strictness analyser needs @Ord@. It is a lexicographic order with
1630 the property @(a<=b) || (b<=a)@.
1631
1632 \begin{code}
1633 instance Eq TyCon where
1634     a == b = case (a `compare` b) of { EQ -> True;   _ -> False }
1635     a /= b = case (a `compare` b) of { EQ -> False;  _ -> True  }
1636
1637 instance Ord TyCon where
1638     a <= b = case (a `compare` b) of { LT -> True;  EQ -> True;  GT -> False }
1639     a <  b = case (a `compare` b) of { LT -> True;  EQ -> False; GT -> False }
1640     a >= b = case (a `compare` b) of { LT -> False; EQ -> True;  GT -> True  }
1641     a >  b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True  }
1642     compare a b = getUnique a `compare` getUnique b
1643
1644 instance Uniquable TyCon where
1645     getUnique tc = tyConUnique tc
1646
1647 instance Outputable TyCon where
1648   -- At the moment a promoted TyCon has the same Name as its
1649   -- corresponding TyCon, so we add the quote to distinguish it here
1650   ppr tc = pprPromotionQuote tc <> ppr (tyConName tc)
1651
1652 pprPromotionQuote :: TyCon -> SDoc
1653 pprPromotionQuote (PromotedDataCon {}) = char '\''   -- Quote promoted DataCons in types
1654 pprPromotionQuote (PromotedTyCon {})   = ifPprDebug (char '\'') 
1655 pprPromotionQuote _                    = empty       -- However, we don't quote TyCons in kinds
1656                                                      -- e.g.   type family T a :: Bool -> *
1657                                                      -- cf Trac #5952.  Except with -dppr-debug
1658
1659 instance NamedThing TyCon where
1660     getName = tyConName
1661
1662 instance Data.Data TyCon where
1663     -- don't traverse?
1664     toConstr _   = abstractConstr "TyCon"
1665     gunfold _ _  = error "gunfold"
1666     dataTypeOf _ = mkNoRepType "TyCon"
1667
1668 \end{code}
1669
1670 %************************************************************************
1671 %*                                                                      *
1672            Walking over recursive TyCons
1673 %*                                                                      *
1674 %************************************************************************
1675
1676 Note [Expanding newtypes and products]
1677 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1678 When expanding a type to expose a data-type constructor, we need to be
1679 careful about newtypes, lest we fall into an infinite loop. Here are
1680 the key examples:
1681
1682   newtype Id  x = MkId x
1683   newtype Fix f = MkFix (f (Fix f))
1684   newtype T     = MkT (T -> T)
1685
1686   Type           Expansion
1687  --------------------------
1688   T              T -> T
1689   Fix Maybe      Maybe (Fix Maybe)
1690   Id (Id Int)    Int
1691   Fix Id         NO NO NO
1692
1693 Notice that we can expand T, even though it's recursive.
1694 And we can expand Id (Id Int), even though the Id shows up
1695 twice at the outer level.
1696
1697 So, when expanding, we keep track of when we've seen a recursive
1698 newtype at outermost level; and bale out if we see it again.
1699
1700 We sometimes want to do the same for product types, so that the 
1701 strictness analyser doesn't unbox infinitely deeply.
1702
1703 The function that manages this is checkRecTc.
1704
1705 \begin{code}
1706 newtype RecTcChecker = RC NameSet
1707
1708 initRecTc :: RecTcChecker 
1709 initRecTc = RC emptyNameSet
1710
1711 checkRecTc :: RecTcChecker -> TyCon -> Maybe RecTcChecker
1712 -- Nothing      => Recursion detected
1713 -- Just rec_tcs => Keep going
1714 checkRecTc (RC rec_nts) tc
1715   | not (isRecursiveTyCon tc)     = Just (RC rec_nts)
1716   | tc_name `elemNameSet` rec_nts = Nothing
1717   | otherwise                     = Just (RC (addOneToNameSet rec_nts tc_name))
1718   where
1719     tc_name = tyConName tc
1720 \end{code}