2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
15 AlgTyConRhs(..), visibleDataCons,
19 isFunTyCon, isUnLiftedTyCon, isProductTyCon,
20 isAlgTyCon, isDataTyCon, isSynTyCon, isNewTyCon, isClosedNewTyCon,
22 isEnumerationTyCon, isGadtSyntaxTyCon, isOpenTyCon,
23 assocTyConArgPoss_maybe, isTyConAssoc, setTyConArgPoss,
24 isTupleTyCon, isUnboxedTupleTyCon, isBoxedTupleTyCon, tupleTyConBoxity,
25 isRecursiveTyCon, newTyConRep, newTyConRhs, newTyConCo_maybe,
26 isHiBootTyCon, isSuperKindTyCon,
27 isCoercionTyCon_maybe, isCoercionTyCon,
30 tcExpandTyCon_maybe, coreExpandTyCon_maybe,
32 makeTyConAbstract, isAbstractTyCon,
34 mkForeignTyCon, isForeignTyCon,
51 algTyConRhs, tyConDataCons, tyConDataCons_maybe, tyConFamilySize,
55 isClassTyCon, tyConClass_maybe,
56 isFamInstTyCon, tyConFamInst_maybe, tyConFamilyCoercion_maybe,
57 synTyConDefn, synTyConRhs, synTyConType, synTyConResKind,
58 tyConExtName, -- External name for foreign types
66 #include "HsVersions.h"
68 import {-# SOURCE #-} TypeRep ( Kind, Type, PredType )
69 import {-# SOURCE #-} DataCon ( DataCon, isVanillaDataCon )
81 %************************************************************************
83 \subsection{The data type}
85 %************************************************************************
90 tyConUnique :: Unique,
97 | AlgTyCon { -- Data type, and newtype decls.
98 -- All lifted, all boxed
99 tyConUnique :: Unique,
104 tyConTyVars :: [TyVar], -- Scopes over (a) the algTcStupidTheta
105 -- (b) the cached types in
106 -- algTyConRhs.NewTyCon
107 -- (c) the family instance
109 -- But not over the data constructors
111 tyConArgPoss :: Maybe [Int], -- for associated families: for each
112 -- tyvar in the AT decl, gives the
113 -- position of that tyvar in the class
114 -- argument list (starting from 0).
115 -- NB: Length is less than tyConArity
116 -- if higher kind signature.
117 -- NB: Just _ <=> associated (not
120 algTcSelIds :: [Id], -- Its record selectors (empty if none)
122 algTcGadtSyntax :: Bool, -- True <=> the data type was declared using GADT syntax
123 -- That doesn't mean it's a true GADT; only that the "where"
124 -- form was used. This field is used only to guide
126 algTcStupidTheta :: [PredType], -- The "stupid theta" for the data type
127 -- (always empty for GADTs)
129 algTcRhs :: AlgTyConRhs, -- Data constructors in here
131 algTcRec :: RecFlag, -- Tells whether the data type is part
132 -- of a mutually-recursive group or not
134 hasGenerics :: Bool, -- True <=> generic to/from functions are available
135 -- (in the exports of the data type's source module)
137 algTcParent :: AlgTyConParent -- Gives the class or family tycon for
138 -- derived tycons representing classes
139 -- or family instances, respectively.
143 tyConUnique :: Unique,
147 tyConBoxed :: Boxity,
148 tyConTyVars :: [TyVar],
154 tyConUnique :: Unique,
159 tyConTyVars :: [TyVar], -- Bound tyvars
161 tyConArgPoss :: Maybe [Int], -- for associated families: for each
162 -- tyvar in the AT decl, gives the
163 -- position of that tyvar in the class
164 -- argument list (starting from 0).
165 -- NB: Length is less than tyConArity
166 -- if higher kind signature.
168 synTcRhs :: SynTyConRhs -- Expanded type in here
171 | PrimTyCon { -- Primitive types; cannot be defined in Haskell
172 -- Now includes foreign-imported types
173 -- Also includes Kinds
174 tyConUnique :: Unique,
177 tyConArity :: Arity, -- SLPJ Oct06: I'm not sure what the significance
178 -- of the arity of a primtycon is!
180 primTyConRep :: PrimRep,
181 -- Many primitive tycons are unboxed, but some are
182 -- boxed (represented by pointers). The CgRep tells.
184 isUnLifted :: Bool, -- Most primitive tycons are unlifted,
185 -- but foreign-imported ones may not be
186 tyConExtName :: Maybe FastString -- Just xx for foreign-imported types
189 | CoercionTyCon { -- E.g. (:=:), sym, trans, left, right
190 -- INVARIANT: coercions are always fully applied
191 tyConUnique :: Unique,
194 coKindFun :: [Type] -> (Type,Type)
195 } -- INVARAINT: coKindFun is always applied to exactly 'arity' args
196 -- E.g. for trans (c1 :: ta=tb) (c2 :: tb=tc), the coKindFun returns
197 -- the kind as a pair of types: (ta,tc)
199 | SuperKindTyCon { -- Super Kinds, TY (box) and CO (diamond).
200 -- They have no kind; and arity zero
201 tyConUnique :: Unique,
205 type FieldLabel = Name
208 = AbstractTyCon -- We know nothing about this data type, except
209 -- that it's represented by a pointer
210 -- Used when we export a data type abstractly into
213 | OpenDataTyCon -- data family (further instances can appear
214 | OpenNewTyCon -- newtype family at any time)
217 data_cons :: [DataCon],
218 -- The constructors; can be empty if the user declares
219 -- the type to have no constructors
220 -- INVARIANT: Kept in order of increasing tag
221 -- (see the tag assignment in DataCon.mkDataCon)
222 is_enum :: Bool -- Cached: True <=> an enumeration type
223 } -- Includes data types with no constructors.
226 data_con :: DataCon, -- The unique constructor; it has no existentials
228 nt_rhs :: Type, -- Cached: the argument type of the constructor
229 -- = the representation type of the tycon
230 -- The free tyvars of this type are the tyConTyVars
232 nt_co :: Maybe TyCon, -- The coercion used to create the newtype
233 -- from the representation
234 -- optional for non-recursive newtypes
235 -- See Note [Newtype coercions]
237 nt_etad_rhs :: ([TyVar], Type) ,
238 -- The same again, but this time eta-reduced
239 -- hence the [TyVar] which may be shorter than the declared
240 -- arity of the TyCon. See Note [Newtype eta]
242 nt_rep :: Type -- Cached: the *ultimate* representation type
243 -- By 'ultimate' I mean that the top-level constructor
244 -- of the rep type is not itself a newtype or type synonym.
245 -- The rep type isn't entirely simple:
246 -- for a recursive newtype we pick () as the rep type
249 -- This one does not need to be eta reduced; hence its
250 -- free type variables are conveniently tyConTyVars
252 -- newtype T a = MkT [(a,Int)]
253 -- The rep type is [(a,Int)]
254 -- NB: the rep type isn't necessarily the original RHS of the
255 -- newtype decl, because the rep type looks through other
258 visibleDataCons :: AlgTyConRhs -> [DataCon]
259 visibleDataCons AbstractTyCon = []
260 visibleDataCons OpenDataTyCon = []
261 visibleDataCons OpenNewTyCon = []
262 visibleDataCons (DataTyCon{ data_cons = cs }) = cs
263 visibleDataCons (NewTyCon{ data_con = c }) = [c]
265 -- Both type classes as well as data/newtype family instances imply implicit
266 -- type constructors. These implicit type constructors refer to their parent
267 -- structure (ie, the class or family from which they derive) using a type of
268 -- the following form.
271 = NoParentTyCon -- An ordinary type constructor has no parent.
273 | ClassTyCon -- Type constructors representing a class dictionary.
276 | FamilyTyCon -- Type constructors representing an instance of a type
277 TyCon -- The type family
278 [Type] -- Instance types
279 TyCon -- A CoercionTyCon identifying the representation
280 -- type with the type instance family.
281 -- c.f. Note [Newtype coercions]
282 -- E.g. data intance T [a] = ...
283 -- gives a representation tycon:
285 -- axiom co a :: T [a] ~ T77 a
286 -- with T77's algTcParent = FamilyTyCon T [a] co
289 = OpenSynTyCon Kind -- Type family: *result* kind given
290 | SynonymTyCon Type -- Mentioning head type vars. Acts as a template for
291 -- the expansion when the tycon is applied to some
295 Note [Newtype coercions]
296 ~~~~~~~~~~~~~~~~~~~~~~~~
298 The NewTyCon field nt_co is a a TyCon (a coercion constructor in fact)
299 which is used for coercing from the representation type of the
300 newtype, to the newtype itself. For example,
302 newtype T a = MkT (a -> a)
304 the NewTyCon for T will contain nt_co = CoT where CoT t : T t :=: t ->
305 t. This TyCon is a CoercionTyCon, so it does not have a kind on its
306 own; it basically has its own typing rule for the fully-applied
307 version. If the newtype T has k type variables then CoT has arity at
308 most k. In the case that the right hand side is a type application
309 ending with the same type variables as the left hand side, we
310 "eta-contract" the coercion. So if we had
312 newtype S a = MkT [a]
314 then we would generate the arity 0 coercion CoS : S :=: []. The
315 primary reason we do this is to make newtype deriving cleaner.
317 In the paper we'd write
318 axiom CoT : (forall t. T t) :=: (forall t. [t])
319 and then when we used CoT at a particular type, s, we'd say
321 which encodes as (TyConApp instCoercionTyCon [TyConApp CoT [], s])
323 But in GHC we instead make CoT into a new piece of type syntax, CoercionTyCon,
324 (like instCoercionTyCon, symCoercionTyCon etc), which must always
325 be saturated, but which encodes as
327 In the vocabulary of the paper it's as if we had axiom declarations
329 axiom CoT t : T t :=: [t]
334 newtype Parser m a = MkParser (Foogle m a)
335 Are these two types equal (to Core)?
338 Well, yes. But to see that easily we eta-reduce the RHS type of
339 Parser, in this case to ([], Froogle), so that even unsaturated applications
340 of Parser will work right. This eta reduction is done when the type
341 constructor is built, and cached in NewTyCon. The cached field is
342 only used in coreExpandTyCon_maybe.
344 Here's an example that I think showed up in practice
346 newtype T a = MkT [a]
347 newtype Foo m = MkFoo (forall a. m a -> Int)
353 w2 = MkFoo (\(MkT x) -> case w1 of MkFoo f -> f x)
355 After desugaring, and discading the data constructors for the newtypes,
359 And now Lint complains unless Foo T == Foo [], and that requires T==[]
362 %************************************************************************
366 %************************************************************************
368 A PrimRep is an abstraction of a type. It contains information that
369 the code generator needs in order to pass arguments, return results,
370 and store values of this type.
372 A PrimRep is somewhat similar to a CgRep (see codeGen/SMRep) and a
373 MachRep (see cmm/MachOp), although each of these types has a distinct
374 and clearly defined purpose:
376 - A PrimRep is a CgRep + information about signedness + information
377 about primitive pointers (AddrRep). Signedness and primitive
378 pointers are required when passing a primitive type to a foreign
379 function, but aren't needed for call/return conventions of Haskell
382 - A MachRep is a basic machine type (non-void, doesn't contain
383 information on pointerhood or signedness, but contains some
384 reps that don't have corresponding Haskell types).
390 | IntRep -- signed, word-sized
391 | WordRep -- unsinged, word-sized
392 | Int64Rep -- signed, 64 bit (32-bit words only)
393 | Word64Rep -- unsigned, 64 bit (32-bit words only)
394 | AddrRep -- a pointer, but not to a Haskell value
399 %************************************************************************
401 \subsection{TyCon Construction}
403 %************************************************************************
405 Note: the TyCon constructors all take a Kind as one argument, even though
406 they could, in principle, work out their Kind from their other arguments.
407 But to do so they need functions from Types, and that makes a nasty
408 module mutual-recursion. And they aren't called from many places.
409 So we compromise, and move their Kind calculation to the call site.
412 mkFunTyCon :: Name -> Kind -> TyCon
415 tyConUnique = nameUnique name,
421 -- This is the making of a TyCon. Just the same as the old mkAlgTyCon,
422 -- but now you also have to pass in the generic information about the type
423 -- constructor - you can get hold of it easily (see Generics module)
424 mkAlgTyCon name kind tyvars stupid rhs sel_ids parent is_rec gen_info gadt_syn
427 tyConUnique = nameUnique name,
429 tyConArity = length tyvars,
430 tyConTyVars = tyvars,
431 tyConArgPoss = Nothing,
432 algTcStupidTheta = stupid,
434 algTcSelIds = sel_ids,
435 algTcParent = parent,
437 algTcGadtSyntax = gadt_syn,
438 hasGenerics = gen_info
441 mkClassTyCon name kind tyvars rhs clas is_rec =
442 mkAlgTyCon name kind tyvars [] rhs [] (ClassTyCon clas) is_rec False False
444 mkTupleTyCon name kind arity tyvars con boxed gen_info
446 tyConUnique = nameUnique name,
451 tyConTyVars = tyvars,
453 hasGenerics = gen_info
456 -- Foreign-imported (.NET) type constructors are represented
457 -- as primitive, but *lifted*, TyCons for now. They are lifted
458 -- because the Haskell type T representing the (foreign) .NET
459 -- type T is actually implemented (in ILX) as a thunk<T>
460 mkForeignTyCon name ext_name kind arity
463 tyConUnique = nameUnique name,
466 primTyConRep = PtrRep, -- they all do
468 tyConExtName = ext_name
472 -- most Prim tycons are lifted
473 mkPrimTyCon name kind arity rep
474 = mkPrimTyCon' name kind arity rep True
476 mkVoidPrimTyCon name kind arity
477 = mkPrimTyCon' name kind arity VoidRep True
479 -- but RealWorld is lifted
480 mkLiftedPrimTyCon name kind arity rep
481 = mkPrimTyCon' name kind arity rep False
483 mkPrimTyCon' name kind arity rep is_unlifted
486 tyConUnique = nameUnique name,
490 isUnLifted = is_unlifted,
491 tyConExtName = Nothing
494 mkSynTyCon name kind tyvars rhs
497 tyConUnique = nameUnique name,
499 tyConArity = length tyvars,
500 tyConTyVars = tyvars,
501 tyConArgPoss = Nothing,
505 mkCoercionTyCon name arity kindRule
508 tyConUnique = nameUnique name,
513 -- Super kinds always have arity zero
514 mkSuperKindTyCon name
517 tyConUnique = nameUnique name
522 isFunTyCon :: TyCon -> Bool
523 isFunTyCon (FunTyCon {}) = True
526 isAbstractTyCon :: TyCon -> Bool
527 isAbstractTyCon (AlgTyCon { algTcRhs = AbstractTyCon }) = True
528 isAbstractTyCon _ = False
530 makeTyConAbstract :: TyCon -> TyCon
531 makeTyConAbstract tc@(AlgTyCon {}) = tc { algTcRhs = AbstractTyCon }
532 makeTyConAbstract tc = pprPanic "makeTyConAbstract" (ppr tc)
534 isPrimTyCon :: TyCon -> Bool
535 isPrimTyCon (PrimTyCon {}) = True
536 isPrimTyCon _ = False
538 isUnLiftedTyCon :: TyCon -> Bool
539 isUnLiftedTyCon (PrimTyCon {isUnLifted = is_unlifted}) = is_unlifted
540 isUnLiftedTyCon (TupleTyCon {tyConBoxed = boxity}) = not (isBoxed boxity)
541 isUnLiftedTyCon _ = False
543 -- isAlgTyCon returns True for both @data@ and @newtype@
544 isAlgTyCon :: TyCon -> Bool
545 isAlgTyCon (AlgTyCon {}) = True
546 isAlgTyCon (TupleTyCon {}) = True
547 isAlgTyCon other = False
549 isDataTyCon :: TyCon -> Bool
550 -- isDataTyCon returns True for data types that are definitely
551 -- represented by heap-allocated constructors.
552 -- These are srcutinised by Core-level @case@ expressions, and they
553 -- get info tables allocated for them.
554 -- True for all @data@ types
555 -- False for newtypes
557 isDataTyCon tc@(AlgTyCon {algTcRhs = rhs})
559 OpenDataTyCon -> True
561 OpenNewTyCon -> False
563 AbstractTyCon -> False -- We don't know, so return False
564 isDataTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity
565 isDataTyCon other = False
567 isNewTyCon :: TyCon -> Bool
568 isNewTyCon (AlgTyCon {algTcRhs = rhs}) = case rhs of
572 isNewTyCon other = False
574 -- This is an important refinement as typical newtype optimisations do *not*
575 -- hold for newtype families. Why? Given a type `T a', if T is a newtype
576 -- family, there is no unique right hand side by which `T a' can be replaced
579 isClosedNewTyCon :: TyCon -> Bool
580 isClosedNewTyCon tycon = isNewTyCon tycon && not (isOpenTyCon tycon)
582 isProductTyCon :: TyCon -> Bool
584 -- has *one* constructor,
585 -- is *not* existential
587 -- may be DataType, NewType
588 -- may be unboxed or not,
589 -- may be recursive or not
591 isProductTyCon tc@(AlgTyCon {}) = case algTcRhs tc of
592 DataTyCon{ data_cons = [data_con] }
593 -> isVanillaDataCon data_con
596 isProductTyCon (TupleTyCon {}) = True
597 isProductTyCon other = False
599 isSynTyCon :: TyCon -> Bool
600 isSynTyCon (SynTyCon {}) = True
603 isGadtSyntaxTyCon :: TyCon -> Bool
604 isGadtSyntaxTyCon (AlgTyCon { algTcGadtSyntax = res }) = res
605 isGadtSyntaxTyCon other = False
607 isEnumerationTyCon :: TyCon -> Bool
608 isEnumerationTyCon (AlgTyCon {algTcRhs = DataTyCon { is_enum = res }}) = res
609 isEnumerationTyCon other = False
611 isOpenTyCon :: TyCon -> Bool
612 isOpenTyCon (SynTyCon {synTcRhs = OpenSynTyCon _}) = True
613 isOpenTyCon (AlgTyCon {algTcRhs = OpenDataTyCon }) = True
614 isOpenTyCon (AlgTyCon {algTcRhs = OpenNewTyCon }) = True
615 isOpenTyCon _ = False
617 assocTyConArgPoss_maybe :: TyCon -> Maybe [Int]
618 assocTyConArgPoss_maybe (AlgTyCon { tyConArgPoss = poss }) = poss
619 assocTyConArgPoss_maybe (SynTyCon { tyConArgPoss = poss }) = poss
620 assocTyConArgPoss_maybe _ = Nothing
622 isTyConAssoc :: TyCon -> Bool
623 isTyConAssoc = isJust . assocTyConArgPoss_maybe
625 setTyConArgPoss :: TyCon -> [Int] -> TyCon
626 setTyConArgPoss tc@(AlgTyCon {}) poss = tc { tyConArgPoss = Just poss }
627 setTyConArgPoss tc@(SynTyCon {}) poss = tc { tyConArgPoss = Just poss }
628 setTyConArgPoss tc _ = pprPanic "setTyConArgPoss" (ppr tc)
630 isTupleTyCon :: TyCon -> Bool
631 -- The unit tycon didn't used to be classed as a tuple tycon
632 -- but I thought that was silly so I've undone it
633 -- If it can't be for some reason, it should be a AlgTyCon
635 -- NB: when compiling Data.Tuple, the tycons won't reply True to
636 -- isTupleTyCon, becuase they are built as AlgTyCons. However they
637 -- get spat into the interface file as tuple tycons, so I don't think
639 isTupleTyCon (TupleTyCon {}) = True
640 isTupleTyCon other = False
642 isUnboxedTupleTyCon :: TyCon -> Bool
643 isUnboxedTupleTyCon (TupleTyCon {tyConBoxed = boxity}) = not (isBoxed boxity)
644 isUnboxedTupleTyCon other = False
646 isBoxedTupleTyCon :: TyCon -> Bool
647 isBoxedTupleTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity
648 isBoxedTupleTyCon other = False
650 tupleTyConBoxity tc = tyConBoxed tc
652 isRecursiveTyCon :: TyCon -> Bool
653 isRecursiveTyCon (AlgTyCon {algTcRec = Recursive}) = True
654 isRecursiveTyCon other = False
656 isHiBootTyCon :: TyCon -> Bool
657 -- Used for knot-tying in hi-boot files
658 isHiBootTyCon (AlgTyCon {algTcRhs = AbstractTyCon}) = True
659 isHiBootTyCon other = False
661 isForeignTyCon :: TyCon -> Bool
662 -- isForeignTyCon identifies foreign-imported type constructors
663 isForeignTyCon (PrimTyCon {tyConExtName = Just _}) = True
664 isForeignTyCon other = False
666 isSuperKindTyCon :: TyCon -> Bool
667 isSuperKindTyCon (SuperKindTyCon {}) = True
668 isSuperKindTyCon other = False
670 isCoercionTyCon_maybe :: TyCon -> Maybe (Arity, [Type] -> (Type,Type))
671 isCoercionTyCon_maybe (CoercionTyCon {tyConArity = ar, coKindFun = rule})
673 isCoercionTyCon_maybe other = Nothing
675 isCoercionTyCon :: TyCon -> Bool
676 isCoercionTyCon (CoercionTyCon {}) = True
677 isCoercionTyCon other = False
679 -- Identifies implicit tycons that, in particular, do not go into interface
680 -- files (because they are implicitly reconstructed when the interface is
685 -- * associated families are implicit, as they are re-constructed from
686 -- the class declaration in which they reside, and
687 -- * family instances are *not* implicit as they represent the instance body
688 -- (similar to a dfun does that for a class instance).
690 isImplicitTyCon :: TyCon -> Bool
691 isImplicitTyCon tycon | isTyConAssoc tycon = True
692 | isSynTyCon tycon = False
693 | isAlgTyCon tycon = isClassTyCon tycon ||
695 isImplicitTyCon _other = True
696 -- catches: FunTyCon, PrimTyCon,
697 -- CoercionTyCon, SuperKindTyCon
701 -----------------------------------------------
702 -- Expand type-constructor applications
703 -----------------------------------------------
706 tcExpandTyCon_maybe, coreExpandTyCon_maybe
708 -> [Type] -- Args to tycon
709 -> Maybe ([(TyVar,Type)], -- Substitution
710 Type, -- Body type (not yet substituted)
711 [Type]) -- Leftover args
713 -- For the *typechecker* view, we expand synonyms only
714 tcExpandTyCon_maybe (SynTyCon {tyConTyVars = tvs,
715 synTcRhs = SynonymTyCon rhs }) tys
717 tcExpandTyCon_maybe other_tycon tys = Nothing
720 -- For the *Core* view, we expand synonyms only as well
722 coreExpandTyCon_maybe (AlgTyCon {algTcRec = NonRecursive, -- Not recursive
723 algTcRhs = NewTyCon { nt_etad_rhs = etad_rhs, nt_co = Nothing }}) tys
724 = case etad_rhs of -- Don't do this in the pattern match, lest we accidentally
725 -- match the etad_rhs of a *recursive* newtype
726 (tvs,rhs) -> expand tvs rhs tys
728 coreExpandTyCon_maybe tycon tys = tcExpandTyCon_maybe tycon tys
732 expand :: [TyVar] -> Type -- Template
734 -> Maybe ([(TyVar,Type)], Type, [Type]) -- Expansion
736 = case n_tvs `compare` length tys of
737 LT -> Just (tvs `zip` tys, rhs, drop n_tvs tys)
738 EQ -> Just (tvs `zip` tys, rhs, [])
745 tyConHasGenerics :: TyCon -> Bool
746 tyConHasGenerics (AlgTyCon {hasGenerics = hg}) = hg
747 tyConHasGenerics (TupleTyCon {hasGenerics = hg}) = hg
748 tyConHasGenerics other = False -- Synonyms
750 tyConDataCons :: TyCon -> [DataCon]
751 -- It's convenient for tyConDataCons to return the
752 -- empty list for type synonyms etc
753 tyConDataCons tycon = tyConDataCons_maybe tycon `orElse` []
755 tyConDataCons_maybe :: TyCon -> Maybe [DataCon]
756 tyConDataCons_maybe (AlgTyCon {algTcRhs = DataTyCon { data_cons = cons }}) = Just cons
757 tyConDataCons_maybe (AlgTyCon {algTcRhs = NewTyCon { data_con = con }}) = Just [con]
758 tyConDataCons_maybe (TupleTyCon {dataCon = con}) = Just [con]
759 tyConDataCons_maybe other = Nothing
761 tyConFamilySize :: TyCon -> Int
762 tyConFamilySize (AlgTyCon {algTcRhs = DataTyCon {data_cons = cons}}) =
764 tyConFamilySize (AlgTyCon {algTcRhs = NewTyCon {}}) = 1
765 tyConFamilySize (AlgTyCon {algTcRhs = OpenDataTyCon}) = 0
766 tyConFamilySize (TupleTyCon {}) = 1
768 tyConFamilySize other = pprPanic "tyConFamilySize:" (ppr other)
771 tyConSelIds :: TyCon -> [Id]
772 tyConSelIds (AlgTyCon {algTcSelIds = fs}) = fs
773 tyConSelIds other_tycon = []
775 algTyConRhs :: TyCon -> AlgTyConRhs
776 algTyConRhs (AlgTyCon {algTcRhs = rhs}) = rhs
777 algTyConRhs (TupleTyCon {dataCon = con}) = DataTyCon { data_cons = [con], is_enum = False }
778 algTyConRhs other = pprPanic "algTyConRhs" (ppr other)
782 newTyConRhs :: TyCon -> ([TyVar], Type)
783 newTyConRhs (AlgTyCon {tyConTyVars = tvs, algTcRhs = NewTyCon { nt_rhs = rhs }}) = (tvs, rhs)
784 newTyConRhs tycon = pprPanic "newTyConRhs" (ppr tycon)
786 newTyConRep :: TyCon -> ([TyVar], Type)
787 newTyConRep (AlgTyCon {tyConTyVars = tvs, algTcRhs = NewTyCon { nt_rep = rep }}) = (tvs, rep)
788 newTyConRep tycon = pprPanic "newTyConRep" (ppr tycon)
790 newTyConCo_maybe :: TyCon -> Maybe TyCon
791 newTyConCo_maybe (AlgTyCon {algTcRhs = NewTyCon { nt_co = co }}) = co
792 newTyConCo_maybe _ = Nothing
794 tyConPrimRep :: TyCon -> PrimRep
795 tyConPrimRep (PrimTyCon {primTyConRep = rep}) = rep
796 tyConPrimRep tc = ASSERT(not (isUnboxedTupleTyCon tc)) PtrRep
800 tyConStupidTheta :: TyCon -> [PredType]
801 tyConStupidTheta (AlgTyCon {algTcStupidTheta = stupid}) = stupid
802 tyConStupidTheta (TupleTyCon {}) = []
803 tyConStupidTheta tycon = pprPanic "tyConStupidTheta" (ppr tycon)
807 synTyConDefn :: TyCon -> ([TyVar], Type)
808 synTyConDefn (SynTyCon {tyConTyVars = tyvars, synTcRhs = SynonymTyCon ty})
810 synTyConDefn tycon = pprPanic "getSynTyConDefn" (ppr tycon)
812 synTyConRhs :: TyCon -> SynTyConRhs
813 synTyConRhs (SynTyCon {synTcRhs = rhs}) = rhs
814 synTyConRhs tc = pprPanic "synTyConRhs" (ppr tc)
816 synTyConType :: TyCon -> Type
817 synTyConType tc = case synTcRhs tc of
819 _ -> pprPanic "synTyConType" (ppr tc)
821 synTyConResKind :: TyCon -> Kind
822 synTyConResKind (SynTyCon {synTcRhs = OpenSynTyCon kind}) = kind
823 synTyConResKind tycon = pprPanic "synTyConResKind" (ppr tycon)
827 maybeTyConSingleCon :: TyCon -> Maybe DataCon
828 maybeTyConSingleCon (AlgTyCon {algTcRhs = DataTyCon {data_cons = [c] }}) = Just c
829 maybeTyConSingleCon (AlgTyCon {algTcRhs = NewTyCon { data_con = c }}) = Just c
830 maybeTyConSingleCon (AlgTyCon {}) = Nothing
831 maybeTyConSingleCon (TupleTyCon {dataCon = con}) = Just con
832 maybeTyConSingleCon (PrimTyCon {}) = Nothing
833 maybeTyConSingleCon (FunTyCon {}) = Nothing -- case at funty
834 maybeTyConSingleCon tc = pprPanic "maybeTyConSingleCon: unexpected tycon " $ ppr tc
838 isClassTyCon :: TyCon -> Bool
839 isClassTyCon (AlgTyCon {algTcParent = ClassTyCon _}) = True
840 isClassTyCon other_tycon = False
842 tyConClass_maybe :: TyCon -> Maybe Class
843 tyConClass_maybe (AlgTyCon {algTcParent = ClassTyCon clas}) = Just clas
844 tyConClass_maybe other_tycon = Nothing
846 isFamInstTyCon :: TyCon -> Bool
847 isFamInstTyCon (AlgTyCon {algTcParent = FamilyTyCon _ _ _ }) = True
848 isFamInstTyCon other_tycon = False
850 tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])
851 tyConFamInst_maybe (AlgTyCon {algTcParent = FamilyTyCon fam instTys _}) =
853 tyConFamInst_maybe other_tycon =
856 tyConFamilyCoercion_maybe :: TyCon -> Maybe TyCon
857 tyConFamilyCoercion_maybe (AlgTyCon {algTcParent = FamilyTyCon _ _ coe}) =
859 tyConFamilyCoercion_maybe other_tycon =
864 %************************************************************************
866 \subsection[TyCon-instances]{Instance declarations for @TyCon@}
868 %************************************************************************
870 @TyCon@s are compared by comparing their @Unique@s.
872 The strictness analyser needs @Ord@. It is a lexicographic order with
873 the property @(a<=b) || (b<=a)@.
876 instance Eq TyCon where
877 a == b = case (a `compare` b) of { EQ -> True; _ -> False }
878 a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
880 instance Ord TyCon where
881 a <= b = case (a `compare` b) of { LT -> True; EQ -> True; GT -> False }
882 a < b = case (a `compare` b) of { LT -> True; EQ -> False; GT -> False }
883 a >= b = case (a `compare` b) of { LT -> False; EQ -> True; GT -> True }
884 a > b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True }
885 compare a b = getUnique a `compare` getUnique b
887 instance Uniquable TyCon where
888 getUnique tc = tyConUnique tc
890 instance Outputable TyCon where
891 ppr tc = ppr (getName tc)
893 instance NamedThing TyCon where