Support for using libffi to implement FFI calls in GHCi (#631)
[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 module TyCon(
10         TyCon, FieldLabel,
11
12         PrimRep(..),
13         tyConPrimRep,
14         primRepSizeW,
15
16         AlgTyConRhs(..), visibleDataCons, 
17         TyConParent(..), 
18         SynTyConRhs(..),
19
20         isFunTyCon, isUnLiftedTyCon, isProductTyCon, 
21         isAlgTyCon, isDataTyCon, 
22         isNewTyCon, unwrapNewTyCon_maybe, 
23         isSynTyCon, isClosedSynTyCon, isOpenSynTyCon,
24         isPrimTyCon, 
25
26         isEnumerationTyCon, isGadtSyntaxTyCon, isOpenTyCon,
27         assocTyConArgPoss_maybe, isTyConAssoc, setTyConArgPoss,
28         isTupleTyCon, isUnboxedTupleTyCon, isBoxedTupleTyCon, tupleTyConBoxity,
29         isRecursiveTyCon, newTyConRhs, newTyConEtadRhs, newTyConCo_maybe,
30         isHiBootTyCon, isSuperKindTyCon,
31         isCoercionTyCon_maybe, isCoercionTyCon,
32         isImplicitTyCon,
33
34         tcExpandTyCon_maybe, coreExpandTyCon_maybe,
35
36         makeTyConAbstract, isAbstractTyCon,
37
38         mkForeignTyCon, isForeignTyCon,
39
40         mkAlgTyCon,
41         mkClassTyCon,
42         mkFunTyCon,
43         mkPrimTyCon,
44         mkVoidPrimTyCon,
45         mkLiftedPrimTyCon,
46         mkTupleTyCon,
47         mkSynTyCon,
48         mkSuperKindTyCon,
49         mkCoercionTyCon,
50
51         tyConName,
52         tyConKind,
53         tyConUnique,
54         tyConTyVars,
55         algTyConRhs, tyConDataCons, tyConDataCons_maybe, tyConFamilySize,
56         tyConSelIds,
57         tyConStupidTheta,
58         tyConArity,
59         isClassTyCon, tyConClass_maybe,
60         isFamInstTyCon, tyConFamInst_maybe, tyConFamilyCoercion_maybe,
61         synTyConDefn, synTyConRhs, synTyConType, synTyConResKind,
62         tyConExtName,           -- External name for foreign types
63
64         maybeTyConSingleCon,
65
66         -- Generics
67         tyConHasGenerics
68 ) where
69
70 #include "HsVersions.h"
71
72 import {-# SOURCE #-} TypeRep ( Kind, Type, PredType )
73 import {-# SOURCE #-} DataCon ( DataCon, isVanillaDataCon )
74
75 import Var
76 import Class
77 import BasicTypes
78 import Name
79 import PrelNames
80 import Maybes
81 import Outputable
82 import FastString
83 import Constants
84 \end{code}
85
86 %************************************************************************
87 %*                                                                      *
88 \subsection{The data type}
89 %*                                                                      *
90 %************************************************************************
91
92 \begin{code}
93 data TyCon
94   = FunTyCon {
95         tyConUnique :: Unique,
96         tyConName   :: Name,
97         tyConKind   :: Kind,
98         tyConArity  :: Arity
99     }
100
101
102   | AlgTyCon {          -- Data type, and newtype decls.
103                         -- All lifted, all boxed
104         tyConUnique :: Unique,
105         tyConName   :: Name,
106         tyConKind   :: Kind,
107         tyConArity  :: Arity,
108
109         tyConTyVars :: [TyVar],         -- Scopes over (a) the algTcStupidTheta
110                                         --             (b) the cached types in
111                                         --                 algTyConRhs.NewTyCon
112                                         --             (c) the family instance
113                                         --                 types if present
114                                         -- But not over the data constructors
115
116         algTcSelIds :: [Id],            -- Its record selectors (empty if none)
117
118         algTcGadtSyntax  :: Bool,       -- True <=> the data type was declared using GADT syntax
119                                         -- That doesn't mean it's a true GADT; only that the "where"
120                                         --      form was used. This field is used only to guide
121                                         --      pretty-printinng
122         algTcStupidTheta :: [PredType], -- The "stupid theta" for the data type
123                                         -- (always empty for GADTs)
124
125         algTcRhs :: AlgTyConRhs,        -- Data constructors in here
126
127         algTcRec :: RecFlag,            -- Tells whether the data type is part
128                                         -- of a mutually-recursive group or not
129
130         hasGenerics :: Bool,            -- True <=> generic to/from functions are available
131                                         -- (in the exports of the data type's source module)
132
133         algTcParent :: TyConParent      -- Gives the class or family tycon for
134                                         -- derived tycons representing classes
135                                         -- or family instances, respectively.
136     }
137
138   | TupleTyCon {
139         tyConUnique :: Unique,
140         tyConName   :: Name,
141         tyConKind   :: Kind,
142         tyConArity  :: Arity,
143         tyConBoxed  :: Boxity,
144         tyConTyVars :: [TyVar],
145         dataCon     :: DataCon,
146         hasGenerics :: Bool
147     }
148
149   | SynTyCon {
150         tyConUnique  :: Unique,
151         tyConName    :: Name,
152         tyConKind    :: Kind,
153         tyConArity   :: Arity,
154
155         tyConTyVars  :: [TyVar],        -- Bound tyvars
156
157         synTcRhs     :: SynTyConRhs,    -- Expanded type in here
158
159         synTcParent  :: TyConParent     -- Gives the family tycon of
160                                         -- representation tycons of family
161                                         -- instances
162
163     }
164
165   | PrimTyCon {                 -- Primitive types; cannot be defined in Haskell
166                                 -- Now includes foreign-imported types
167                                 -- Also includes Kinds
168         tyConUnique   :: Unique,
169         tyConName     :: Name,
170         tyConKind     :: Kind,
171         tyConArity    :: Arity,         -- SLPJ Oct06: I'm not sure what the significance
172                                         --             of the arity of a primtycon is!
173
174         primTyConRep  :: PrimRep,
175                         -- Many primitive tycons are unboxed, but some are
176                         -- boxed (represented by pointers). The CgRep tells.
177
178         isUnLifted   :: Bool,           -- Most primitive tycons are unlifted, 
179                                         -- but foreign-imported ones may not be
180         tyConExtName :: Maybe FastString        -- Just xx for foreign-imported types
181     }
182
183   | CoercionTyCon {     -- E.g. (:=:), sym, trans, left, right
184                         -- INVARIANT: coercions are always fully applied
185         tyConUnique :: Unique,
186         tyConName   :: Name,
187         tyConArity  :: Arity,
188         coKindFun   :: [Type] -> (Type,Type)
189     }           -- INVARAINT: coKindFun is always applied to exactly 'arity' args
190                 -- E.g. for trans (c1 :: ta=tb) (c2 :: tb=tc), the coKindFun returns 
191                 --      the kind as a pair of types: (ta,tc)
192         
193   | SuperKindTyCon {    -- Super Kinds, TY (box) and CO (diamond).
194                         -- They have no kind; and arity zero
195         tyConUnique :: Unique,
196         tyConName   :: Name
197     }
198
199 type FieldLabel = Name
200
201 -- Right hand sides of type constructors for algebraic types
202 --
203 data AlgTyConRhs
204
205   -- We know nothing about this data type, except that it's represented by a
206   -- pointer.  Used when we export a data type abstractly into an hi file.
207   --
208   = AbstractTyCon
209
210   -- The constructor represents an open family without a fixed right hand
211   -- side.  Additional instances can appear at any time.
212   -- 
213   -- These are introduced by either a top level decl:
214   --    data T a :: *
215   -- or an assoicated data type decl, in a class decl:
216   --    class C a b where
217   --      data T b :: *
218
219   | OpenTyCon {
220
221       otArgPoss   :: Maybe [Int]
222         -- Nothing <=> top-level indexed type family
223         -- Just ns <=> associated (not toplevel) family
224         --   In the latter case, for each tyvar in the AT decl, 'ns' gives the
225         --   position of that tyvar in the class argument list (starting from 0).
226         --   NB: Length is less than tyConArity iff higher kind signature.
227         
228     }
229
230   | DataTyCon {
231         data_cons :: [DataCon],
232                         -- The constructors; can be empty if the user declares
233                         --   the type to have no constructors
234                         -- INVARIANT: Kept in order of increasing tag
235                         --        (see the tag assignment in DataCon.mkDataCon)
236         is_enum :: Bool         -- Cached: True <=> an enumeration type
237     }                   --         Includes data types with no constructors.
238
239   | NewTyCon {
240         data_con :: DataCon,    -- The unique constructor; it has no existentials
241
242         nt_rhs :: Type,         -- Cached: the argument type of the constructor
243                                 --  = the representation type of the tycon
244                                 -- The free tyvars of this type are the tyConTyVars
245       
246         nt_co :: Maybe TyCon,   -- A CoercionTyCon used to create the newtype
247                                 -- from the representation
248                                 -- Optional for non-recursive newtypes
249                                 -- See Note [Newtype coercions]
250                                 -- Invariant: arity = #tvs in nt_etad_rhs;
251                                 --      See Note [Newtype eta]
252                                 -- Watch out!  If any newtypes become transparent
253                                 -- again check Trac #1072.
254
255         nt_etad_rhs :: ([TyVar], Type)
256                         -- The same again, but this time eta-reduced
257                         -- hence the [TyVar] which may be shorter than the declared 
258                         -- arity of the TyCon.  See Note [Newtype eta]
259     }
260
261 visibleDataCons :: AlgTyConRhs -> [DataCon]
262 visibleDataCons AbstractTyCon                 = []
263 visibleDataCons OpenTyCon {}                  = []
264 visibleDataCons (DataTyCon{ data_cons = cs }) = cs
265 visibleDataCons (NewTyCon{ data_con = c })    = [c]
266
267 -- Both type classes as well as family instances imply implicit
268 -- type constructors.  These implicit type constructors refer to their parent
269 -- structure (ie, the class or family from which they derive) using a type of
270 -- the following form.  We use `TyConParent' for both algebraic and synonym 
271 -- types, but the variant `ClassTyCon' will only be used by algebraic tycons.
272
273 data TyConParent 
274   = NoParentTyCon       -- An ordinary type constructor has no parent.
275
276   | ClassTyCon          -- Type constructors representing a class dictionary.
277         Class           -- INVARIANT: the classTyCon of this Class is the current tycon
278
279   | FamilyTyCon         -- Type constructors representing an instance of a type
280         TyCon           --   The type family
281         [Type]          --   Instance types; free variables are the tyConTyVars
282                         --      of the current TyCon (not the family one)
283                         --      INVARIANT: the number of types matches the arity 
284                         --                 of the family tycon
285         TyCon           --   A CoercionTyCon identifying the representation 
286                         --     type with the type instance family.  
287                         --      c.f. Note [Newtype coercions]
288
289         --
290         -- E.g.  data intance T [a] = ...
291         -- gives a representation tycon:
292         --      data :R7T a = ...
293         --      axiom co a :: T [a] ~ :R7T a
294         -- with :R7T's algTcParent = FamilyTyCon T [a] co
295
296 okParent :: Name -> TyConParent -> Bool -- Checks invariants
297 okParent _       NoParentTyCon                   = True
298 okParent tc_name (ClassTyCon cls)                = tyConName (classTyCon cls) == tc_name
299 okParent _       (FamilyTyCon fam_tc tys _co_tc) = tyConArity fam_tc == length tys
300
301 --------------------
302 data SynTyConRhs
303   = OpenSynTyCon Kind           -- Type family: *result* kind given
304                  (Maybe [Int])  -- for associated families: for each tyvars in
305                                 -- the AT decl, gives the position of that
306                                 -- tyvar in the class argument list (starting
307                                 -- from 0). 
308                                 -- NB: Length is less than tyConArity
309                                 --     if higher kind signature.
310
311   | SynonymTyCon Type   -- Mentioning head type vars.  Acts as a template for
312                         --  the expansion when the tycon is applied to some
313                         --  types.
314 \end{code}
315
316 Note [Newtype coercions]
317 ~~~~~~~~~~~~~~~~~~~~~~~~
318 The NewTyCon field nt_co is a a TyCon (a coercion constructor in fact)
319 which is used for coercing from the representation type of the
320 newtype, to the newtype itself. For example,
321
322    newtype T a = MkT (a -> a)
323
324 the NewTyCon for T will contain nt_co = CoT where CoT t : T t :=: t ->
325 t.  This TyCon is a CoercionTyCon, so it does not have a kind on its
326 own; it basically has its own typing rule for the fully-applied
327 version.  If the newtype T has k type variables then CoT has arity at
328 most k.  In the case that the right hand side is a type application
329 ending with the same type variables as the left hand side, we
330 "eta-contract" the coercion.  So if we had
331
332    newtype S a = MkT [a]
333
334 then we would generate the arity 0 coercion CoS : S :=: [].  The
335 primary reason we do this is to make newtype deriving cleaner.
336
337 In the paper we'd write
338         axiom CoT : (forall t. T t) :=: (forall t. [t])
339 and then when we used CoT at a particular type, s, we'd say
340         CoT @ s
341 which encodes as (TyConApp instCoercionTyCon [TyConApp CoT [], s])
342
343 But in GHC we instead make CoT into a new piece of type syntax, CoercionTyCon,
344 (like instCoercionTyCon, symCoercionTyCon etc), which must always
345 be saturated, but which encodes as
346         TyConApp CoT [s]
347 In the vocabulary of the paper it's as if we had axiom declarations
348 like
349         axiom CoT t :  T t :=: [t]
350
351 Note [Newtype eta]
352 ~~~~~~~~~~~~~~~~~~
353 Consider
354         newtype Parser m a = MkParser (Foogle m a)
355 Are these two types equal (to Core)?
356         Monad (Parser m) 
357         Monad (Foogle m)
358 Well, yes.  But to see that easily we eta-reduce the RHS type of
359 Parser, in this case to ([], Froogle), so that even unsaturated applications
360 of Parser will work right.  This eta reduction is done when the type 
361 constructor is built, and cached in NewTyCon.  The cached field is
362 only used in coreExpandTyCon_maybe.
363  
364 Here's an example that I think showed up in practice
365 Source code:
366         newtype T a = MkT [a]
367         newtype Foo m = MkFoo (forall a. m a -> Int)
368
369         w1 :: Foo []
370         w1 = ...
371         
372         w2 :: Foo T
373         w2 = MkFoo (\(MkT x) -> case w1 of MkFoo f -> f x)
374
375 After desugaring, and discading the data constructors for the newtypes,
376 we get:
377         w2 :: Foo T
378         w2 = w1
379 And now Lint complains unless Foo T == Foo [], and that requires T==[]
380
381 This point carries over to the newtype coercion, because we need to
382 say 
383         w2 = w1 `cast` Foo CoT
384
385 so the coercion tycon CoT must have 
386         kind:    T ~ []
387  and    arity:   0
388
389
390 Note [Indexed data types] (aka data type families)
391 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
392    See also Note [Wrappers for data instance tycons] in MkId.lhs
393
394 Consider
395         data family T a
396
397         data instance T (b,c) where
398           T1 :: b -> c -> T (b,c)
399
400 Then
401   * T is the "family TyCon"
402
403   * We make "representation TyCon" :R1T, thus:
404         data :R1T b c where
405           T1 :: forall b c. b -> c -> :R1T b c
406
407   * It has a top-level coercion connecting it to the family TyCon
408
409         axiom :Co:R1T b c : T (b,c) ~ :R1T b c
410
411   * The data contructor T1 has a wrapper (which is what the source-level
412     "T1" invokes):
413
414         $WT1 :: forall b c. b -> c -> T (b,c)
415         $WT1 b c (x::b) (y::c) = T1 b c x y `cast` sym (:Co:R1T b c)
416
417   * The representation TyCon :R1T has an AlgTyConParent of
418
419         FamilyTyCon T [(b,c)] :Co:R1T
420
421
422
423 %************************************************************************
424 %*                                                                      *
425 \subsection{PrimRep}
426 %*                                                                      *
427 %************************************************************************
428
429 A PrimRep is an abstraction of a type.  It contains information that
430 the code generator needs in order to pass arguments, return results,
431 and store values of this type.
432
433 A PrimRep is somewhat similar to a CgRep (see codeGen/SMRep) and a
434 MachRep (see cmm/MachOp), although each of these types has a distinct
435 and clearly defined purpose:
436
437   - A PrimRep is a CgRep + information about signedness + information
438     about primitive pointers (AddrRep).  Signedness and primitive
439     pointers are required when passing a primitive type to a foreign
440     function, but aren't needed for call/return conventions of Haskell
441     functions.
442
443   - A MachRep is a basic machine type (non-void, doesn't contain
444     information on pointerhood or signedness, but contains some
445     reps that don't have corresponding Haskell types).
446
447 \begin{code}
448 data PrimRep
449   = VoidRep
450   | PtrRep
451   | IntRep              -- signed, word-sized
452   | WordRep             -- unsinged, word-sized
453   | Int64Rep            -- signed, 64 bit (32-bit words only)
454   | Word64Rep           -- unsigned, 64 bit (32-bit words only)
455   | AddrRep             -- a pointer, but not to a Haskell value
456   | FloatRep
457   | DoubleRep
458   deriving( Eq, Show )
459
460 instance Outputable PrimRep where
461   ppr r = text (show r)
462
463 -- Size of a PrimRep, in words
464 primRepSizeW :: PrimRep -> Int
465 primRepSizeW IntRep   = 1
466 primRepSizeW WordRep  = 1
467 primRepSizeW Int64Rep = wORD64_SIZE `quot` wORD_SIZE
468 primRepSizeW Word64Rep= wORD64_SIZE `quot` wORD_SIZE
469 primRepSizeW FloatRep = 1    -- NB. might not take a full word
470 primRepSizeW DoubleRep= dOUBLE_SIZE `quot` wORD_SIZE
471 primRepSizeW AddrRep  = 1
472 primRepSizeW PtrRep   = 1
473 primRepSizeW VoidRep  = 0
474 \end{code}
475
476 %************************************************************************
477 %*                                                                      *
478 \subsection{TyCon Construction}
479 %*                                                                      *
480 %************************************************************************
481
482 Note: the TyCon constructors all take a Kind as one argument, even though
483 they could, in principle, work out their Kind from their other arguments.
484 But to do so they need functions from Types, and that makes a nasty
485 module mutual-recursion.  And they aren't called from many places.
486 So we compromise, and move their Kind calculation to the call site.
487
488 \begin{code}
489 mkFunTyCon :: Name -> Kind -> TyCon
490 mkFunTyCon name kind 
491   = FunTyCon { 
492         tyConUnique = nameUnique name,
493         tyConName   = name,
494         tyConKind   = kind,
495         tyConArity  = 2
496     }
497
498 -- This is the making of a TyCon. Just the same as the old mkAlgTyCon,
499 -- but now you also have to pass in the generic information about the type
500 -- constructor - you can get hold of it easily (see Generics module)
501 mkAlgTyCon :: Name
502            -> Kind
503            -> [TyVar]
504            -> [PredType]
505            -> AlgTyConRhs
506            -> [Id]
507            -> TyConParent
508            -> RecFlag
509            -> Bool
510            -> Bool
511            -> TyCon
512 mkAlgTyCon name kind tyvars stupid rhs sel_ids parent is_rec gen_info gadt_syn
513   = AlgTyCon {  
514         tyConName        = name,
515         tyConUnique      = nameUnique name,
516         tyConKind        = kind,
517         tyConArity       = length tyvars,
518         tyConTyVars      = tyvars,
519         algTcStupidTheta = stupid,
520         algTcRhs         = rhs,
521         algTcSelIds      = sel_ids,
522         algTcParent      = ASSERT( okParent name parent ) parent,
523         algTcRec         = is_rec,
524         algTcGadtSyntax  = gadt_syn,
525         hasGenerics = gen_info
526     }
527
528 mkClassTyCon :: Name -> Kind -> [TyVar] -> AlgTyConRhs -> Class -> RecFlag -> TyCon
529 mkClassTyCon name kind tyvars rhs clas is_rec =
530   mkAlgTyCon name kind tyvars [] rhs [] (ClassTyCon clas) is_rec False False
531
532 mkTupleTyCon :: Name -> Kind -> Arity -> [TyVar] -> DataCon -> Boxity -> Bool -> TyCon
533 mkTupleTyCon name kind arity tyvars con boxed gen_info
534   = TupleTyCon {
535         tyConUnique = nameUnique name,
536         tyConName = name,
537         tyConKind = kind,
538         tyConArity = arity,
539         tyConBoxed = boxed,
540         tyConTyVars = tyvars,
541         dataCon = con,
542         hasGenerics = gen_info
543     }
544
545 -- Foreign-imported (.NET) type constructors are represented
546 -- as primitive, but *lifted*, TyCons for now. They are lifted
547 -- because the Haskell type T representing the (foreign) .NET
548 -- type T is actually implemented (in ILX) as a thunk<T>
549 mkForeignTyCon :: Name -> Maybe FastString -> Kind -> Arity -> TyCon
550 mkForeignTyCon name ext_name kind arity
551   = PrimTyCon {
552         tyConName    = name,
553         tyConUnique  = nameUnique name,
554         tyConKind    = kind,
555         tyConArity   = arity,
556         primTyConRep = PtrRep, -- they all do
557         isUnLifted   = False,
558         tyConExtName = ext_name
559     }
560
561
562 -- most Prim tycons are lifted
563 mkPrimTyCon :: Name  -> Kind -> Arity -> PrimRep -> TyCon
564 mkPrimTyCon name kind arity rep
565   = mkPrimTyCon' name kind arity rep True  
566
567 mkVoidPrimTyCon :: Name -> Kind -> Arity -> TyCon
568 mkVoidPrimTyCon name kind arity 
569   = mkPrimTyCon' name kind arity VoidRep True  
570
571 -- but RealWorld is lifted
572 mkLiftedPrimTyCon :: Name  -> Kind -> Arity -> PrimRep -> TyCon
573 mkLiftedPrimTyCon name kind arity rep
574   = mkPrimTyCon' name kind arity rep False
575
576 mkPrimTyCon' :: Name  -> Kind -> Arity -> PrimRep -> Bool -> TyCon
577 mkPrimTyCon' name kind arity rep is_unlifted
578   = PrimTyCon {
579         tyConName    = name,
580         tyConUnique  = nameUnique name,
581         tyConKind    = kind,
582         tyConArity   = arity,
583         primTyConRep = rep,
584         isUnLifted   = is_unlifted,
585         tyConExtName = Nothing
586     }
587
588 mkSynTyCon :: Name -> Kind -> [TyVar] -> SynTyConRhs -> TyConParent -> TyCon
589 mkSynTyCon name kind tyvars rhs parent
590   = SynTyCon {  
591         tyConName = name,
592         tyConUnique = nameUnique name,
593         tyConKind = kind,
594         tyConArity = length tyvars,
595         tyConTyVars = tyvars,
596         synTcRhs = rhs,
597         synTcParent = parent
598     }
599
600 mkCoercionTyCon :: Name -> Arity -> ([Type] -> (Type,Type)) -> TyCon
601 mkCoercionTyCon name arity kindRule
602   = CoercionTyCon {
603         tyConName = name,
604         tyConUnique = nameUnique name,
605         tyConArity = arity,
606         coKindFun = kindRule
607     }
608
609 -- Super kinds always have arity zero
610 mkSuperKindTyCon :: Name -> TyCon
611 mkSuperKindTyCon name
612   = SuperKindTyCon {
613         tyConName = name,
614         tyConUnique = nameUnique name
615   }
616 \end{code}
617
618 \begin{code}
619 isFunTyCon :: TyCon -> Bool
620 isFunTyCon (FunTyCon {}) = True
621 isFunTyCon _             = False
622
623 isAbstractTyCon :: TyCon -> Bool
624 isAbstractTyCon (AlgTyCon { algTcRhs = AbstractTyCon }) = True
625 isAbstractTyCon _ = False
626
627 makeTyConAbstract :: TyCon -> TyCon
628 makeTyConAbstract tc@(AlgTyCon {}) = tc { algTcRhs = AbstractTyCon }
629 makeTyConAbstract tc = pprPanic "makeTyConAbstract" (ppr tc)
630
631 isPrimTyCon :: TyCon -> Bool
632 isPrimTyCon (PrimTyCon {}) = True
633 isPrimTyCon _              = False
634
635 isUnLiftedTyCon :: TyCon -> Bool
636 isUnLiftedTyCon (PrimTyCon  {isUnLifted = is_unlifted}) = is_unlifted
637 isUnLiftedTyCon (TupleTyCon {tyConBoxed = boxity})      = not (isBoxed boxity)
638 isUnLiftedTyCon _                                       = False
639
640 -- isAlgTyCon returns True for both @data@ and @newtype@
641 isAlgTyCon :: TyCon -> Bool
642 isAlgTyCon (AlgTyCon {})   = True
643 isAlgTyCon (TupleTyCon {}) = True
644 isAlgTyCon _               = False
645
646 isDataTyCon :: TyCon -> Bool
647 -- isDataTyCon returns True for data types that are definitely
648 -- represented by heap-allocated constructors.
649 -- These are srcutinised by Core-level @case@ expressions, and they
650 -- get info tables allocated for them.
651 --      True for all @data@ types
652 --      False for newtypes
653 --                unboxed tuples
654 --                type families
655 -- 
656 -- NB: for a data type family, T, only the *instance* tycons are
657 --     get an info table etc.  The family tycon does not.
658 --     Hence False for OpenTyCon
659 isDataTyCon (AlgTyCon {algTcRhs = rhs})
660   = case rhs of
661         OpenTyCon {}  -> False
662         DataTyCon {}  -> True
663         NewTyCon {}   -> False
664         AbstractTyCon -> False   -- We don't know, so return False
665 isDataTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity
666 isDataTyCon _ = False
667
668 isNewTyCon :: TyCon -> Bool
669 isNewTyCon (AlgTyCon {algTcRhs = NewTyCon {}}) = True
670 isNewTyCon _                                   = False
671
672 unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, Maybe TyCon)
673 unwrapNewTyCon_maybe (AlgTyCon { tyConTyVars = tvs, 
674                                  algTcRhs = NewTyCon { nt_co = mb_co, 
675                                                        nt_rhs = rhs }})
676                            = Just (tvs, rhs, mb_co)
677 unwrapNewTyCon_maybe _     = Nothing
678
679 isProductTyCon :: TyCon -> Bool
680 -- A "product" tycon
681 --      has *one* constructor, 
682 --      is *not* existential
683 -- but
684 --      may be  DataType, NewType
685 --      may be  unboxed or not, 
686 --      may be  recursive or not
687 -- 
688 isProductTyCon tc@(AlgTyCon {}) = case algTcRhs tc of
689                                     DataTyCon{ data_cons = [data_con] } 
690                                                 -> isVanillaDataCon data_con
691                                     NewTyCon {} -> True
692                                     _           -> False
693 isProductTyCon (TupleTyCon {})  = True   
694 isProductTyCon _                = False
695
696 isSynTyCon :: TyCon -> Bool
697 isSynTyCon (SynTyCon {}) = True
698 isSynTyCon _             = False
699
700 -- As for newtypes, it is in some contexts important to distinguish between
701 -- closed synonyms and synonym families, as synonym families have no unique
702 -- right hand side to which a synonym family application can expand.
703 --
704 isClosedSynTyCon :: TyCon -> Bool
705 isClosedSynTyCon tycon = isSynTyCon tycon && not (isOpenTyCon tycon)
706
707 isOpenSynTyCon :: TyCon -> Bool
708 isOpenSynTyCon tycon = isSynTyCon tycon && isOpenTyCon tycon
709
710 isGadtSyntaxTyCon :: TyCon -> Bool
711 isGadtSyntaxTyCon (AlgTyCon { algTcGadtSyntax = res }) = res
712 isGadtSyntaxTyCon _                                    = False
713
714 isEnumerationTyCon :: TyCon -> Bool
715 isEnumerationTyCon (AlgTyCon {algTcRhs = DataTyCon { is_enum = res }}) = res
716 isEnumerationTyCon _                                                   = False
717
718 isOpenTyCon :: TyCon -> Bool
719 isOpenTyCon (SynTyCon {synTcRhs = OpenSynTyCon _ _}) = True
720 isOpenTyCon (AlgTyCon {algTcRhs = OpenTyCon {}    }) = True
721 isOpenTyCon _                                        = False
722
723 assocTyConArgPoss_maybe :: TyCon -> Maybe [Int]
724 assocTyConArgPoss_maybe (AlgTyCon { 
725                            algTcRhs = OpenTyCon {otArgPoss = poss}})  = poss
726 assocTyConArgPoss_maybe (SynTyCon { synTcRhs = OpenSynTyCon _ poss }) = poss
727 assocTyConArgPoss_maybe _ = Nothing
728
729 isTyConAssoc :: TyCon -> Bool
730 isTyConAssoc = isJust . assocTyConArgPoss_maybe
731
732 setTyConArgPoss :: TyCon -> [Int] -> TyCon
733 setTyConArgPoss tc@(AlgTyCon { algTcRhs = rhs })               poss = 
734   tc { algTcRhs = rhs {otArgPoss = Just poss} }
735 setTyConArgPoss tc@(SynTyCon { synTcRhs = OpenSynTyCon ki _ }) poss = 
736   tc { synTcRhs = OpenSynTyCon ki (Just poss) }
737 setTyConArgPoss tc _ = pprPanic "setTyConArgPoss" (ppr tc)
738
739 isTupleTyCon :: TyCon -> Bool
740 -- The unit tycon didn't used to be classed as a tuple tycon
741 -- but I thought that was silly so I've undone it
742 -- If it can't be for some reason, it should be a AlgTyCon
743 --
744 -- NB: when compiling Data.Tuple, the tycons won't reply True to
745 -- isTupleTyCon, becuase they are built as AlgTyCons.  However they
746 -- get spat into the interface file as tuple tycons, so I don't think
747 -- it matters.
748 isTupleTyCon (TupleTyCon {}) = True
749 isTupleTyCon _               = False
750
751 isUnboxedTupleTyCon :: TyCon -> Bool
752 isUnboxedTupleTyCon (TupleTyCon {tyConBoxed = boxity}) = not (isBoxed boxity)
753 isUnboxedTupleTyCon _                                  = False
754
755 isBoxedTupleTyCon :: TyCon -> Bool
756 isBoxedTupleTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity
757 isBoxedTupleTyCon _                                  = False
758
759 tupleTyConBoxity :: TyCon -> Boxity
760 tupleTyConBoxity tc = tyConBoxed tc
761
762 isRecursiveTyCon :: TyCon -> Bool
763 isRecursiveTyCon (AlgTyCon {algTcRec = Recursive}) = True
764 isRecursiveTyCon _                                 = False
765
766 isHiBootTyCon :: TyCon -> Bool
767 -- Used for knot-tying in hi-boot files
768 isHiBootTyCon (AlgTyCon {algTcRhs = AbstractTyCon}) = True
769 isHiBootTyCon _                                     = False
770
771 isForeignTyCon :: TyCon -> Bool
772 -- isForeignTyCon identifies foreign-imported type constructors
773 isForeignTyCon (PrimTyCon {tyConExtName = Just _}) = True
774 isForeignTyCon _                                   = False
775
776 isSuperKindTyCon :: TyCon -> Bool
777 isSuperKindTyCon (SuperKindTyCon {}) = True
778 isSuperKindTyCon _                   = False
779
780 isCoercionTyCon_maybe :: TyCon -> Maybe (Arity, [Type] -> (Type,Type))
781 isCoercionTyCon_maybe (CoercionTyCon {tyConArity = ar, coKindFun = rule}) 
782   = Just (ar, rule)
783 isCoercionTyCon_maybe _ = Nothing
784
785 isCoercionTyCon :: TyCon -> Bool
786 isCoercionTyCon (CoercionTyCon {}) = True
787 isCoercionTyCon _                  = False
788
789 -- Identifies implicit tycons that, in particular, do not go into interface
790 -- files (because they are implicitly reconstructed when the interface is
791 -- read).
792 --
793 -- Note that 
794 --
795 -- * associated families are implicit, as they are re-constructed from
796 --   the class declaration in which they reside, and 
797 -- * family instances are *not* implicit as they represent the instance body
798 --   (similar to a dfun does that for a class instance).
799 --
800 isImplicitTyCon :: TyCon -> Bool
801 isImplicitTyCon tycon | isTyConAssoc tycon           = True
802                       | isSynTyCon tycon             = False
803                       | isAlgTyCon tycon             = isClassTyCon tycon ||
804                                                        isTupleTyCon tycon
805 isImplicitTyCon _other                               = True
806         -- catches: FunTyCon, PrimTyCon, 
807         -- CoercionTyCon, SuperKindTyCon
808 \end{code}
809
810
811 -----------------------------------------------
812 --      Expand type-constructor applications
813 -----------------------------------------------
814
815 \begin{code}
816 tcExpandTyCon_maybe, coreExpandTyCon_maybe 
817         :: TyCon 
818         -> [Type]                       -- Args to tycon
819         -> Maybe ([(TyVar,Type)],       -- Substitution
820                   Type,                 -- Body type (not yet substituted)
821                   [Type])               -- Leftover args
822
823 -- For the *typechecker* view, we expand (closed) synonyms only
824 tcExpandTyCon_maybe (SynTyCon {tyConTyVars = tvs, 
825                                synTcRhs = SynonymTyCon rhs }) tys
826    = expand tvs rhs tys
827 tcExpandTyCon_maybe _ _ = Nothing
828
829 ---------------
830 -- For the *Core* view, we expand synonyms only as well
831
832 coreExpandTyCon_maybe (AlgTyCon {algTcRec = NonRecursive,       -- Not recursive
833          algTcRhs = NewTyCon { nt_etad_rhs = etad_rhs, nt_co = Nothing }}) tys
834    = case etad_rhs of   -- Don't do this in the pattern match, lest we accidentally
835                         -- match the etad_rhs of a *recursive* newtype
836         (tvs,rhs) -> expand tvs rhs tys
837
838 coreExpandTyCon_maybe tycon tys = tcExpandTyCon_maybe tycon tys
839
840
841 ----------------
842 expand  :: [TyVar] -> Type                      -- Template
843         -> [Type]                               -- Args
844         -> Maybe ([(TyVar,Type)], Type, [Type]) -- Expansion
845 expand tvs rhs tys
846   = case n_tvs `compare` length tys of
847         LT -> Just (tvs `zip` tys, rhs, drop n_tvs tys)
848         EQ -> Just (tvs `zip` tys, rhs, [])
849         GT -> Nothing
850    where
851      n_tvs = length tvs
852 \end{code}
853
854 \begin{code}
855 tyConHasGenerics :: TyCon -> Bool
856 tyConHasGenerics (AlgTyCon {hasGenerics = hg})   = hg
857 tyConHasGenerics (TupleTyCon {hasGenerics = hg}) = hg
858 tyConHasGenerics _                               = False        -- Synonyms
859
860 tyConDataCons :: TyCon -> [DataCon]
861 -- It's convenient for tyConDataCons to return the
862 -- empty list for type synonyms etc
863 tyConDataCons tycon = tyConDataCons_maybe tycon `orElse` []
864
865 tyConDataCons_maybe :: TyCon -> Maybe [DataCon]
866 tyConDataCons_maybe (AlgTyCon {algTcRhs = DataTyCon { data_cons = cons }}) = Just cons
867 tyConDataCons_maybe (AlgTyCon {algTcRhs = NewTyCon { data_con = con }})    = Just [con]
868 tyConDataCons_maybe (TupleTyCon {dataCon = con})                           = Just [con]
869 tyConDataCons_maybe _                                                      = Nothing
870
871 tyConFamilySize  :: TyCon -> Int
872 tyConFamilySize (AlgTyCon   {algTcRhs = DataTyCon {data_cons = cons}}) = 
873   length cons
874 tyConFamilySize (AlgTyCon   {algTcRhs = NewTyCon {}})                  = 1
875 tyConFamilySize (AlgTyCon   {algTcRhs = OpenTyCon {}})                 = 0
876 tyConFamilySize (TupleTyCon {})                                        = 1
877 tyConFamilySize other = pprPanic "tyConFamilySize:" (ppr other)
878
879 tyConSelIds :: TyCon -> [Id]
880 tyConSelIds (AlgTyCon {algTcSelIds = fs}) = fs
881 tyConSelIds _                             = []
882
883 algTyConRhs :: TyCon -> AlgTyConRhs
884 algTyConRhs (AlgTyCon {algTcRhs = rhs})  = rhs
885 algTyConRhs (TupleTyCon {dataCon = con}) = DataTyCon { data_cons = [con], is_enum = False }
886 algTyConRhs other = pprPanic "algTyConRhs" (ppr other)
887 \end{code}
888
889 \begin{code}
890 newTyConRhs :: TyCon -> ([TyVar], Type)
891 newTyConRhs (AlgTyCon {tyConTyVars = tvs, algTcRhs = NewTyCon { nt_rhs = rhs }}) = (tvs, rhs)
892 newTyConRhs tycon = pprPanic "newTyConRhs" (ppr tycon)
893
894 newTyConEtadRhs :: TyCon -> ([TyVar], Type)
895 newTyConEtadRhs (AlgTyCon {algTcRhs = NewTyCon { nt_etad_rhs = tvs_rhs }}) = tvs_rhs
896 newTyConEtadRhs tycon = pprPanic "newTyConEtadRhs" (ppr tycon)
897
898 newTyConCo_maybe :: TyCon -> Maybe TyCon
899 newTyConCo_maybe (AlgTyCon {algTcRhs = NewTyCon { nt_co = co }}) = co
900 newTyConCo_maybe _                                               = Nothing
901
902 tyConPrimRep :: TyCon -> PrimRep
903 tyConPrimRep (PrimTyCon {primTyConRep = rep}) = rep
904 tyConPrimRep tc = ASSERT(not (isUnboxedTupleTyCon tc)) PtrRep
905 \end{code}
906
907 \begin{code}
908 tyConStupidTheta :: TyCon -> [PredType]
909 tyConStupidTheta (AlgTyCon {algTcStupidTheta = stupid}) = stupid
910 tyConStupidTheta (TupleTyCon {})                        = []
911 tyConStupidTheta tycon = pprPanic "tyConStupidTheta" (ppr tycon)
912 \end{code}
913
914 \begin{code}
915 synTyConDefn :: TyCon -> ([TyVar], Type)
916 synTyConDefn (SynTyCon {tyConTyVars = tyvars, synTcRhs = SynonymTyCon ty}) 
917   = (tyvars, ty)
918 synTyConDefn tycon = pprPanic "getSynTyConDefn" (ppr tycon)
919
920 synTyConRhs :: TyCon -> SynTyConRhs
921 synTyConRhs (SynTyCon {synTcRhs = rhs}) = rhs
922 synTyConRhs tc                          = pprPanic "synTyConRhs" (ppr tc)
923
924 synTyConType :: TyCon -> Type
925 synTyConType tc = case synTcRhs tc of
926                     SynonymTyCon t -> t
927                     _              -> pprPanic "synTyConType" (ppr tc)
928
929 synTyConResKind :: TyCon -> Kind
930 synTyConResKind (SynTyCon {synTcRhs = OpenSynTyCon kind _}) = kind
931 synTyConResKind tycon  = pprPanic "synTyConResKind" (ppr tycon)
932 \end{code}
933
934 \begin{code}
935 maybeTyConSingleCon :: TyCon -> Maybe DataCon
936 maybeTyConSingleCon (AlgTyCon {algTcRhs = DataTyCon {data_cons = [c] }}) = Just c
937 maybeTyConSingleCon (AlgTyCon {algTcRhs = NewTyCon { data_con = c }})    = Just c
938 maybeTyConSingleCon (AlgTyCon {})                = Nothing
939 maybeTyConSingleCon (TupleTyCon {dataCon = con}) = Just con
940 maybeTyConSingleCon (PrimTyCon {})               = Nothing
941 maybeTyConSingleCon (FunTyCon {})                = Nothing  -- case at funty
942 maybeTyConSingleCon tc = pprPanic "maybeTyConSingleCon: unexpected tycon " $ ppr tc
943 \end{code}
944
945 \begin{code}
946 isClassTyCon :: TyCon -> Bool
947 isClassTyCon (AlgTyCon {algTcParent = ClassTyCon _}) = True
948 isClassTyCon _                                       = False
949
950 tyConClass_maybe :: TyCon -> Maybe Class
951 tyConClass_maybe (AlgTyCon {algTcParent = ClassTyCon clas}) = Just clas
952 tyConClass_maybe _                                          = Nothing
953
954 isFamInstTyCon :: TyCon -> Bool
955 isFamInstTyCon (AlgTyCon {algTcParent = FamilyTyCon _ _ _ }) = True
956 isFamInstTyCon (SynTyCon {synTcParent = FamilyTyCon _ _ _ }) = True
957 isFamInstTyCon _                                             = False
958
959 tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])
960 tyConFamInst_maybe (AlgTyCon {algTcParent = FamilyTyCon fam instTys _}) = 
961   Just (fam, instTys)
962 tyConFamInst_maybe (SynTyCon {synTcParent = FamilyTyCon fam instTys _}) = 
963   Just (fam, instTys)
964 tyConFamInst_maybe _                                                    = 
965   Nothing
966
967 tyConFamilyCoercion_maybe :: TyCon -> Maybe TyCon
968 tyConFamilyCoercion_maybe (AlgTyCon {algTcParent = FamilyTyCon _ _ coe}) = 
969   Just coe
970 tyConFamilyCoercion_maybe (SynTyCon {synTcParent = FamilyTyCon _ _ coe}) = 
971   Just coe
972 tyConFamilyCoercion_maybe _                                              =
973   Nothing
974 \end{code}
975
976
977 %************************************************************************
978 %*                                                                      *
979 \subsection[TyCon-instances]{Instance declarations for @TyCon@}
980 %*                                                                      *
981 %************************************************************************
982
983 @TyCon@s are compared by comparing their @Unique@s.
984
985 The strictness analyser needs @Ord@. It is a lexicographic order with
986 the property @(a<=b) || (b<=a)@.
987
988 \begin{code}
989 instance Eq TyCon where
990     a == b = case (a `compare` b) of { EQ -> True;   _ -> False }
991     a /= b = case (a `compare` b) of { EQ -> False;  _ -> True  }
992
993 instance Ord TyCon where
994     a <= b = case (a `compare` b) of { LT -> True;  EQ -> True;  GT -> False }
995     a <  b = case (a `compare` b) of { LT -> True;  EQ -> False; GT -> False }
996     a >= b = case (a `compare` b) of { LT -> False; EQ -> True;  GT -> True  }
997     a >  b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True  }
998     compare a b = getUnique a `compare` getUnique b
999
1000 instance Uniquable TyCon where
1001     getUnique tc = tyConUnique tc
1002
1003 instance Outputable TyCon where
1004     ppr tc  = ppr (getName tc) 
1005
1006 instance NamedThing TyCon where
1007     getName = tyConName
1008 \end{code}