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]
260 nt_etad_rhs :: ([TyVar], Type) ,
261 -- The same again, but this time eta-reduced
262 -- hence the [TyVar] which may be shorter than the declared
263 -- arity of the TyCon. See Note [Newtype eta]
265 nt_rep :: Type -- Cached: the *ultimate* representation type
266 -- By 'ultimate' I mean that the top-level constructor
267 -- of the rep type is not itself a newtype or type synonym.
268 -- The rep type isn't entirely simple:
269 -- for a recursive newtype we pick () as the rep type
272 -- This one does not need to be eta reduced; hence its
273 -- free type variables are conveniently tyConTyVars
275 -- newtype T a = MkT [(a,Int)]
276 -- The rep type is [(a,Int)]
277 -- NB: the rep type isn't necessarily the original RHS of the
278 -- newtype decl, because the rep type looks through other
281 visibleDataCons :: AlgTyConRhs -> [DataCon]
282 visibleDataCons AbstractTyCon = []
283 visibleDataCons OpenTyCon {} = []
284 visibleDataCons (DataTyCon{ data_cons = cs }) = cs
285 visibleDataCons (NewTyCon{ data_con = c }) = [c]
287 -- Both type classes as well as family instances imply implicit
288 -- type constructors. These implicit type constructors refer to their parent
289 -- structure (ie, the class or family from which they derive) using a type of
290 -- the following form. We use `TyConParent' for both algebraic and synonym
291 -- types, but the variant `ClassTyCon' will only be used by algebraic tycons.
294 = NoParentTyCon -- An ordinary type constructor has no parent.
296 | ClassTyCon -- Type constructors representing a class dictionary.
297 Class -- INVARIANT: the classTyCon of this Class is the current tycon
299 | FamilyTyCon -- Type constructors representing an instance of a type
300 TyCon -- The type family
301 [Type] -- Instance types; free variables are the tyConTyVars
302 -- of the current TyCon (not the family one)
303 -- INVARIANT: the number of types matches the arity
304 -- of the family tycon
305 TyCon -- A CoercionTyCon identifying the representation
306 -- type with the type instance family.
307 -- c.f. Note [Newtype coercions]
310 -- E.g. data intance T [a] = ...
311 -- gives a representation tycon:
313 -- axiom co a :: T [a] ~ :R7T a
314 -- with :R7T's algTcParent = FamilyTyCon T [a] co
316 okParent :: Name -> TyConParent -> Bool -- Checks invariants
317 okParent tc_name NoParentTyCon = True
318 okParent tc_name (ClassTyCon cls) = tyConName (classTyCon cls) == tc_name
319 okParent tc_name (FamilyTyCon fam_tc tys co_tc) = tyConArity fam_tc == length tys
323 = OpenSynTyCon Kind -- Type family: *result* kind given
324 (Maybe [Int]) -- for associated families: for each tyvars in
325 -- the AT decl, gives the position of that
326 -- tyvar in the class argument list (starting
328 -- NB: Length is less than tyConArity
329 -- if higher kind signature.
331 | SynonymTyCon Type -- Mentioning head type vars. Acts as a template for
332 -- the expansion when the tycon is applied to some
336 Note [Newtype coercions]
337 ~~~~~~~~~~~~~~~~~~~~~~~~
338 The NewTyCon field nt_co is a a TyCon (a coercion constructor in fact)
339 which is used for coercing from the representation type of the
340 newtype, to the newtype itself. For example,
342 newtype T a = MkT (a -> a)
344 the NewTyCon for T will contain nt_co = CoT where CoT t : T t :=: t ->
345 t. This TyCon is a CoercionTyCon, so it does not have a kind on its
346 own; it basically has its own typing rule for the fully-applied
347 version. If the newtype T has k type variables then CoT has arity at
348 most k. In the case that the right hand side is a type application
349 ending with the same type variables as the left hand side, we
350 "eta-contract" the coercion. So if we had
352 newtype S a = MkT [a]
354 then we would generate the arity 0 coercion CoS : S :=: []. The
355 primary reason we do this is to make newtype deriving cleaner.
357 In the paper we'd write
358 axiom CoT : (forall t. T t) :=: (forall t. [t])
359 and then when we used CoT at a particular type, s, we'd say
361 which encodes as (TyConApp instCoercionTyCon [TyConApp CoT [], s])
363 But in GHC we instead make CoT into a new piece of type syntax, CoercionTyCon,
364 (like instCoercionTyCon, symCoercionTyCon etc), which must always
365 be saturated, but which encodes as
367 In the vocabulary of the paper it's as if we had axiom declarations
369 axiom CoT t : T t :=: [t]
374 newtype Parser m a = MkParser (Foogle m a)
375 Are these two types equal (to Core)?
378 Well, yes. But to see that easily we eta-reduce the RHS type of
379 Parser, in this case to ([], Froogle), so that even unsaturated applications
380 of Parser will work right. This eta reduction is done when the type
381 constructor is built, and cached in NewTyCon. The cached field is
382 only used in coreExpandTyCon_maybe.
384 Here's an example that I think showed up in practice
386 newtype T a = MkT [a]
387 newtype Foo m = MkFoo (forall a. m a -> Int)
393 w2 = MkFoo (\(MkT x) -> case w1 of MkFoo f -> f x)
395 After desugaring, and discading the data constructors for the newtypes,
399 And now Lint complains unless Foo T == Foo [], and that requires T==[]
401 This point carries over to the newtype coercion, because we need to
403 w2 = w1 `cast` Foo CoT
405 so the coercion tycon CoT must have
410 Note [Indexed data types] (aka data type families)
411 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
412 See also Note [Wrappers for data instance tycons] in MkId.lhs
417 data instance T (b,c) where
418 T1 :: b -> c -> T (b,c)
421 * T is the "family TyCon"
423 * We make "representation TyCon" :R1T, thus:
425 T1 :: forall b c. b -> c -> :R1T b c
427 * It has a top-level coercion connecting it to the family TyCon
429 axiom :Co:R1T b c : T (b,c) ~ :R1T b c
431 * The data contructor T1 has a wrapper (which is what the source-level
434 $WT1 :: forall b c. b -> c -> T (b,c)
435 $WT1 b c (x::b) (y::c) = T1 b c x y `cast` sym (:Co:R1T b c)
437 * The representation TyCon :R1T has an AlgTyConParent of
439 FamilyTyCon T [(b,c)] :Co:R1T
443 %************************************************************************
447 %************************************************************************
449 A PrimRep is an abstraction of a type. It contains information that
450 the code generator needs in order to pass arguments, return results,
451 and store values of this type.
453 A PrimRep is somewhat similar to a CgRep (see codeGen/SMRep) and a
454 MachRep (see cmm/MachOp), although each of these types has a distinct
455 and clearly defined purpose:
457 - A PrimRep is a CgRep + information about signedness + information
458 about primitive pointers (AddrRep). Signedness and primitive
459 pointers are required when passing a primitive type to a foreign
460 function, but aren't needed for call/return conventions of Haskell
463 - A MachRep is a basic machine type (non-void, doesn't contain
464 information on pointerhood or signedness, but contains some
465 reps that don't have corresponding Haskell types).
471 | IntRep -- signed, word-sized
472 | WordRep -- unsinged, word-sized
473 | Int64Rep -- signed, 64 bit (32-bit words only)
474 | Word64Rep -- unsigned, 64 bit (32-bit words only)
475 | AddrRep -- a pointer, but not to a Haskell value
479 -- Size of a PrimRep, in bytes
480 sizeofPrimRep :: PrimRep -> Int
481 sizeofPrimRep IntRep = wORD_SIZE
482 sizeofPrimRep WordRep = wORD_SIZE
483 sizeofPrimRep Int64Rep = wORD64_SIZE
484 sizeofPrimRep Word64Rep= wORD64_SIZE
485 sizeofPrimRep FloatRep = 4
486 sizeofPrimRep DoubleRep= 8
487 sizeofPrimRep AddrRep = wORD_SIZE
488 sizeofPrimRep PtrRep = wORD_SIZE
489 sizeofPrimRep VoidRep = 0
492 %************************************************************************
494 \subsection{TyCon Construction}
496 %************************************************************************
498 Note: the TyCon constructors all take a Kind as one argument, even though
499 they could, in principle, work out their Kind from their other arguments.
500 But to do so they need functions from Types, and that makes a nasty
501 module mutual-recursion. And they aren't called from many places.
502 So we compromise, and move their Kind calculation to the call site.
505 mkFunTyCon :: Name -> Kind -> TyCon
508 tyConUnique = nameUnique name,
514 -- This is the making of a TyCon. Just the same as the old mkAlgTyCon,
515 -- but now you also have to pass in the generic information about the type
516 -- constructor - you can get hold of it easily (see Generics module)
517 mkAlgTyCon name kind tyvars stupid rhs sel_ids parent is_rec gen_info gadt_syn
520 tyConUnique = nameUnique name,
522 tyConArity = length tyvars,
523 tyConTyVars = tyvars,
524 algTcStupidTheta = stupid,
526 algTcSelIds = sel_ids,
527 algTcParent = ASSERT( okParent name parent ) parent,
529 algTcGadtSyntax = gadt_syn,
530 hasGenerics = gen_info
533 mkClassTyCon name kind tyvars rhs clas is_rec =
534 mkAlgTyCon name kind tyvars [] rhs [] (ClassTyCon clas) is_rec False False
536 mkTupleTyCon name kind arity tyvars con boxed gen_info
538 tyConUnique = nameUnique name,
543 tyConTyVars = tyvars,
545 hasGenerics = gen_info
548 -- Foreign-imported (.NET) type constructors are represented
549 -- as primitive, but *lifted*, TyCons for now. They are lifted
550 -- because the Haskell type T representing the (foreign) .NET
551 -- type T is actually implemented (in ILX) as a thunk<T>
552 mkForeignTyCon name ext_name kind arity
555 tyConUnique = nameUnique name,
558 primTyConRep = PtrRep, -- they all do
560 tyConExtName = ext_name
564 -- most Prim tycons are lifted
565 mkPrimTyCon name kind arity rep
566 = mkPrimTyCon' name kind arity rep True
568 mkVoidPrimTyCon name kind arity
569 = mkPrimTyCon' name kind arity VoidRep True
571 -- but RealWorld is lifted
572 mkLiftedPrimTyCon name kind arity rep
573 = mkPrimTyCon' name kind arity rep False
575 mkPrimTyCon' name kind arity rep is_unlifted
578 tyConUnique = nameUnique name,
582 isUnLifted = is_unlifted,
583 tyConExtName = Nothing
586 mkSynTyCon name kind tyvars rhs parent
589 tyConUnique = nameUnique name,
591 tyConArity = length tyvars,
592 tyConTyVars = tyvars,
597 mkCoercionTyCon name arity kindRule
600 tyConUnique = nameUnique name,
605 -- Super kinds always have arity zero
606 mkSuperKindTyCon name
609 tyConUnique = nameUnique name
614 isFunTyCon :: TyCon -> Bool
615 isFunTyCon (FunTyCon {}) = True
618 isAbstractTyCon :: TyCon -> Bool
619 isAbstractTyCon (AlgTyCon { algTcRhs = AbstractTyCon }) = True
620 isAbstractTyCon _ = False
622 makeTyConAbstract :: TyCon -> TyCon
623 makeTyConAbstract tc@(AlgTyCon {}) = tc { algTcRhs = AbstractTyCon }
624 makeTyConAbstract tc = pprPanic "makeTyConAbstract" (ppr tc)
626 isPrimTyCon :: TyCon -> Bool
627 isPrimTyCon (PrimTyCon {}) = True
628 isPrimTyCon _ = False
630 isUnLiftedTyCon :: TyCon -> Bool
631 isUnLiftedTyCon (PrimTyCon {isUnLifted = is_unlifted}) = is_unlifted
632 isUnLiftedTyCon (TupleTyCon {tyConBoxed = boxity}) = not (isBoxed boxity)
633 isUnLiftedTyCon _ = False
635 -- isAlgTyCon returns True for both @data@ and @newtype@
636 isAlgTyCon :: TyCon -> Bool
637 isAlgTyCon (AlgTyCon {}) = True
638 isAlgTyCon (TupleTyCon {}) = True
639 isAlgTyCon other = False
641 isDataTyCon :: TyCon -> Bool
642 -- isDataTyCon returns True for data types that are definitely
643 -- represented by heap-allocated constructors.
644 -- These are srcutinised by Core-level @case@ expressions, and they
645 -- get info tables allocated for them.
646 -- True for all @data@ types
647 -- False for newtypes
651 -- NB: for a data type family, T, only the *instance* tycons are
652 -- get an info table etc. The family tycon does not.
653 -- Hence False for OpenTyCon
654 isDataTyCon tc@(AlgTyCon {algTcRhs = rhs})
656 OpenTyCon {} -> False
659 AbstractTyCon -> False -- We don't know, so return False
660 isDataTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity
661 isDataTyCon other = False
663 isNewTyCon :: TyCon -> Bool
664 isNewTyCon (AlgTyCon {algTcRhs = NewTyCon {}}) = True
665 isNewTyCon other = False
667 unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, Maybe TyCon)
668 unwrapNewTyCon_maybe (AlgTyCon { tyConTyVars = tvs,
669 algTcRhs = NewTyCon { nt_co = mb_co,
671 = Just (tvs, rhs, mb_co)
672 unwrapNewTyCon_maybe other = Nothing
674 isProductTyCon :: TyCon -> Bool
676 -- has *one* constructor,
677 -- is *not* existential
679 -- may be DataType, NewType
680 -- may be unboxed or not,
681 -- may be recursive or not
683 isProductTyCon tc@(AlgTyCon {}) = case algTcRhs tc of
684 DataTyCon{ data_cons = [data_con] }
685 -> isVanillaDataCon data_con
688 isProductTyCon (TupleTyCon {}) = True
689 isProductTyCon other = False
691 isSynTyCon :: TyCon -> Bool
692 isSynTyCon (SynTyCon {}) = True
695 -- As for newtypes, it is in some contexts important to distinguish between
696 -- closed synonyms and synonym families, as synonym families have no unique
697 -- right hand side to which a synonym family application can expand.
699 isClosedSynTyCon :: TyCon -> Bool
700 isClosedSynTyCon tycon = isSynTyCon tycon && not (isOpenTyCon tycon)
702 isOpenSynTyCon :: TyCon -> Bool
703 isOpenSynTyCon tycon = isSynTyCon tycon && isOpenTyCon tycon
705 isGadtSyntaxTyCon :: TyCon -> Bool
706 isGadtSyntaxTyCon (AlgTyCon { algTcGadtSyntax = res }) = res
707 isGadtSyntaxTyCon other = False
709 isEnumerationTyCon :: TyCon -> Bool
710 isEnumerationTyCon (AlgTyCon {algTcRhs = DataTyCon { is_enum = res }}) = res
711 isEnumerationTyCon other = False
713 isOpenTyCon :: TyCon -> Bool
714 isOpenTyCon (SynTyCon {synTcRhs = OpenSynTyCon _ _}) = True
715 isOpenTyCon (AlgTyCon {algTcRhs = OpenTyCon {} }) = True
716 isOpenTyCon _ = False
718 assocTyConArgPoss_maybe :: TyCon -> Maybe [Int]
719 assocTyConArgPoss_maybe (AlgTyCon {
720 algTcRhs = OpenTyCon {otArgPoss = poss}}) = poss
721 assocTyConArgPoss_maybe (SynTyCon { synTcRhs = OpenSynTyCon _ poss }) = poss
722 assocTyConArgPoss_maybe _ = Nothing
724 isTyConAssoc :: TyCon -> Bool
725 isTyConAssoc = isJust . assocTyConArgPoss_maybe
727 setTyConArgPoss :: TyCon -> [Int] -> TyCon
728 setTyConArgPoss tc@(AlgTyCon { algTcRhs = rhs }) poss =
729 tc { algTcRhs = rhs {otArgPoss = Just poss} }
730 setTyConArgPoss tc@(SynTyCon { synTcRhs = OpenSynTyCon ki _ }) poss =
731 tc { synTcRhs = OpenSynTyCon ki (Just poss) }
732 setTyConArgPoss tc _ = pprPanic "setTyConArgPoss" (ppr tc)
734 isTupleTyCon :: TyCon -> Bool
735 -- The unit tycon didn't used to be classed as a tuple tycon
736 -- but I thought that was silly so I've undone it
737 -- If it can't be for some reason, it should be a AlgTyCon
739 -- NB: when compiling Data.Tuple, the tycons won't reply True to
740 -- isTupleTyCon, becuase they are built as AlgTyCons. However they
741 -- get spat into the interface file as tuple tycons, so I don't think
743 isTupleTyCon (TupleTyCon {}) = True
744 isTupleTyCon other = False
746 isUnboxedTupleTyCon :: TyCon -> Bool
747 isUnboxedTupleTyCon (TupleTyCon {tyConBoxed = boxity}) = not (isBoxed boxity)
748 isUnboxedTupleTyCon other = False
750 isBoxedTupleTyCon :: TyCon -> Bool
751 isBoxedTupleTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity
752 isBoxedTupleTyCon other = False
754 tupleTyConBoxity tc = tyConBoxed tc
756 isRecursiveTyCon :: TyCon -> Bool
757 isRecursiveTyCon (AlgTyCon {algTcRec = Recursive}) = True
758 isRecursiveTyCon other = False
760 isHiBootTyCon :: TyCon -> Bool
761 -- Used for knot-tying in hi-boot files
762 isHiBootTyCon (AlgTyCon {algTcRhs = AbstractTyCon}) = True
763 isHiBootTyCon other = False
765 isForeignTyCon :: TyCon -> Bool
766 -- isForeignTyCon identifies foreign-imported type constructors
767 isForeignTyCon (PrimTyCon {tyConExtName = Just _}) = True
768 isForeignTyCon other = False
770 isSuperKindTyCon :: TyCon -> Bool
771 isSuperKindTyCon (SuperKindTyCon {}) = True
772 isSuperKindTyCon other = False
774 isCoercionTyCon_maybe :: TyCon -> Maybe (Arity, [Type] -> (Type,Type))
775 isCoercionTyCon_maybe (CoercionTyCon {tyConArity = ar, coKindFun = rule})
777 isCoercionTyCon_maybe other = Nothing
779 isCoercionTyCon :: TyCon -> Bool
780 isCoercionTyCon (CoercionTyCon {}) = True
781 isCoercionTyCon other = False
783 -- Identifies implicit tycons that, in particular, do not go into interface
784 -- files (because they are implicitly reconstructed when the interface is
789 -- * associated families are implicit, as they are re-constructed from
790 -- the class declaration in which they reside, and
791 -- * family instances are *not* implicit as they represent the instance body
792 -- (similar to a dfun does that for a class instance).
794 isImplicitTyCon :: TyCon -> Bool
795 isImplicitTyCon tycon | isTyConAssoc tycon = True
796 | isSynTyCon tycon = False
797 | isAlgTyCon tycon = isClassTyCon tycon ||
799 isImplicitTyCon _other = True
800 -- catches: FunTyCon, PrimTyCon,
801 -- CoercionTyCon, SuperKindTyCon
805 -----------------------------------------------
806 -- Expand type-constructor applications
807 -----------------------------------------------
810 tcExpandTyCon_maybe, coreExpandTyCon_maybe
812 -> [Type] -- Args to tycon
813 -> Maybe ([(TyVar,Type)], -- Substitution
814 Type, -- Body type (not yet substituted)
815 [Type]) -- Leftover args
817 -- For the *typechecker* view, we expand synonyms only
818 tcExpandTyCon_maybe (SynTyCon {tyConTyVars = tvs,
819 synTcRhs = SynonymTyCon rhs }) tys
821 tcExpandTyCon_maybe other_tycon tys = Nothing
824 -- For the *Core* view, we expand synonyms only as well
826 coreExpandTyCon_maybe (AlgTyCon {algTcRec = NonRecursive, -- Not recursive
827 algTcRhs = NewTyCon { nt_etad_rhs = etad_rhs, nt_co = Nothing }}) tys
828 = case etad_rhs of -- Don't do this in the pattern match, lest we accidentally
829 -- match the etad_rhs of a *recursive* newtype
830 (tvs,rhs) -> expand tvs rhs tys
832 coreExpandTyCon_maybe tycon tys = tcExpandTyCon_maybe tycon tys
836 expand :: [TyVar] -> Type -- Template
838 -> Maybe ([(TyVar,Type)], Type, [Type]) -- Expansion
840 = case n_tvs `compare` length tys of
841 LT -> Just (tvs `zip` tys, rhs, drop n_tvs tys)
842 EQ -> Just (tvs `zip` tys, rhs, [])
849 tyConHasGenerics :: TyCon -> Bool
850 tyConHasGenerics (AlgTyCon {hasGenerics = hg}) = hg
851 tyConHasGenerics (TupleTyCon {hasGenerics = hg}) = hg
852 tyConHasGenerics other = False -- Synonyms
854 tyConDataCons :: TyCon -> [DataCon]
855 -- It's convenient for tyConDataCons to return the
856 -- empty list for type synonyms etc
857 tyConDataCons tycon = tyConDataCons_maybe tycon `orElse` []
859 tyConDataCons_maybe :: TyCon -> Maybe [DataCon]
860 tyConDataCons_maybe (AlgTyCon {algTcRhs = DataTyCon { data_cons = cons }}) = Just cons
861 tyConDataCons_maybe (AlgTyCon {algTcRhs = NewTyCon { data_con = con }}) = Just [con]
862 tyConDataCons_maybe (TupleTyCon {dataCon = con}) = Just [con]
863 tyConDataCons_maybe other = Nothing
865 tyConFamilySize :: TyCon -> Int
866 tyConFamilySize (AlgTyCon {algTcRhs = DataTyCon {data_cons = cons}}) =
868 tyConFamilySize (AlgTyCon {algTcRhs = NewTyCon {}}) = 1
869 tyConFamilySize (AlgTyCon {algTcRhs = OpenTyCon {}}) = 0
870 tyConFamilySize (TupleTyCon {}) = 1
872 tyConFamilySize other = pprPanic "tyConFamilySize:" (ppr other)
875 tyConSelIds :: TyCon -> [Id]
876 tyConSelIds (AlgTyCon {algTcSelIds = fs}) = fs
877 tyConSelIds other_tycon = []
879 algTyConRhs :: TyCon -> AlgTyConRhs
880 algTyConRhs (AlgTyCon {algTcRhs = rhs}) = rhs
881 algTyConRhs (TupleTyCon {dataCon = con}) = DataTyCon { data_cons = [con], is_enum = False }
882 algTyConRhs other = pprPanic "algTyConRhs" (ppr other)
886 newTyConRhs :: TyCon -> ([TyVar], Type)
887 newTyConRhs (AlgTyCon {tyConTyVars = tvs, algTcRhs = NewTyCon { nt_rhs = rhs }}) = (tvs, rhs)
888 newTyConRhs tycon = pprPanic "newTyConRhs" (ppr tycon)
890 newTyConEtadRhs :: TyCon -> ([TyVar], Type)
891 newTyConEtadRhs (AlgTyCon {algTcRhs = NewTyCon { nt_etad_rhs = tvs_rhs }}) = tvs_rhs
892 newTyConEtadRhs tycon = pprPanic "newTyConEtadRhs" (ppr tycon)
894 newTyConRep :: TyCon -> ([TyVar], Type)
895 newTyConRep (AlgTyCon {tyConTyVars = tvs, algTcRhs = NewTyCon { nt_rep = rep }}) = (tvs, rep)
896 newTyConRep tycon = pprPanic "newTyConRep" (ppr tycon)
898 newTyConCo_maybe :: TyCon -> Maybe TyCon
899 newTyConCo_maybe (AlgTyCon {algTcRhs = NewTyCon { nt_co = co }}) = co
900 newTyConCo_maybe _ = Nothing
902 tyConPrimRep :: TyCon -> PrimRep
903 tyConPrimRep (PrimTyCon {primTyConRep = rep}) = rep
904 tyConPrimRep tc = ASSERT(not (isUnboxedTupleTyCon tc)) PtrRep
908 tyConStupidTheta :: TyCon -> [PredType]
909 tyConStupidTheta (AlgTyCon {algTcStupidTheta = stupid}) = stupid
910 tyConStupidTheta (TupleTyCon {}) = []
911 tyConStupidTheta tycon = pprPanic "tyConStupidTheta" (ppr tycon)
915 synTyConDefn :: TyCon -> ([TyVar], Type)
916 synTyConDefn (SynTyCon {tyConTyVars = tyvars, synTcRhs = SynonymTyCon ty})
918 synTyConDefn tycon = pprPanic "getSynTyConDefn" (ppr tycon)
920 synTyConRhs :: TyCon -> SynTyConRhs
921 synTyConRhs (SynTyCon {synTcRhs = rhs}) = rhs
922 synTyConRhs tc = pprPanic "synTyConRhs" (ppr tc)
924 synTyConType :: TyCon -> Type
925 synTyConType tc = case synTcRhs tc of
927 _ -> pprPanic "synTyConType" (ppr tc)
929 synTyConResKind :: TyCon -> Kind
930 synTyConResKind (SynTyCon {synTcRhs = OpenSynTyCon kind _}) = kind
931 synTyConResKind tycon = pprPanic "synTyConResKind" (ppr tycon)
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
946 isClassTyCon :: TyCon -> Bool
947 isClassTyCon (AlgTyCon {algTcParent = ClassTyCon _}) = True
948 isClassTyCon other_tycon = False
950 tyConClass_maybe :: TyCon -> Maybe Class
951 tyConClass_maybe (AlgTyCon {algTcParent = ClassTyCon clas}) = Just clas
952 tyConClass_maybe other_tycon = Nothing
954 isFamInstTyCon :: TyCon -> Bool
955 isFamInstTyCon (AlgTyCon {algTcParent = FamilyTyCon _ _ _ }) = True
956 isFamInstTyCon (SynTyCon {synTcParent = FamilyTyCon _ _ _ }) = True
957 isFamInstTyCon other_tycon = False
959 tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])
960 tyConFamInst_maybe (AlgTyCon {algTcParent = FamilyTyCon fam instTys _}) =
962 tyConFamInst_maybe (SynTyCon {synTcParent = FamilyTyCon fam instTys _}) =
964 tyConFamInst_maybe other_tycon =
967 tyConFamilyCoercion_maybe :: TyCon -> Maybe TyCon
968 tyConFamilyCoercion_maybe (AlgTyCon {algTcParent = FamilyTyCon _ _ coe}) =
970 tyConFamilyCoercion_maybe (SynTyCon {synTcParent = FamilyTyCon _ _ coe}) =
972 tyConFamilyCoercion_maybe other_tycon =
977 %************************************************************************
979 \subsection[TyCon-instances]{Instance declarations for @TyCon@}
981 %************************************************************************
983 @TyCon@s are compared by comparing their @Unique@s.
985 The strictness analyser needs @Ord@. It is a lexicographic order with
986 the property @(a<=b) || (b<=a)@.
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 }
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
1000 instance Uniquable TyCon where
1001 getUnique tc = tyConUnique tc
1003 instance Outputable TyCon where
1004 ppr tc = ppr (getName tc)
1006 instance NamedThing TyCon where