2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
10 -- The above warning supression flag is a temporary kludge.
11 -- While working on this module you are encouraged to remove it and fix
12 -- any warnings in the module. See
13 -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
23 AlgTyConRhs(..), visibleDataCons,
27 isFunTyCon, isUnLiftedTyCon, isProductTyCon,
28 isAlgTyCon, isDataTyCon,
29 isNewTyCon, unwrapNewTyCon_maybe,
30 isSynTyCon, isClosedSynTyCon, isOpenSynTyCon,
33 isEnumerationTyCon, isGadtSyntaxTyCon, isOpenTyCon,
34 assocTyConArgPoss_maybe, isTyConAssoc, setTyConArgPoss,
35 isTupleTyCon, isUnboxedTupleTyCon, isBoxedTupleTyCon, tupleTyConBoxity,
36 isRecursiveTyCon, newTyConRep, newTyConRhs, newTyConEtadRhs, newTyConCo_maybe,
37 isHiBootTyCon, isSuperKindTyCon,
38 isCoercionTyCon_maybe, isCoercionTyCon,
41 tcExpandTyCon_maybe, coreExpandTyCon_maybe,
43 makeTyConAbstract, isAbstractTyCon,
45 mkForeignTyCon, isForeignTyCon,
62 algTyConRhs, tyConDataCons, tyConDataCons_maybe, tyConFamilySize,
66 isClassTyCon, tyConClass_maybe,
67 isFamInstTyCon, tyConFamInst_maybe, tyConFamilyCoercion_maybe,
68 synTyConDefn, synTyConRhs, synTyConType, synTyConResKind,
69 tyConExtName, -- External name for foreign types
77 #include "HsVersions.h"
79 import {-# SOURCE #-} TypeRep ( Kind, Type, PredType )
80 import {-# SOURCE #-} DataCon ( DataCon, isVanillaDataCon )
93 %************************************************************************
95 \subsection{The data type}
97 %************************************************************************
102 tyConUnique :: Unique,
109 | AlgTyCon { -- Data type, and newtype decls.
110 -- All lifted, all boxed
111 tyConUnique :: Unique,
116 tyConTyVars :: [TyVar], -- Scopes over (a) the algTcStupidTheta
117 -- (b) the cached types in
118 -- algTyConRhs.NewTyCon
119 -- (c) the family instance
121 -- But not over the data constructors
123 algTcSelIds :: [Id], -- Its record selectors (empty if none)
125 algTcGadtSyntax :: Bool, -- True <=> the data type was declared using GADT syntax
126 -- That doesn't mean it's a true GADT; only that the "where"
127 -- form was used. This field is used only to guide
129 algTcStupidTheta :: [PredType], -- The "stupid theta" for the data type
130 -- (always empty for GADTs)
132 algTcRhs :: AlgTyConRhs, -- Data constructors in here
134 algTcRec :: RecFlag, -- Tells whether the data type is part
135 -- of a mutually-recursive group or not
137 hasGenerics :: Bool, -- True <=> generic to/from functions are available
138 -- (in the exports of the data type's source module)
140 algTcParent :: TyConParent -- Gives the class or family tycon for
141 -- derived tycons representing classes
142 -- or family instances, respectively.
146 tyConUnique :: Unique,
150 tyConBoxed :: Boxity,
151 tyConTyVars :: [TyVar],
157 tyConUnique :: Unique,
162 tyConTyVars :: [TyVar], -- Bound tyvars
164 synTcRhs :: SynTyConRhs, -- Expanded type in here
166 synTcParent :: TyConParent -- Gives the family tycon of
167 -- representation tycons of family
172 | PrimTyCon { -- Primitive types; cannot be defined in Haskell
173 -- Now includes foreign-imported types
174 -- Also includes Kinds
175 tyConUnique :: Unique,
178 tyConArity :: Arity, -- SLPJ Oct06: I'm not sure what the significance
179 -- of the arity of a primtycon is!
181 primTyConRep :: PrimRep,
182 -- Many primitive tycons are unboxed, but some are
183 -- boxed (represented by pointers). The CgRep tells.
185 isUnLifted :: Bool, -- Most primitive tycons are unlifted,
186 -- but foreign-imported ones may not be
187 tyConExtName :: Maybe FastString -- Just xx for foreign-imported types
190 | CoercionTyCon { -- E.g. (:=:), sym, trans, left, right
191 -- INVARIANT: coercions are always fully applied
192 tyConUnique :: Unique,
195 coKindFun :: [Type] -> (Type,Type)
196 } -- INVARAINT: coKindFun is always applied to exactly 'arity' args
197 -- E.g. for trans (c1 :: ta=tb) (c2 :: tb=tc), the coKindFun returns
198 -- the kind as a pair of types: (ta,tc)
200 | SuperKindTyCon { -- Super Kinds, TY (box) and CO (diamond).
201 -- They have no kind; and arity zero
202 tyConUnique :: Unique,
206 type FieldLabel = Name
208 -- Right hand sides of type constructors for algebraic types
212 -- We know nothing about this data type, except that it's represented by a
213 -- pointer. Used when we export a data type abstractly into an hi file.
217 -- The constructor represents an open family without a fixed right hand
218 -- side. Additional instances can appear at any time.
220 -- These are introduced by either a top level decl:
222 -- or an assoicated data type decl, in a class decl:
228 otArgPoss :: Maybe [Int]
229 -- Nothing <=> top-level indexed type family
230 -- Just ns <=> associated (not toplevel) family
231 -- In the latter case, for each tyvar in the AT decl, 'ns' gives the
232 -- position of that tyvar in the class argument list (starting from 0).
233 -- NB: Length is less than tyConArity iff higher kind signature.
238 data_cons :: [DataCon],
239 -- The constructors; can be empty if the user declares
240 -- the type to have no constructors
241 -- INVARIANT: Kept in order of increasing tag
242 -- (see the tag assignment in DataCon.mkDataCon)
243 is_enum :: Bool -- Cached: True <=> an enumeration type
244 } -- Includes data types with no constructors.
247 data_con :: DataCon, -- The unique constructor; it has no existentials
249 nt_rhs :: Type, -- Cached: the argument type of the constructor
250 -- = the representation type of the tycon
251 -- The free tyvars of this type are the tyConTyVars
253 nt_co :: Maybe TyCon, -- A CoercionTyCon used to create the newtype
254 -- from the representation
255 -- Optional for non-recursive newtypes
256 -- See Note [Newtype coercions]
257 -- Invariant: arity = #tvs in nt_etad_rhs;
258 -- See Note [Newtype eta]
259 -- Watch out! If any newtypes become transparent
260 -- again check Trac #1072.
262 nt_etad_rhs :: ([TyVar], Type) ,
263 -- The same again, but this time eta-reduced
264 -- hence the [TyVar] which may be shorter than the declared
265 -- arity of the TyCon. See Note [Newtype eta]
267 nt_rep :: Type -- Cached: the *ultimate* representation type
268 -- By 'ultimate' I mean that the top-level constructor
269 -- of the rep type is not itself a newtype or type synonym.
270 -- The rep type isn't entirely simple:
271 -- for a recursive newtype we pick () as the rep type
274 -- This one does not need to be eta reduced; hence its
275 -- free type variables are conveniently tyConTyVars
277 -- newtype T a = MkT [(a,Int)]
278 -- The rep type is [(a,Int)]
279 -- NB: the rep type isn't necessarily the original RHS of the
280 -- newtype decl, because the rep type looks through other
283 visibleDataCons :: AlgTyConRhs -> [DataCon]
284 visibleDataCons AbstractTyCon = []
285 visibleDataCons OpenTyCon {} = []
286 visibleDataCons (DataTyCon{ data_cons = cs }) = cs
287 visibleDataCons (NewTyCon{ data_con = c }) = [c]
289 -- Both type classes as well as family instances imply implicit
290 -- type constructors. These implicit type constructors refer to their parent
291 -- structure (ie, the class or family from which they derive) using a type of
292 -- the following form. We use `TyConParent' for both algebraic and synonym
293 -- types, but the variant `ClassTyCon' will only be used by algebraic tycons.
296 = NoParentTyCon -- An ordinary type constructor has no parent.
298 | ClassTyCon -- Type constructors representing a class dictionary.
299 Class -- INVARIANT: the classTyCon of this Class is the current tycon
301 | FamilyTyCon -- Type constructors representing an instance of a type
302 TyCon -- The type family
303 [Type] -- Instance types; free variables are the tyConTyVars
304 -- of the current TyCon (not the family one)
305 -- INVARIANT: the number of types matches the arity
306 -- of the family tycon
307 TyCon -- A CoercionTyCon identifying the representation
308 -- type with the type instance family.
309 -- c.f. Note [Newtype coercions]
312 -- E.g. data intance T [a] = ...
313 -- gives a representation tycon:
315 -- axiom co a :: T [a] ~ :R7T a
316 -- with :R7T's algTcParent = FamilyTyCon T [a] co
318 okParent :: Name -> TyConParent -> Bool -- Checks invariants
319 okParent tc_name NoParentTyCon = True
320 okParent tc_name (ClassTyCon cls) = tyConName (classTyCon cls) == tc_name
321 okParent tc_name (FamilyTyCon fam_tc tys co_tc) = tyConArity fam_tc == length tys
325 = OpenSynTyCon Kind -- Type family: *result* kind given
326 (Maybe [Int]) -- for associated families: for each tyvars in
327 -- the AT decl, gives the position of that
328 -- tyvar in the class argument list (starting
330 -- NB: Length is less than tyConArity
331 -- if higher kind signature.
333 | SynonymTyCon Type -- Mentioning head type vars. Acts as a template for
334 -- the expansion when the tycon is applied to some
338 Note [Newtype coercions]
339 ~~~~~~~~~~~~~~~~~~~~~~~~
340 The NewTyCon field nt_co is a a TyCon (a coercion constructor in fact)
341 which is used for coercing from the representation type of the
342 newtype, to the newtype itself. For example,
344 newtype T a = MkT (a -> a)
346 the NewTyCon for T will contain nt_co = CoT where CoT t : T t :=: t ->
347 t. This TyCon is a CoercionTyCon, so it does not have a kind on its
348 own; it basically has its own typing rule for the fully-applied
349 version. If the newtype T has k type variables then CoT has arity at
350 most k. In the case that the right hand side is a type application
351 ending with the same type variables as the left hand side, we
352 "eta-contract" the coercion. So if we had
354 newtype S a = MkT [a]
356 then we would generate the arity 0 coercion CoS : S :=: []. The
357 primary reason we do this is to make newtype deriving cleaner.
359 In the paper we'd write
360 axiom CoT : (forall t. T t) :=: (forall t. [t])
361 and then when we used CoT at a particular type, s, we'd say
363 which encodes as (TyConApp instCoercionTyCon [TyConApp CoT [], s])
365 But in GHC we instead make CoT into a new piece of type syntax, CoercionTyCon,
366 (like instCoercionTyCon, symCoercionTyCon etc), which must always
367 be saturated, but which encodes as
369 In the vocabulary of the paper it's as if we had axiom declarations
371 axiom CoT t : T t :=: [t]
376 newtype Parser m a = MkParser (Foogle m a)
377 Are these two types equal (to Core)?
380 Well, yes. But to see that easily we eta-reduce the RHS type of
381 Parser, in this case to ([], Froogle), so that even unsaturated applications
382 of Parser will work right. This eta reduction is done when the type
383 constructor is built, and cached in NewTyCon. The cached field is
384 only used in coreExpandTyCon_maybe.
386 Here's an example that I think showed up in practice
388 newtype T a = MkT [a]
389 newtype Foo m = MkFoo (forall a. m a -> Int)
395 w2 = MkFoo (\(MkT x) -> case w1 of MkFoo f -> f x)
397 After desugaring, and discading the data constructors for the newtypes,
401 And now Lint complains unless Foo T == Foo [], and that requires T==[]
403 This point carries over to the newtype coercion, because we need to
405 w2 = w1 `cast` Foo CoT
407 so the coercion tycon CoT must have
412 Note [Indexed data types] (aka data type families)
413 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
414 See also Note [Wrappers for data instance tycons] in MkId.lhs
419 data instance T (b,c) where
420 T1 :: b -> c -> T (b,c)
423 * T is the "family TyCon"
425 * We make "representation TyCon" :R1T, thus:
427 T1 :: forall b c. b -> c -> :R1T b c
429 * It has a top-level coercion connecting it to the family TyCon
431 axiom :Co:R1T b c : T (b,c) ~ :R1T b c
433 * The data contructor T1 has a wrapper (which is what the source-level
436 $WT1 :: forall b c. b -> c -> T (b,c)
437 $WT1 b c (x::b) (y::c) = T1 b c x y `cast` sym (:Co:R1T b c)
439 * The representation TyCon :R1T has an AlgTyConParent of
441 FamilyTyCon T [(b,c)] :Co:R1T
445 %************************************************************************
449 %************************************************************************
451 A PrimRep is an abstraction of a type. It contains information that
452 the code generator needs in order to pass arguments, return results,
453 and store values of this type.
455 A PrimRep is somewhat similar to a CgRep (see codeGen/SMRep) and a
456 MachRep (see cmm/MachOp), although each of these types has a distinct
457 and clearly defined purpose:
459 - A PrimRep is a CgRep + information about signedness + information
460 about primitive pointers (AddrRep). Signedness and primitive
461 pointers are required when passing a primitive type to a foreign
462 function, but aren't needed for call/return conventions of Haskell
465 - A MachRep is a basic machine type (non-void, doesn't contain
466 information on pointerhood or signedness, but contains some
467 reps that don't have corresponding Haskell types).
473 | IntRep -- signed, word-sized
474 | WordRep -- unsinged, word-sized
475 | Int64Rep -- signed, 64 bit (32-bit words only)
476 | Word64Rep -- unsigned, 64 bit (32-bit words only)
477 | AddrRep -- a pointer, but not to a Haskell value
482 -- Size of a PrimRep, in bytes
483 sizeofPrimRep :: PrimRep -> Int
484 sizeofPrimRep IntRep = wORD_SIZE
485 sizeofPrimRep WordRep = wORD_SIZE
486 sizeofPrimRep Int64Rep = wORD64_SIZE
487 sizeofPrimRep Word64Rep= wORD64_SIZE
488 sizeofPrimRep FloatRep = 4
489 sizeofPrimRep DoubleRep= 8
490 sizeofPrimRep AddrRep = wORD_SIZE
491 sizeofPrimRep PtrRep = wORD_SIZE
492 sizeofPrimRep VoidRep = 0
495 %************************************************************************
497 \subsection{TyCon Construction}
499 %************************************************************************
501 Note: the TyCon constructors all take a Kind as one argument, even though
502 they could, in principle, work out their Kind from their other arguments.
503 But to do so they need functions from Types, and that makes a nasty
504 module mutual-recursion. And they aren't called from many places.
505 So we compromise, and move their Kind calculation to the call site.
508 mkFunTyCon :: Name -> Kind -> TyCon
511 tyConUnique = nameUnique name,
517 -- This is the making of a TyCon. Just the same as the old mkAlgTyCon,
518 -- but now you also have to pass in the generic information about the type
519 -- constructor - you can get hold of it easily (see Generics module)
520 mkAlgTyCon name kind tyvars stupid rhs sel_ids parent is_rec gen_info gadt_syn
523 tyConUnique = nameUnique name,
525 tyConArity = length tyvars,
526 tyConTyVars = tyvars,
527 algTcStupidTheta = stupid,
529 algTcSelIds = sel_ids,
530 algTcParent = ASSERT( okParent name parent ) parent,
532 algTcGadtSyntax = gadt_syn,
533 hasGenerics = gen_info
536 mkClassTyCon name kind tyvars rhs clas is_rec =
537 mkAlgTyCon name kind tyvars [] rhs [] (ClassTyCon clas) is_rec False False
539 mkTupleTyCon name kind arity tyvars con boxed gen_info
541 tyConUnique = nameUnique name,
546 tyConTyVars = tyvars,
548 hasGenerics = gen_info
551 -- Foreign-imported (.NET) type constructors are represented
552 -- as primitive, but *lifted*, TyCons for now. They are lifted
553 -- because the Haskell type T representing the (foreign) .NET
554 -- type T is actually implemented (in ILX) as a thunk<T>
555 mkForeignTyCon name ext_name kind arity
558 tyConUnique = nameUnique name,
561 primTyConRep = PtrRep, -- they all do
563 tyConExtName = ext_name
567 -- most Prim tycons are lifted
568 mkPrimTyCon name kind arity rep
569 = mkPrimTyCon' name kind arity rep True
571 mkVoidPrimTyCon name kind arity
572 = mkPrimTyCon' name kind arity VoidRep True
574 -- but RealWorld is lifted
575 mkLiftedPrimTyCon name kind arity rep
576 = mkPrimTyCon' name kind arity rep False
578 mkPrimTyCon' name kind arity rep is_unlifted
581 tyConUnique = nameUnique name,
585 isUnLifted = is_unlifted,
586 tyConExtName = Nothing
589 mkSynTyCon name kind tyvars rhs parent
592 tyConUnique = nameUnique name,
594 tyConArity = length tyvars,
595 tyConTyVars = tyvars,
600 mkCoercionTyCon name arity kindRule
603 tyConUnique = nameUnique name,
608 -- Super kinds always have arity zero
609 mkSuperKindTyCon name
612 tyConUnique = nameUnique name
617 isFunTyCon :: TyCon -> Bool
618 isFunTyCon (FunTyCon {}) = True
621 isAbstractTyCon :: TyCon -> Bool
622 isAbstractTyCon (AlgTyCon { algTcRhs = AbstractTyCon }) = True
623 isAbstractTyCon _ = False
625 makeTyConAbstract :: TyCon -> TyCon
626 makeTyConAbstract tc@(AlgTyCon {}) = tc { algTcRhs = AbstractTyCon }
627 makeTyConAbstract tc = pprPanic "makeTyConAbstract" (ppr tc)
629 isPrimTyCon :: TyCon -> Bool
630 isPrimTyCon (PrimTyCon {}) = True
631 isPrimTyCon _ = False
633 isUnLiftedTyCon :: TyCon -> Bool
634 isUnLiftedTyCon (PrimTyCon {isUnLifted = is_unlifted}) = is_unlifted
635 isUnLiftedTyCon (TupleTyCon {tyConBoxed = boxity}) = not (isBoxed boxity)
636 isUnLiftedTyCon _ = False
638 -- isAlgTyCon returns True for both @data@ and @newtype@
639 isAlgTyCon :: TyCon -> Bool
640 isAlgTyCon (AlgTyCon {}) = True
641 isAlgTyCon (TupleTyCon {}) = True
642 isAlgTyCon other = False
644 isDataTyCon :: TyCon -> Bool
645 -- isDataTyCon returns True for data types that are definitely
646 -- represented by heap-allocated constructors.
647 -- These are srcutinised by Core-level @case@ expressions, and they
648 -- get info tables allocated for them.
649 -- True for all @data@ types
650 -- False for newtypes
654 -- NB: for a data type family, T, only the *instance* tycons are
655 -- get an info table etc. The family tycon does not.
656 -- Hence False for OpenTyCon
657 isDataTyCon tc@(AlgTyCon {algTcRhs = rhs})
659 OpenTyCon {} -> False
662 AbstractTyCon -> False -- We don't know, so return False
663 isDataTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity
664 isDataTyCon other = False
666 isNewTyCon :: TyCon -> Bool
667 isNewTyCon (AlgTyCon {algTcRhs = NewTyCon {}}) = True
668 isNewTyCon other = False
670 unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, Maybe TyCon)
671 unwrapNewTyCon_maybe (AlgTyCon { tyConTyVars = tvs,
672 algTcRhs = NewTyCon { nt_co = mb_co,
674 = Just (tvs, rhs, mb_co)
675 unwrapNewTyCon_maybe other = Nothing
677 isProductTyCon :: TyCon -> Bool
679 -- has *one* constructor,
680 -- is *not* existential
682 -- may be DataType, NewType
683 -- may be unboxed or not,
684 -- may be recursive or not
686 isProductTyCon tc@(AlgTyCon {}) = case algTcRhs tc of
687 DataTyCon{ data_cons = [data_con] }
688 -> isVanillaDataCon data_con
691 isProductTyCon (TupleTyCon {}) = True
692 isProductTyCon other = False
694 isSynTyCon :: TyCon -> Bool
695 isSynTyCon (SynTyCon {}) = True
698 -- As for newtypes, it is in some contexts important to distinguish between
699 -- closed synonyms and synonym families, as synonym families have no unique
700 -- right hand side to which a synonym family application can expand.
702 isClosedSynTyCon :: TyCon -> Bool
703 isClosedSynTyCon tycon = isSynTyCon tycon && not (isOpenTyCon tycon)
705 isOpenSynTyCon :: TyCon -> Bool
706 isOpenSynTyCon tycon = isSynTyCon tycon && isOpenTyCon tycon
708 isGadtSyntaxTyCon :: TyCon -> Bool
709 isGadtSyntaxTyCon (AlgTyCon { algTcGadtSyntax = res }) = res
710 isGadtSyntaxTyCon other = False
712 isEnumerationTyCon :: TyCon -> Bool
713 isEnumerationTyCon (AlgTyCon {algTcRhs = DataTyCon { is_enum = res }}) = res
714 isEnumerationTyCon other = False
716 isOpenTyCon :: TyCon -> Bool
717 isOpenTyCon (SynTyCon {synTcRhs = OpenSynTyCon _ _}) = True
718 isOpenTyCon (AlgTyCon {algTcRhs = OpenTyCon {} }) = True
719 isOpenTyCon _ = False
721 assocTyConArgPoss_maybe :: TyCon -> Maybe [Int]
722 assocTyConArgPoss_maybe (AlgTyCon {
723 algTcRhs = OpenTyCon {otArgPoss = poss}}) = poss
724 assocTyConArgPoss_maybe (SynTyCon { synTcRhs = OpenSynTyCon _ poss }) = poss
725 assocTyConArgPoss_maybe _ = Nothing
727 isTyConAssoc :: TyCon -> Bool
728 isTyConAssoc = isJust . assocTyConArgPoss_maybe
730 setTyConArgPoss :: TyCon -> [Int] -> TyCon
731 setTyConArgPoss tc@(AlgTyCon { algTcRhs = rhs }) poss =
732 tc { algTcRhs = rhs {otArgPoss = Just poss} }
733 setTyConArgPoss tc@(SynTyCon { synTcRhs = OpenSynTyCon ki _ }) poss =
734 tc { synTcRhs = OpenSynTyCon ki (Just poss) }
735 setTyConArgPoss tc _ = pprPanic "setTyConArgPoss" (ppr tc)
737 isTupleTyCon :: TyCon -> Bool
738 -- The unit tycon didn't used to be classed as a tuple tycon
739 -- but I thought that was silly so I've undone it
740 -- If it can't be for some reason, it should be a AlgTyCon
742 -- NB: when compiling Data.Tuple, the tycons won't reply True to
743 -- isTupleTyCon, becuase they are built as AlgTyCons. However they
744 -- get spat into the interface file as tuple tycons, so I don't think
746 isTupleTyCon (TupleTyCon {}) = True
747 isTupleTyCon other = False
749 isUnboxedTupleTyCon :: TyCon -> Bool
750 isUnboxedTupleTyCon (TupleTyCon {tyConBoxed = boxity}) = not (isBoxed boxity)
751 isUnboxedTupleTyCon other = False
753 isBoxedTupleTyCon :: TyCon -> Bool
754 isBoxedTupleTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity
755 isBoxedTupleTyCon other = False
757 tupleTyConBoxity tc = tyConBoxed tc
759 isRecursiveTyCon :: TyCon -> Bool
760 isRecursiveTyCon (AlgTyCon {algTcRec = Recursive}) = True
761 isRecursiveTyCon other = False
763 isHiBootTyCon :: TyCon -> Bool
764 -- Used for knot-tying in hi-boot files
765 isHiBootTyCon (AlgTyCon {algTcRhs = AbstractTyCon}) = True
766 isHiBootTyCon other = False
768 isForeignTyCon :: TyCon -> Bool
769 -- isForeignTyCon identifies foreign-imported type constructors
770 isForeignTyCon (PrimTyCon {tyConExtName = Just _}) = True
771 isForeignTyCon other = False
773 isSuperKindTyCon :: TyCon -> Bool
774 isSuperKindTyCon (SuperKindTyCon {}) = True
775 isSuperKindTyCon other = False
777 isCoercionTyCon_maybe :: TyCon -> Maybe (Arity, [Type] -> (Type,Type))
778 isCoercionTyCon_maybe (CoercionTyCon {tyConArity = ar, coKindFun = rule})
780 isCoercionTyCon_maybe other = Nothing
782 isCoercionTyCon :: TyCon -> Bool
783 isCoercionTyCon (CoercionTyCon {}) = True
784 isCoercionTyCon other = False
786 -- Identifies implicit tycons that, in particular, do not go into interface
787 -- files (because they are implicitly reconstructed when the interface is
792 -- * associated families are implicit, as they are re-constructed from
793 -- the class declaration in which they reside, and
794 -- * family instances are *not* implicit as they represent the instance body
795 -- (similar to a dfun does that for a class instance).
797 isImplicitTyCon :: TyCon -> Bool
798 isImplicitTyCon tycon | isTyConAssoc tycon = True
799 | isSynTyCon tycon = False
800 | isAlgTyCon tycon = isClassTyCon tycon ||
802 isImplicitTyCon _other = True
803 -- catches: FunTyCon, PrimTyCon,
804 -- CoercionTyCon, SuperKindTyCon
808 -----------------------------------------------
809 -- Expand type-constructor applications
810 -----------------------------------------------
813 tcExpandTyCon_maybe, coreExpandTyCon_maybe
815 -> [Type] -- Args to tycon
816 -> Maybe ([(TyVar,Type)], -- Substitution
817 Type, -- Body type (not yet substituted)
818 [Type]) -- Leftover args
820 -- For the *typechecker* view, we expand (closed) synonyms only
821 tcExpandTyCon_maybe (SynTyCon {tyConTyVars = tvs,
822 synTcRhs = SynonymTyCon rhs }) tys
824 tcExpandTyCon_maybe other_tycon tys = Nothing
827 -- For the *Core* view, we expand synonyms only as well
829 coreExpandTyCon_maybe (AlgTyCon {algTcRec = NonRecursive, -- Not recursive
830 algTcRhs = NewTyCon { nt_etad_rhs = etad_rhs, nt_co = Nothing }}) tys
831 = case etad_rhs of -- Don't do this in the pattern match, lest we accidentally
832 -- match the etad_rhs of a *recursive* newtype
833 (tvs,rhs) -> expand tvs rhs tys
835 coreExpandTyCon_maybe tycon tys = tcExpandTyCon_maybe tycon tys
839 expand :: [TyVar] -> Type -- Template
841 -> Maybe ([(TyVar,Type)], Type, [Type]) -- Expansion
843 = case n_tvs `compare` length tys of
844 LT -> Just (tvs `zip` tys, rhs, drop n_tvs tys)
845 EQ -> Just (tvs `zip` tys, rhs, [])
852 tyConHasGenerics :: TyCon -> Bool
853 tyConHasGenerics (AlgTyCon {hasGenerics = hg}) = hg
854 tyConHasGenerics (TupleTyCon {hasGenerics = hg}) = hg
855 tyConHasGenerics other = False -- Synonyms
857 tyConDataCons :: TyCon -> [DataCon]
858 -- It's convenient for tyConDataCons to return the
859 -- empty list for type synonyms etc
860 tyConDataCons tycon = tyConDataCons_maybe tycon `orElse` []
862 tyConDataCons_maybe :: TyCon -> Maybe [DataCon]
863 tyConDataCons_maybe (AlgTyCon {algTcRhs = DataTyCon { data_cons = cons }}) = Just cons
864 tyConDataCons_maybe (AlgTyCon {algTcRhs = NewTyCon { data_con = con }}) = Just [con]
865 tyConDataCons_maybe (TupleTyCon {dataCon = con}) = Just [con]
866 tyConDataCons_maybe other = Nothing
868 tyConFamilySize :: TyCon -> Int
869 tyConFamilySize (AlgTyCon {algTcRhs = DataTyCon {data_cons = cons}}) =
871 tyConFamilySize (AlgTyCon {algTcRhs = NewTyCon {}}) = 1
872 tyConFamilySize (AlgTyCon {algTcRhs = OpenTyCon {}}) = 0
873 tyConFamilySize (TupleTyCon {}) = 1
875 tyConFamilySize other = pprPanic "tyConFamilySize:" (ppr other)
878 tyConSelIds :: TyCon -> [Id]
879 tyConSelIds (AlgTyCon {algTcSelIds = fs}) = fs
880 tyConSelIds other_tycon = []
882 algTyConRhs :: TyCon -> AlgTyConRhs
883 algTyConRhs (AlgTyCon {algTcRhs = rhs}) = rhs
884 algTyConRhs (TupleTyCon {dataCon = con}) = DataTyCon { data_cons = [con], is_enum = False }
885 algTyConRhs other = pprPanic "algTyConRhs" (ppr other)
889 newTyConRhs :: TyCon -> ([TyVar], Type)
890 newTyConRhs (AlgTyCon {tyConTyVars = tvs, algTcRhs = NewTyCon { nt_rhs = rhs }}) = (tvs, rhs)
891 newTyConRhs tycon = pprPanic "newTyConRhs" (ppr tycon)
893 newTyConEtadRhs :: TyCon -> ([TyVar], Type)
894 newTyConEtadRhs (AlgTyCon {algTcRhs = NewTyCon { nt_etad_rhs = tvs_rhs }}) = tvs_rhs
895 newTyConEtadRhs tycon = pprPanic "newTyConEtadRhs" (ppr tycon)
897 newTyConRep :: TyCon -> ([TyVar], Type)
898 newTyConRep (AlgTyCon {tyConTyVars = tvs, algTcRhs = NewTyCon { nt_rep = rep }}) = (tvs, rep)
899 newTyConRep tycon = pprPanic "newTyConRep" (ppr tycon)
901 newTyConCo_maybe :: TyCon -> Maybe TyCon
902 newTyConCo_maybe (AlgTyCon {algTcRhs = NewTyCon { nt_co = co }}) = co
903 newTyConCo_maybe _ = Nothing
905 tyConPrimRep :: TyCon -> PrimRep
906 tyConPrimRep (PrimTyCon {primTyConRep = rep}) = rep
907 tyConPrimRep tc = ASSERT(not (isUnboxedTupleTyCon tc)) PtrRep
911 tyConStupidTheta :: TyCon -> [PredType]
912 tyConStupidTheta (AlgTyCon {algTcStupidTheta = stupid}) = stupid
913 tyConStupidTheta (TupleTyCon {}) = []
914 tyConStupidTheta tycon = pprPanic "tyConStupidTheta" (ppr tycon)
918 synTyConDefn :: TyCon -> ([TyVar], Type)
919 synTyConDefn (SynTyCon {tyConTyVars = tyvars, synTcRhs = SynonymTyCon ty})
921 synTyConDefn tycon = pprPanic "getSynTyConDefn" (ppr tycon)
923 synTyConRhs :: TyCon -> SynTyConRhs
924 synTyConRhs (SynTyCon {synTcRhs = rhs}) = rhs
925 synTyConRhs tc = pprPanic "synTyConRhs" (ppr tc)
927 synTyConType :: TyCon -> Type
928 synTyConType tc = case synTcRhs tc of
930 _ -> pprPanic "synTyConType" (ppr tc)
932 synTyConResKind :: TyCon -> Kind
933 synTyConResKind (SynTyCon {synTcRhs = OpenSynTyCon kind _}) = kind
934 synTyConResKind tycon = pprPanic "synTyConResKind" (ppr tycon)
938 maybeTyConSingleCon :: TyCon -> Maybe DataCon
939 maybeTyConSingleCon (AlgTyCon {algTcRhs = DataTyCon {data_cons = [c] }}) = Just c
940 maybeTyConSingleCon (AlgTyCon {algTcRhs = NewTyCon { data_con = c }}) = Just c
941 maybeTyConSingleCon (AlgTyCon {}) = Nothing
942 maybeTyConSingleCon (TupleTyCon {dataCon = con}) = Just con
943 maybeTyConSingleCon (PrimTyCon {}) = Nothing
944 maybeTyConSingleCon (FunTyCon {}) = Nothing -- case at funty
945 maybeTyConSingleCon tc = pprPanic "maybeTyConSingleCon: unexpected tycon " $ ppr tc
949 isClassTyCon :: TyCon -> Bool
950 isClassTyCon (AlgTyCon {algTcParent = ClassTyCon _}) = True
951 isClassTyCon other_tycon = False
953 tyConClass_maybe :: TyCon -> Maybe Class
954 tyConClass_maybe (AlgTyCon {algTcParent = ClassTyCon clas}) = Just clas
955 tyConClass_maybe other_tycon = Nothing
957 isFamInstTyCon :: TyCon -> Bool
958 isFamInstTyCon (AlgTyCon {algTcParent = FamilyTyCon _ _ _ }) = True
959 isFamInstTyCon (SynTyCon {synTcParent = FamilyTyCon _ _ _ }) = True
960 isFamInstTyCon other_tycon = False
962 tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])
963 tyConFamInst_maybe (AlgTyCon {algTcParent = FamilyTyCon fam instTys _}) =
965 tyConFamInst_maybe (SynTyCon {synTcParent = FamilyTyCon fam instTys _}) =
967 tyConFamInst_maybe other_tycon =
970 tyConFamilyCoercion_maybe :: TyCon -> Maybe TyCon
971 tyConFamilyCoercion_maybe (AlgTyCon {algTcParent = FamilyTyCon _ _ coe}) =
973 tyConFamilyCoercion_maybe (SynTyCon {synTcParent = FamilyTyCon _ _ coe}) =
975 tyConFamilyCoercion_maybe other_tycon =
980 %************************************************************************
982 \subsection[TyCon-instances]{Instance declarations for @TyCon@}
984 %************************************************************************
986 @TyCon@s are compared by comparing their @Unique@s.
988 The strictness analyser needs @Ord@. It is a lexicographic order with
989 the property @(a<=b) || (b<=a)@.
992 instance Eq TyCon where
993 a == b = case (a `compare` b) of { EQ -> True; _ -> False }
994 a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
996 instance Ord TyCon where
997 a <= b = case (a `compare` b) of { LT -> True; EQ -> True; GT -> False }
998 a < b = case (a `compare` b) of { LT -> True; EQ -> False; GT -> False }
999 a >= b = case (a `compare` b) of { LT -> False; EQ -> True; GT -> True }
1000 a > b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True }
1001 compare a b = getUnique a `compare` getUnique b
1003 instance Uniquable TyCon where
1004 getUnique tc = tyConUnique tc
1006 instance Outputable TyCon where
1007 ppr tc = ppr (getName tc)
1009 instance NamedThing TyCon where