2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
10 -- * Main TyCon data types
13 AlgTyConRhs(..), visibleDataCons,
16 AssocFamilyPermutation,
18 -- ** Constructing TyCons
31 -- ** Predicates on TyCons
33 isClassTyCon, isFamInstTyCon,
36 isTupleTyCon, isUnboxedTupleTyCon, isBoxedTupleTyCon,
37 isSynTyCon, isClosedSynTyCon, isOpenSynTyCon,
39 isCoercionTyCon, isCoercionTyCon_maybe,
42 isDataTyCon, isProductTyCon, isEnumerationTyCon,
43 isNewTyCon, isAbstractTyCon, isOpenTyCon,
49 isImplicitTyCon, tyConHasGenerics,
51 -- ** Extracting information out of TyCons
56 tyConDataCons, tyConDataCons_maybe, tyConSingleDataCon_maybe,
62 tyConFamInst_maybe, tyConFamilyCoercion_maybe,
63 synTyConDefn, synTyConRhs, synTyConType, synTyConResKind,
64 tyConExtName, -- External name for foreign types
66 newTyConRhs, newTyConEtadRhs, unwrapNewTyCon_maybe,
67 assocTyConArgPoss_maybe,
70 -- ** Manipulating TyCons
71 tcExpandTyCon_maybe, coreExpandTyCon_maybe,
76 -- * Primitive representations of Types
82 #include "HsVersions.h"
84 import {-# SOURCE #-} TypeRep ( Kind, Type, PredType )
85 import {-# SOURCE #-} DataCon ( DataCon, isVanillaDataCon )
96 import Data.List( elemIndex )
99 %************************************************************************
101 \subsection{The data type}
103 %************************************************************************
106 -- | Represents type constructors. Type constructors are introduced by things such as:
108 -- 1) Data declarations: @data Foo = ...@ creates the @Foo@ type constructor of kind @*@
110 -- 2) Type synonyms: @type Foo = ...@ creates the @Foo@ type constructor
112 -- 3) Newtypes: @newtype Foo a = MkFoo ...@ creates the @Foo@ type constructor of kind @* -> *@
114 -- 4) Class declarations: @class Foo where@ creates the @Foo@ type constructor of kind @*@
116 -- 5) Type coercions! This is because we represent a coercion from @t1@ to @t2@ as a 'Type', where
117 -- that type has kind @t1 ~ t2@. See "Coercion" for more on this
119 -- This data type also encodes a number of primitive, built in type constructors such as those
120 -- for function and tuple types.
122 = -- | The function type constructor, @(->)@
124 tyConUnique :: Unique,
130 -- | Algebraic type constructors, which are defined to be those arising @data@ type and @newtype@ declarations.
131 -- All these constructors are lifted and boxed. See 'AlgTyConRhs' for more information.
133 tyConUnique :: Unique,
138 tyConTyVars :: [TyVar], -- ^ The type variables used in the type constructor.
139 -- Precisely, this list scopes over:
141 -- 1. The 'algTcStupidTheta'
143 -- 2. The cached types in 'algTyConRhs.NewTyCon'
145 -- 3. The family instance types if present
147 -- Note that it does /not/ scope over the data constructors.
149 algTcSelIds :: [Id], -- ^ The record selectors of this type (possibly emptys)
151 algTcGadtSyntax :: Bool, -- ^ Was the data type declared with GADT syntax? If so,
152 -- that doesn't mean it's a true GADT; only that the "where"
153 -- form was used. This field is used only to guide
155 algTcStupidTheta :: [PredType], -- ^ The \"stupid theta\" for the data type (always empty for GADTs).
156 -- A \"stupid theta\" is the context to the left of an algebraic type
157 -- declaration, e.g. @Eq a@ in the declaration @data Eq a => T a ...@.
159 algTcRhs :: AlgTyConRhs, -- ^ Contains information about the data constructors of the algebraic type
161 algTcRec :: RecFlag, -- ^ Tells us whether the data type is part of a mutually-recursive group or not
163 hasGenerics :: Bool, -- ^ Whether generic (in the -XGenerics sense) to\/from functions are
164 -- available in the exports of the data type's source module.
166 algTcParent :: TyConParent -- ^ Gives the class or family declaration 'TyCon' for derived 'TyCon's
167 -- representing class or family instances, respectively. See also 'synTcParent'
170 -- | Represents the infinite family of tuple type constructors, @()@, @(a,b)@, @(# a, b #)@ etc.
172 tyConUnique :: Unique,
176 tyConBoxed :: Boxity,
177 tyConTyVars :: [TyVar],
178 dataCon :: DataCon, -- ^ Corresponding tuple data constructor
182 -- | Represents type synonyms
184 tyConUnique :: Unique,
189 tyConTyVars :: [TyVar], -- Bound tyvars
191 synTcRhs :: SynTyConRhs, -- ^ Contains information about the expansion of the synonym
193 synTcParent :: TyConParent -- ^ Gives the family declaration 'TyCon' of 'TyCon's representing family instances
197 -- | Primitive types; cannot be defined in Haskell. This includes the usual suspects (such as @Int#@)
198 -- as well as foreign-imported types and kinds
200 tyConUnique :: Unique,
203 tyConArity :: Arity, -- SLPJ Oct06: I'm not sure what the significance
204 -- of the arity of a primtycon is!
206 primTyConRep :: PrimRep,
207 -- ^ Many primitive tycons are unboxed, but some are
208 -- boxed (represented by pointers). This 'PrimRep' holds
211 isUnLifted :: Bool, -- ^ Most primitive tycons are unlifted (may not contain bottom)
212 -- but foreign-imported ones may be lifted
213 tyConExtName :: Maybe FastString -- ^ @Just e@ for foreign-imported types, holds the name of the imported thing
216 -- | Type coercions, such as @(~)@, @sym@, @trans@, @left@ and @right@.
217 -- INVARIANT: coercions are always fully applied
219 tyConUnique :: Unique,
222 coKindFun :: [Type] -> (Type,Type)
223 -- ^ Function that when given a list of the type arguments to the 'TyCon'
224 -- constructs the types that the resulting coercion relates.
226 -- INVARIANT: 'coKindFun' is always applied to exactly 'tyConArity' args
227 -- E.g. for @trans (c1 :: ta=tb) (c2 :: tb=tc)@, the 'coKindFun' returns
228 -- the kind as a pair of types: @(ta, tc)@
231 -- | Super-kinds. These are "kinds-of-kinds" and are never seen in Haskell source programs.
232 -- There are only two super-kinds: TY (aka "box"), which is the super-kind of kinds that
233 -- construct types eventually, and CO (aka "diamond"), which is the super-kind of kinds
234 -- that just represent coercions.
236 -- Super-kinds have no kind themselves, and have arity zero
238 tyConUnique :: Unique,
242 -- | Names of the fields in an algebraic record type
243 type FieldLabel = Name
245 -- | Represents right-hand-sides of 'TyCon's for algebraic types
248 -- | Says that we know nothing about this data type, except that it's represented
249 -- by a pointer. Used when we export a data type abstractly into an .hi file.
252 -- | Represents an open type family without a fixed right hand
253 -- side. Additional instances can appear at any time.
255 -- These are introduced by either a top level declaration:
259 -- Or an assoicated data type declaration, within a class declaration:
261 -- > class C a b where
265 otArgPoss :: AssocFamilyPermutation
268 -- | Information about those 'TyCon's derived from a @data@ declaration. This includes
269 -- data types with no constructors at all.
271 data_cons :: [DataCon],
272 -- ^ The data type constructors; can be empty if the user declares
273 -- the type to have no constructors
275 -- INVARIANT: Kept in order of increasing 'DataCon' tag
277 -- (see the tag assignment in DataCon.mkDataCon)
278 is_enum :: Bool -- ^ Cached value: is this an enumeration type? (See 'isEnumerationTyCon')
281 -- | Information about those 'TyCon's derived from a @newtype@ declaration
283 data_con :: DataCon, -- ^ The unique constructor for the @newtype@. It has no existentials
285 nt_rhs :: Type, -- ^ Cached value: the argument type of the constructor, which
286 -- is just the representation type of the 'TyCon' (remember that
287 -- @newtype@s do not exist at runtime so need a different representation
290 -- The free 'TyVar's of this type are the 'tyConTyVars' from the corresponding
293 nt_etad_rhs :: ([TyVar], Type),
294 -- ^ Same as the 'nt_rhs', but this time eta-reduced. Hence the list of 'TyVar's in
295 -- this field may be shorter than the declared arity of the 'TyCon'.
297 -- See Note [Newtype eta]
299 nt_co :: Maybe TyCon -- ^ A 'TyCon' (which is always a 'CoercionTyCon') that can have a 'Coercion'
300 -- extracted from it to create the @newtype@ from the representation 'Type'.
302 -- This field is optional for non-recursive @newtype@s only.
304 -- See Note [Newtype coercions]
305 -- Invariant: arity = #tvs in nt_etad_rhs;
306 -- See Note [Newtype eta]
307 -- Watch out! If any newtypes become transparent
308 -- again check Trac #1072.
311 type AssocFamilyPermutation
312 = Maybe [Int] -- Nothing for *top-level* type families
313 -- For *associated* type families, gives the position
314 -- of that 'TyVar' in the class argument list (0-indexed)
315 -- e.g. class C a b c where { type F c a :: *->* }
316 -- Then we get Just [2,0]
317 -- For *synonyms*, the length of the list is identical to
319 -- For *data types*, the length may be smaller than the
320 -- TyCon's arity; e.g. class C a where { data D a :: *->* }
321 -- here D gets arity 2
323 -- | Extract those 'DataCon's that we are able to learn about. Note that visibility in this sense does not
324 -- correspond to visibility in the context of any particular user program!
325 visibleDataCons :: AlgTyConRhs -> [DataCon]
326 visibleDataCons AbstractTyCon = []
327 visibleDataCons OpenTyCon {} = []
328 visibleDataCons (DataTyCon{ data_cons = cs }) = cs
329 visibleDataCons (NewTyCon{ data_con = c }) = [c]
331 -- ^ Both type classes as well as family instances imply implicit
332 -- type constructors. These implicit type constructors refer to their parent
333 -- structure (ie, the class or family from which they derive) using a type of
334 -- the following form. We use 'TyConParent' for both algebraic and synonym
335 -- types, but the variant 'ClassTyCon' will only be used by algebraic 'TyCon's.
337 = -- | An ordinary type constructor has no parent.
340 -- | Type constructors representing a class dictionary.
342 Class -- INVARIANT: the classTyCon of this Class is the current tycon
344 -- | Type constructors representing an instance of a type family. Parameters:
346 -- 1) The type family in question
348 -- 2) Instance types; free variables are the 'tyConTyVars'
349 -- of the current 'TyCon' (not the family one). INVARIANT:
350 -- the number of types matches the arity of the family 'TyCon'
352 -- 3) A 'CoercionTyCon' identifying the representation
353 -- type with the type instance family
357 TyCon -- c.f. Note [Newtype coercions]
360 -- E.g. data intance T [a] = ...
361 -- gives a representation tycon:
363 -- axiom co a :: T [a] ~ :R7T a
364 -- with :R7T's algTcParent = FamilyTyCon T [a] co
366 -- | Checks the invariants of a 'TyConParent' given the appropriate type class name, if any
367 okParent :: Name -> TyConParent -> Bool
368 okParent _ NoParentTyCon = True
369 okParent tc_name (ClassTyCon cls) = tyConName (classTyCon cls) == tc_name
370 okParent _ (FamilyTyCon fam_tc tys _co_tc) = tyConArity fam_tc == length tys
374 -- | Information pertaining to the expansion of a type synonym (@type@)
376 = OpenSynTyCon -- e.g. type family F x y :: * -> *
377 Kind -- Kind of the "rhs"; ie *excluding type indices*
378 -- In the example, the kind is (*->*)
379 AssocFamilyPermutation
381 | SynonymTyCon Type -- ^ The synonym mentions head type variables. It acts as a
382 -- template for the expansion when the 'TyCon' is applied to some
386 Note [Newtype coercions]
387 ~~~~~~~~~~~~~~~~~~~~~~~~
388 The NewTyCon field nt_co is a a TyCon (a coercion constructor in fact)
389 which is used for coercing from the representation type of the
390 newtype, to the newtype itself. For example,
392 newtype T a = MkT (a -> a)
394 the NewTyCon for T will contain nt_co = CoT where CoT t : T t ~ t ->
395 t. This TyCon is a CoercionTyCon, so it does not have a kind on its
396 own; it basically has its own typing rule for the fully-applied
397 version. If the newtype T has k type variables then CoT has arity at
398 most k. In the case that the right hand side is a type application
399 ending with the same type variables as the left hand side, we
400 "eta-contract" the coercion. So if we had
402 newtype S a = MkT [a]
404 then we would generate the arity 0 coercion CoS : S ~ []. The
405 primary reason we do this is to make newtype deriving cleaner.
407 In the paper we'd write
408 axiom CoT : (forall t. T t) ~ (forall t. [t])
409 and then when we used CoT at a particular type, s, we'd say
411 which encodes as (TyConApp instCoercionTyCon [TyConApp CoT [], s])
413 But in GHC we instead make CoT into a new piece of type syntax, CoercionTyCon,
414 (like instCoercionTyCon, symCoercionTyCon etc), which must always
415 be saturated, but which encodes as
417 In the vocabulary of the paper it's as if we had axiom declarations
419 axiom CoT t : T t ~ [t]
424 newtype Parser m a = MkParser (Foogle m a)
425 Are these two types equal (to Core)?
428 Well, yes. But to see that easily we eta-reduce the RHS type of
429 Parser, in this case to ([], Froogle), so that even unsaturated applications
430 of Parser will work right. This eta reduction is done when the type
431 constructor is built, and cached in NewTyCon. The cached field is
432 only used in coreExpandTyCon_maybe.
434 Here's an example that I think showed up in practice
436 newtype T a = MkT [a]
437 newtype Foo m = MkFoo (forall a. m a -> Int)
443 w2 = MkFoo (\(MkT x) -> case w1 of MkFoo f -> f x)
445 After desugaring, and discarding the data constructors for the newtypes,
449 And now Lint complains unless Foo T == Foo [], and that requires T==[]
451 This point carries over to the newtype coercion, because we need to
453 w2 = w1 `cast` Foo CoT
455 so the coercion tycon CoT must have
460 Note [Indexed data types] (aka data type families)
461 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
462 See also Note [Wrappers for data instance tycons] in MkId.lhs
467 data instance T (b,c) where
468 T1 :: b -> c -> T (b,c)
471 * T is the "family TyCon"
473 * We make "representation TyCon" :R1T, thus:
475 T1 :: forall b c. b -> c -> :R1T b c
477 * It has a top-level coercion connecting it to the family TyCon
479 axiom :Co:R1T b c : T (b,c) ~ :R1T b c
481 * The data contructor T1 has a wrapper (which is what the source-level
484 $WT1 :: forall b c. b -> c -> T (b,c)
485 $WT1 b c (x::b) (y::c) = T1 b c x y `cast` sym (:Co:R1T b c)
487 * The representation TyCon :R1T has an AlgTyConParent of
489 FamilyTyCon T [(b,c)] :Co:R1T
493 %************************************************************************
497 %************************************************************************
499 A PrimRep is somewhat similar to a CgRep (see codeGen/SMRep) and a
500 MachRep (see cmm/MachOp), although each of these types has a distinct
501 and clearly defined purpose:
503 - A PrimRep is a CgRep + information about signedness + information
504 about primitive pointers (AddrRep). Signedness and primitive
505 pointers are required when passing a primitive type to a foreign
506 function, but aren't needed for call/return conventions of Haskell
509 - A MachRep is a basic machine type (non-void, doesn't contain
510 information on pointerhood or signedness, but contains some
511 reps that don't have corresponding Haskell types).
514 -- | A 'PrimRep' is an abstraction of a type. It contains information that
515 -- the code generator needs in order to pass arguments, return results,
516 -- and store values of this type.
520 | IntRep -- ^ Signed, word-sized value
521 | WordRep -- ^ Unsigned, word-sized value
522 | Int64Rep -- ^ Signed, 64 bit value (with 32-bit words only)
523 | Word64Rep -- ^ Unsigned, 64 bit value (with 32-bit words only)
524 | AddrRep -- ^ A pointer, but /not/ to a Haskell value (use 'PtrRep')
529 instance Outputable PrimRep where
530 ppr r = text (show r)
532 -- | Find the size of a 'PrimRep', in words
533 primRepSizeW :: PrimRep -> Int
534 primRepSizeW IntRep = 1
535 primRepSizeW WordRep = 1
536 primRepSizeW Int64Rep = wORD64_SIZE `quot` wORD_SIZE
537 primRepSizeW Word64Rep= wORD64_SIZE `quot` wORD_SIZE
538 primRepSizeW FloatRep = 1 -- NB. might not take a full word
539 primRepSizeW DoubleRep= dOUBLE_SIZE `quot` wORD_SIZE
540 primRepSizeW AddrRep = 1
541 primRepSizeW PtrRep = 1
542 primRepSizeW VoidRep = 0
545 %************************************************************************
547 \subsection{TyCon Construction}
549 %************************************************************************
551 Note: the TyCon constructors all take a Kind as one argument, even though
552 they could, in principle, work out their Kind from their other arguments.
553 But to do so they need functions from Types, and that makes a nasty
554 module mutual-recursion. And they aren't called from many places.
555 So we compromise, and move their Kind calculation to the call site.
558 -- | Given the name of the function type constructor and it's kind, create the
559 -- corresponding 'TyCon'. It is reccomended to use 'TypeRep.funTyCon' if you want
560 -- this functionality
561 mkFunTyCon :: Name -> Kind -> TyCon
564 tyConUnique = nameUnique name,
570 -- | This is the making of an algebraic 'TyCon'. Notably, you have to pass in the generic (in the -XGenerics sense)
571 -- information about the type constructor - you can get hold of it easily (see Generics module)
573 -> Kind -- ^ Kind of the resulting 'TyCon'
574 -> [TyVar] -- ^ 'TyVar's scoped over: see 'tyConTyVars'. Arity is inferred from the length of this list
575 -> [PredType] -- ^ Stupid theta: see 'algTcStupidTheta'
576 -> AlgTyConRhs -- ^ Information about dat aconstructors
577 -> [Id] -- ^ Selector 'Id's
579 -> RecFlag -- ^ Is the 'TyCon' recursive?
580 -> Bool -- ^ Does it have generic functions? See 'hasGenerics'
581 -> Bool -- ^ Was the 'TyCon' declared with GADT syntax?
583 mkAlgTyCon name kind tyvars stupid rhs sel_ids parent is_rec gen_info gadt_syn
586 tyConUnique = nameUnique name,
588 tyConArity = length tyvars,
589 tyConTyVars = tyvars,
590 algTcStupidTheta = stupid,
592 algTcSelIds = sel_ids,
593 algTcParent = ASSERT( okParent name parent ) parent,
595 algTcGadtSyntax = gadt_syn,
596 hasGenerics = gen_info
599 -- | Simpler specialization of 'mkAlgTyCon' for classes
600 mkClassTyCon :: Name -> Kind -> [TyVar] -> AlgTyConRhs -> Class -> RecFlag -> TyCon
601 mkClassTyCon name kind tyvars rhs clas is_rec =
602 mkAlgTyCon name kind tyvars [] rhs [] (ClassTyCon clas) is_rec False False
605 -> Kind -- ^ Kind of the resulting 'TyCon'
606 -> Arity -- ^ Arity of the tuple
607 -> [TyVar] -- ^ 'TyVar's scoped over: see 'tyConTyVars'
609 -> Boxity -- ^ Whether the tuple is boxed or unboxed
610 -> Bool -- ^ Does it have generic functions? See 'hasGenerics'
612 mkTupleTyCon name kind arity tyvars con boxed gen_info
614 tyConUnique = nameUnique name,
619 tyConTyVars = tyvars,
621 hasGenerics = gen_info
624 -- ^ Foreign-imported (.NET) type constructors are represented
625 -- as primitive, but /lifted/, 'TyCons' for now. They are lifted
626 -- because the Haskell type @T@ representing the (foreign) .NET
627 -- type @T@ is actually implemented (in ILX) as a @thunk<T>@
628 mkForeignTyCon :: Name
629 -> Maybe FastString -- ^ Name of the foreign imported thing, maybe
633 mkForeignTyCon name ext_name kind arity
636 tyConUnique = nameUnique name,
639 primTyConRep = PtrRep, -- they all do
641 tyConExtName = ext_name
645 -- | Create an unlifted primitive 'TyCon', such as @Int#@
646 mkPrimTyCon :: Name -> Kind -> Arity -> PrimRep -> TyCon
647 mkPrimTyCon name kind arity rep
648 = mkPrimTyCon' name kind arity rep True
650 -- | Create the special void 'TyCon' which is unlifted and has 'VoidRep'
651 mkVoidPrimTyCon :: Name -> Kind -> Arity -> TyCon
652 mkVoidPrimTyCon name kind arity
653 = mkPrimTyCon' name kind arity VoidRep True
655 -- | Create a lifted primitive 'TyCon' such as @RealWorld@
656 mkLiftedPrimTyCon :: Name -> Kind -> Arity -> PrimRep -> TyCon
657 mkLiftedPrimTyCon name kind arity rep
658 = mkPrimTyCon' name kind arity rep False
660 mkPrimTyCon' :: Name -> Kind -> Arity -> PrimRep -> Bool -> TyCon
661 mkPrimTyCon' name kind arity rep is_unlifted
664 tyConUnique = nameUnique name,
668 isUnLifted = is_unlifted,
669 tyConExtName = Nothing
672 -- | Create a type synonym 'TyCon'
673 mkSynTyCon :: Name -> Kind -> [TyVar] -> SynTyConRhs -> TyConParent -> TyCon
674 mkSynTyCon name kind tyvars rhs parent
677 tyConUnique = nameUnique name,
679 tyConArity = length tyvars,
680 tyConTyVars = tyvars,
685 -- | Create a coercion 'TyCon'
686 mkCoercionTyCon :: Name -> Arity -> ([Type] -> (Type,Type)) -> TyCon
687 mkCoercionTyCon name arity kindRule
690 tyConUnique = nameUnique name,
695 -- | Create a super-kind 'TyCon'
696 mkSuperKindTyCon :: Name -> TyCon -- Super kinds always have arity zero
697 mkSuperKindTyCon name
700 tyConUnique = nameUnique name
705 isFunTyCon :: TyCon -> Bool
706 isFunTyCon (FunTyCon {}) = True
709 -- | Test if the 'TyCon' is algebraic but abstract (invisible data constructors)
710 isAbstractTyCon :: TyCon -> Bool
711 isAbstractTyCon (AlgTyCon { algTcRhs = AbstractTyCon }) = True
712 isAbstractTyCon _ = False
714 -- | Make an algebraic 'TyCon' abstract. Panics if the supplied 'TyCon' is not algebraic
715 makeTyConAbstract :: TyCon -> TyCon
716 makeTyConAbstract tc@(AlgTyCon {}) = tc { algTcRhs = AbstractTyCon }
717 makeTyConAbstract tc = pprPanic "makeTyConAbstract" (ppr tc)
719 -- | Does this 'TyCon' represent something that cannot be defined in Haskell?
720 isPrimTyCon :: TyCon -> Bool
721 isPrimTyCon (PrimTyCon {}) = True
722 isPrimTyCon _ = False
724 -- | Is this 'TyCon' unlifted (i.e. cannot contain bottom)? Note that this can only
725 -- be true for primitive and unboxed-tuple 'TyCon's
726 isUnLiftedTyCon :: TyCon -> Bool
727 isUnLiftedTyCon (PrimTyCon {isUnLifted = is_unlifted}) = is_unlifted
728 isUnLiftedTyCon (TupleTyCon {tyConBoxed = boxity}) = not (isBoxed boxity)
729 isUnLiftedTyCon _ = False
731 -- | Returns @True@ if the supplied 'TyCon' resulted from either a @data@ or @newtype@ declaration
732 isAlgTyCon :: TyCon -> Bool
733 isAlgTyCon (AlgTyCon {}) = True
734 isAlgTyCon (TupleTyCon {}) = True
737 isDataTyCon :: TyCon -> Bool
738 -- ^ Returns @True@ for data types that are /definitely/ represented by
739 -- heap-allocated constructors. These are scrutinised by Core-level
740 -- @case@ expressions, and they get info tables allocated for them.
742 -- Generally, the function will be true for all @data@ types and false
743 -- for @newtype@s, unboxed tuples and type family 'TyCon's. But it is
744 -- not guarenteed to return @True@ in all cases that it could.
746 -- NB: for a data type family, only the /instance/ 'TyCon's
747 -- get an info table. The family declaration 'TyCon' does not
748 isDataTyCon (AlgTyCon {algTcRhs = rhs})
750 OpenTyCon {} -> False
753 AbstractTyCon -> False -- We don't know, so return False
754 isDataTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity
755 isDataTyCon _ = False
757 -- | Is this 'TyCon' that for a @newtype@
758 isNewTyCon :: TyCon -> Bool
759 isNewTyCon (AlgTyCon {algTcRhs = NewTyCon {}}) = True
762 -- | Take a 'TyCon' apart into the 'TyVar's it scopes over, the 'Type' it expands
763 -- into, and (possibly) a coercion from the representation type to the @newtype@.
764 -- Returns @Nothing@ if this is not possible.
765 unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, Maybe TyCon)
766 unwrapNewTyCon_maybe (AlgTyCon { tyConTyVars = tvs,
767 algTcRhs = NewTyCon { nt_co = mb_co,
769 = Just (tvs, rhs, mb_co)
770 unwrapNewTyCon_maybe _ = Nothing
772 isProductTyCon :: TyCon -> Bool
773 -- | A /product/ 'TyCon' must both:
775 -- 1. Have /one/ constructor
777 -- 2. /Not/ be existential
779 -- However other than this there are few restrictions: they may be @data@ or @newtype@
780 -- 'TyCon's of any boxity and may even be recursive.
781 isProductTyCon tc@(AlgTyCon {}) = case algTcRhs tc of
782 DataTyCon{ data_cons = [data_con] }
783 -> isVanillaDataCon data_con
786 isProductTyCon (TupleTyCon {}) = True
787 isProductTyCon _ = False
789 -- | Is this a 'TyCon' representing a type synonym (@type@)?
790 isSynTyCon :: TyCon -> Bool
791 isSynTyCon (SynTyCon {}) = True
794 -- As for newtypes, it is in some contexts important to distinguish between
795 -- closed synonyms and synonym families, as synonym families have no unique
796 -- right hand side to which a synonym family application can expand.
799 -- | Is this a synonym 'TyCon' that can have no further instances appear?
800 isClosedSynTyCon :: TyCon -> Bool
801 isClosedSynTyCon tycon = isSynTyCon tycon && not (isOpenTyCon tycon)
803 -- | Is this a synonym 'TyCon' that can have may have further instances appear?
804 isOpenSynTyCon :: TyCon -> Bool
805 isOpenSynTyCon tycon = isSynTyCon tycon && isOpenTyCon tycon
807 -- | Is this an algebraic 'TyCon' declared with the GADT syntax?
808 isGadtSyntaxTyCon :: TyCon -> Bool
809 isGadtSyntaxTyCon (AlgTyCon { algTcGadtSyntax = res }) = res
810 isGadtSyntaxTyCon _ = False
812 -- | Is this an algebraic 'TyCon' which is just an enumeration of values?
813 isEnumerationTyCon :: TyCon -> Bool
814 isEnumerationTyCon (AlgTyCon {algTcRhs = DataTyCon { is_enum = res }}) = res
815 isEnumerationTyCon _ = False
817 -- | Is this a 'TyCon', synonym or otherwise, that may have further instances appear?
818 isOpenTyCon :: TyCon -> Bool
819 isOpenTyCon (SynTyCon {synTcRhs = OpenSynTyCon _ _}) = True
820 isOpenTyCon (AlgTyCon {algTcRhs = OpenTyCon {} }) = True
821 isOpenTyCon _ = False
823 -- | Extract the mapping from 'TyVar' indexes to indexes in the corresponding family
824 -- argument lists form an open 'TyCon' of any sort, if the given 'TyCon' is indeed
825 -- such a beast and that information is available
826 assocTyConArgPoss_maybe :: TyCon -> Maybe [Int]
827 assocTyConArgPoss_maybe (AlgTyCon {
828 algTcRhs = OpenTyCon {otArgPoss = poss}}) = poss
829 assocTyConArgPoss_maybe (SynTyCon { synTcRhs = OpenSynTyCon _ poss }) = poss
830 assocTyConArgPoss_maybe _ = Nothing
832 -- | Are we able to extract informationa 'TyVar' to class argument list
833 -- mappping from a given 'TyCon'?
834 isTyConAssoc :: TyCon -> Bool
835 isTyConAssoc = isJust . assocTyConArgPoss_maybe
837 -- | Set the AssocFamilyPermutation structure in an
838 -- associated data or type synonym. The [TyVar] are the
839 -- class type variables. Remember, the tyvars of an associated
840 -- data/type are a subset of the class tyvars; except that an
841 -- associated data type can have extra type variables at the
842 -- end (see Note [Avoid name clashes for associated data types] in TcHsType)
843 setTyConArgPoss :: [TyVar] -> TyCon -> TyCon
844 setTyConArgPoss clas_tvs tc
846 AlgTyCon { algTcRhs = rhs } -> tc { algTcRhs = rhs {otArgPoss = Just ps} }
847 SynTyCon { synTcRhs = OpenSynTyCon ki _ } -> tc { synTcRhs = OpenSynTyCon ki (Just ps) }
848 _ -> pprPanic "setTyConArgPoss" (ppr tc)
850 ps = catMaybes [tv `elemIndex` clas_tvs | tv <- tyConTyVars tc]
851 -- We will get Nothings for the "extra" type variables in an
852 -- associated data type
854 -- The unit tycon didn't used to be classed as a tuple tycon
855 -- but I thought that was silly so I've undone it
856 -- If it can't be for some reason, it should be a AlgTyCon
857 isTupleTyCon :: TyCon -> Bool
858 -- ^ Does this 'TyCon' represent a tuple?
860 -- NB: when compiling @Data.Tuple@, the tycons won't reply @True@ to
861 -- 'isTupleTyCon', becuase they are built as 'AlgTyCons'. However they
862 -- get spat into the interface file as tuple tycons, so I don't think
864 isTupleTyCon (TupleTyCon {}) = True
865 isTupleTyCon _ = False
867 -- | Is this the 'TyCon' for an unboxed tuple?
868 isUnboxedTupleTyCon :: TyCon -> Bool
869 isUnboxedTupleTyCon (TupleTyCon {tyConBoxed = boxity}) = not (isBoxed boxity)
870 isUnboxedTupleTyCon _ = False
872 -- | Is this the 'TyCon' for a boxed tuple?
873 isBoxedTupleTyCon :: TyCon -> Bool
874 isBoxedTupleTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity
875 isBoxedTupleTyCon _ = False
877 -- | Extract the boxity of the given 'TyCon', if it is a 'TupleTyCon'.
879 tupleTyConBoxity :: TyCon -> Boxity
880 tupleTyConBoxity tc = tyConBoxed tc
882 -- | Is this a recursive 'TyCon'?
883 isRecursiveTyCon :: TyCon -> Bool
884 isRecursiveTyCon (AlgTyCon {algTcRec = Recursive}) = True
885 isRecursiveTyCon _ = False
887 -- | Did this 'TyCon' originate from type-checking a .h*-boot file?
888 isHiBootTyCon :: TyCon -> Bool
889 -- Used for knot-tying in hi-boot files
890 isHiBootTyCon (AlgTyCon {algTcRhs = AbstractTyCon}) = True
891 isHiBootTyCon _ = False
893 -- | Is this the 'TyCon' of a foreign-imported type constructor?
894 isForeignTyCon :: TyCon -> Bool
895 isForeignTyCon (PrimTyCon {tyConExtName = Just _}) = True
896 isForeignTyCon _ = False
898 -- | Is this a super-kind 'TyCon'?
899 isSuperKindTyCon :: TyCon -> Bool
900 isSuperKindTyCon (SuperKindTyCon {}) = True
901 isSuperKindTyCon _ = False
903 -- | Attempt to pull a 'TyCon' apart into the arity and 'coKindFun' of
904 -- a coercion 'TyCon'. Returns @Nothing@ if the 'TyCon' is not of the
906 isCoercionTyCon_maybe :: TyCon -> Maybe (Arity, [Type] -> (Type,Type))
907 isCoercionTyCon_maybe (CoercionTyCon {tyConArity = ar, coKindFun = rule})
909 isCoercionTyCon_maybe _ = Nothing
911 -- | Is this a 'TyCon' that represents a coercion?
912 isCoercionTyCon :: TyCon -> Bool
913 isCoercionTyCon (CoercionTyCon {}) = True
914 isCoercionTyCon _ = False
916 -- | Identifies implicit tycons that, in particular, do not go into interface
917 -- files (because they are implicitly reconstructed when the interface is
922 -- * Associated families are implicit, as they are re-constructed from
923 -- the class declaration in which they reside, and
925 -- * Family instances are /not/ implicit as they represent the instance body
926 -- (similar to a @dfun@ does that for a class instance).
927 isImplicitTyCon :: TyCon -> Bool
928 isImplicitTyCon tycon | isTyConAssoc tycon = True
929 | isSynTyCon tycon = False
930 | isAlgTyCon tycon = isClassTyCon tycon ||
932 isImplicitTyCon _other = True
933 -- catches: FunTyCon, PrimTyCon,
934 -- CoercionTyCon, SuperKindTyCon
938 -----------------------------------------------
939 -- Expand type-constructor applications
940 -----------------------------------------------
943 tcExpandTyCon_maybe, coreExpandTyCon_maybe
945 -> [Type] -- ^ Arguments to 'TyCon'
946 -> Maybe ([(TyVar,Type)],
948 [Type]) -- ^ Returns a 'TyVar' substitution, the body type
949 -- of the synonym (not yet substituted) and any arguments
950 -- remaining from the application
952 -- ^ Used to create the view the /typechecker/ has on 'TyCon's. We expand (closed) synonyms only, cf. 'coreExpandTyCon_maybe'
953 tcExpandTyCon_maybe (SynTyCon {tyConTyVars = tvs,
954 synTcRhs = SynonymTyCon rhs }) tys
956 tcExpandTyCon_maybe _ _ = Nothing
960 -- ^ Used to create the view /Core/ has on 'TyCon's. We expand not only closed synonyms like 'tcExpandTyCon_maybe',
961 -- but also non-recursive @newtype@s
962 coreExpandTyCon_maybe (AlgTyCon {algTcRec = NonRecursive, -- Not recursive
963 algTcRhs = NewTyCon { nt_etad_rhs = etad_rhs, nt_co = Nothing }}) tys
964 = case etad_rhs of -- Don't do this in the pattern match, lest we accidentally
965 -- match the etad_rhs of a *recursive* newtype
966 (tvs,rhs) -> expand tvs rhs tys
968 coreExpandTyCon_maybe tycon tys = tcExpandTyCon_maybe tycon tys
972 expand :: [TyVar] -> Type -- Template
974 -> Maybe ([(TyVar,Type)], Type, [Type]) -- Expansion
976 = case n_tvs `compare` length tys of
977 LT -> Just (tvs `zip` tys, rhs, drop n_tvs tys)
978 EQ -> Just (tvs `zip` tys, rhs, [])
985 -- | Does this 'TyCon' have any generic to\/from functions available? See also 'hasGenerics'
986 tyConHasGenerics :: TyCon -> Bool
987 tyConHasGenerics (AlgTyCon {hasGenerics = hg}) = hg
988 tyConHasGenerics (TupleTyCon {hasGenerics = hg}) = hg
989 tyConHasGenerics _ = False -- Synonyms
991 -- | As 'tyConDataCons_maybe', but returns the empty list of constructors if no constructors
993 tyConDataCons :: TyCon -> [DataCon]
994 -- It's convenient for tyConDataCons to return the
995 -- empty list for type synonyms etc
996 tyConDataCons tycon = tyConDataCons_maybe tycon `orElse` []
998 -- | Determine the 'DataCon's originating from the given 'TyCon', if the 'TyCon' is the
999 -- sort that can have any constructors (note: this does not include abstract algebraic types)
1000 tyConDataCons_maybe :: TyCon -> Maybe [DataCon]
1001 tyConDataCons_maybe (AlgTyCon {algTcRhs = DataTyCon { data_cons = cons }}) = Just cons
1002 tyConDataCons_maybe (AlgTyCon {algTcRhs = NewTyCon { data_con = con }}) = Just [con]
1003 tyConDataCons_maybe (TupleTyCon {dataCon = con}) = Just [con]
1004 tyConDataCons_maybe _ = Nothing
1006 -- | Determine the number of value constructors a 'TyCon' has. Panics if the 'TyCon'
1007 -- is not algebraic or a tuple
1008 tyConFamilySize :: TyCon -> Int
1009 tyConFamilySize (AlgTyCon {algTcRhs = DataTyCon {data_cons = cons}}) =
1011 tyConFamilySize (AlgTyCon {algTcRhs = NewTyCon {}}) = 1
1012 tyConFamilySize (AlgTyCon {algTcRhs = OpenTyCon {}}) = 0
1013 tyConFamilySize (TupleTyCon {}) = 1
1014 tyConFamilySize other = pprPanic "tyConFamilySize:" (ppr other)
1016 -- | Extract the record selector 'Id's from an algebraic 'TyCon' and returns the empty list otherwise
1017 tyConSelIds :: TyCon -> [Id]
1018 tyConSelIds (AlgTyCon {algTcSelIds = fs}) = fs
1021 -- | Extract an 'AlgTyConRhs' with information about data constructors from an algebraic or tuple
1022 -- 'TyCon'. Panics for any other sort of 'TyCon'
1023 algTyConRhs :: TyCon -> AlgTyConRhs
1024 algTyConRhs (AlgTyCon {algTcRhs = rhs}) = rhs
1025 algTyConRhs (TupleTyCon {dataCon = con}) = DataTyCon { data_cons = [con], is_enum = False }
1026 algTyConRhs other = pprPanic "algTyConRhs" (ppr other)
1030 -- | Extract the bound type variables and type expansion of a type synonym 'TyCon'. Panics if the
1031 -- 'TyCon' is not a synonym
1032 newTyConRhs :: TyCon -> ([TyVar], Type)
1033 newTyConRhs (AlgTyCon {tyConTyVars = tvs, algTcRhs = NewTyCon { nt_rhs = rhs }}) = (tvs, rhs)
1034 newTyConRhs tycon = pprPanic "newTyConRhs" (ppr tycon)
1036 -- | Extract the bound type variables and type expansion of an eta-contracted type synonym 'TyCon'.
1037 -- Panics if the 'TyCon' is not a synonym
1038 newTyConEtadRhs :: TyCon -> ([TyVar], Type)
1039 newTyConEtadRhs (AlgTyCon {algTcRhs = NewTyCon { nt_etad_rhs = tvs_rhs }}) = tvs_rhs
1040 newTyConEtadRhs tycon = pprPanic "newTyConEtadRhs" (ppr tycon)
1042 -- | Extracts the @newtype@ coercion from such a 'TyCon', which can be used to construct something
1043 -- with the @newtype@s type from its representation type (right hand side). If the supplied 'TyCon'
1044 -- is not a @newtype@, returns @Nothing@
1045 newTyConCo_maybe :: TyCon -> Maybe TyCon
1046 newTyConCo_maybe (AlgTyCon {algTcRhs = NewTyCon { nt_co = co }}) = co
1047 newTyConCo_maybe _ = Nothing
1049 -- | Find the primitive representation of a 'TyCon'
1050 tyConPrimRep :: TyCon -> PrimRep
1051 tyConPrimRep (PrimTyCon {primTyConRep = rep}) = rep
1052 tyConPrimRep tc = ASSERT(not (isUnboxedTupleTyCon tc)) PtrRep
1056 -- | Find the \"stupid theta\" of the 'TyCon'. A \"stupid theta\" is the context to the left of
1057 -- an algebraic type declaration, e.g. @Eq a@ in the declaration @data Eq a => T a ...@
1058 tyConStupidTheta :: TyCon -> [PredType]
1059 tyConStupidTheta (AlgTyCon {algTcStupidTheta = stupid}) = stupid
1060 tyConStupidTheta (TupleTyCon {}) = []
1061 tyConStupidTheta tycon = pprPanic "tyConStupidTheta" (ppr tycon)
1065 -- | Extract the 'TyVar's bound by a type synonym and the corresponding (unsubstituted) right hand side.
1066 -- If the given 'TyCon' is not a type synonym, panics
1067 synTyConDefn :: TyCon -> ([TyVar], Type)
1068 synTyConDefn (SynTyCon {tyConTyVars = tyvars, synTcRhs = SynonymTyCon ty})
1070 synTyConDefn tycon = pprPanic "getSynTyConDefn" (ppr tycon)
1072 -- | Extract the information pertaining to the right hand side of a type synonym (@type@) declaration. Panics
1073 -- if the given 'TyCon' is not a type synonym
1074 synTyConRhs :: TyCon -> SynTyConRhs
1075 synTyConRhs (SynTyCon {synTcRhs = rhs}) = rhs
1076 synTyConRhs tc = pprPanic "synTyConRhs" (ppr tc)
1078 -- | Find the expansion of the type synonym represented by the given 'TyCon'. The free variables of this
1079 -- type will typically include those 'TyVar's bound by the 'TyCon'. Panics if the 'TyCon' is not that of
1081 synTyConType :: TyCon -> Type
1082 synTyConType tc = case synTcRhs tc of
1084 _ -> pprPanic "synTyConType" (ppr tc)
1086 -- | Find the 'Kind' of an open type synonym. Panics if the 'TyCon' is not an open type synonym
1087 synTyConResKind :: TyCon -> Kind
1088 synTyConResKind (SynTyCon {synTcRhs = OpenSynTyCon kind _}) = kind
1089 synTyConResKind tycon = pprPanic "synTyConResKind" (ppr tycon)
1093 -- | If the given 'TyCon' has a /single/ data constructor, i.e. it is a @data@ type with one
1094 -- alternative, a tuple type or a @newtype@ then that constructor is returned. If the 'TyCon'
1095 -- has more than one constructor, or represents a primitive or function type constructor then
1096 -- @Nothing@ is returned. In any other case, the function panics
1097 tyConSingleDataCon_maybe :: TyCon -> Maybe DataCon
1098 tyConSingleDataCon_maybe (AlgTyCon {algTcRhs = DataTyCon {data_cons = [c] }}) = Just c
1099 tyConSingleDataCon_maybe (AlgTyCon {algTcRhs = NewTyCon { data_con = c }}) = Just c
1100 tyConSingleDataCon_maybe (AlgTyCon {}) = Nothing
1101 tyConSingleDataCon_maybe (TupleTyCon {dataCon = con}) = Just con
1102 tyConSingleDataCon_maybe (PrimTyCon {}) = Nothing
1103 tyConSingleDataCon_maybe (FunTyCon {}) = Nothing -- case at funty
1104 tyConSingleDataCon_maybe tc = pprPanic "tyConSingleDataCon_maybe: unexpected tycon " $ ppr tc
1108 -- | Is this 'TyCon' that for a class instance?
1109 isClassTyCon :: TyCon -> Bool
1110 isClassTyCon (AlgTyCon {algTcParent = ClassTyCon _}) = True
1111 isClassTyCon _ = False
1113 -- | If this 'TyCon' is that for a class instance, return the class it is for.
1114 -- Otherwise returns @Nothing@
1115 tyConClass_maybe :: TyCon -> Maybe Class
1116 tyConClass_maybe (AlgTyCon {algTcParent = ClassTyCon clas}) = Just clas
1117 tyConClass_maybe _ = Nothing
1119 -- | Is this 'TyCon' that for a family instance, be that for a synonym or an
1120 -- algebraic family instance?
1121 isFamInstTyCon :: TyCon -> Bool
1122 isFamInstTyCon (AlgTyCon {algTcParent = FamilyTyCon _ _ _ }) = True
1123 isFamInstTyCon (SynTyCon {synTcParent = FamilyTyCon _ _ _ }) = True
1124 isFamInstTyCon _ = False
1126 -- | If this 'TyCon' is that of a family instance, return the family in question
1127 -- and the instance types. Otherwise, return @Nothing@
1128 tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])
1129 tyConFamInst_maybe (AlgTyCon {algTcParent = FamilyTyCon fam instTys _}) =
1131 tyConFamInst_maybe (SynTyCon {synTcParent = FamilyTyCon fam instTys _}) =
1133 tyConFamInst_maybe _ =
1136 -- | If this 'TyCon' is that of a family instance, return a 'TyCon' which represents
1137 -- a coercion identifying the representation type with the type instance family.
1138 -- Otherwise, return @Nothing@
1139 tyConFamilyCoercion_maybe :: TyCon -> Maybe TyCon
1140 tyConFamilyCoercion_maybe (AlgTyCon {algTcParent = FamilyTyCon _ _ coe}) =
1142 tyConFamilyCoercion_maybe (SynTyCon {synTcParent = FamilyTyCon _ _ coe}) =
1144 tyConFamilyCoercion_maybe _ =
1149 %************************************************************************
1151 \subsection[TyCon-instances]{Instance declarations for @TyCon@}
1153 %************************************************************************
1155 @TyCon@s are compared by comparing their @Unique@s.
1157 The strictness analyser needs @Ord@. It is a lexicographic order with
1158 the property @(a<=b) || (b<=a)@.
1161 instance Eq TyCon where
1162 a == b = case (a `compare` b) of { EQ -> True; _ -> False }
1163 a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
1165 instance Ord TyCon where
1166 a <= b = case (a `compare` b) of { LT -> True; EQ -> True; GT -> False }
1167 a < b = case (a `compare` b) of { LT -> True; EQ -> False; GT -> False }
1168 a >= b = case (a `compare` b) of { LT -> False; EQ -> True; GT -> True }
1169 a > b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True }
1170 compare a b = getUnique a `compare` getUnique b
1172 instance Uniquable TyCon where
1173 getUnique tc = tyConUnique tc
1175 instance Outputable TyCon where
1176 ppr tc = ppr (getName tc)
1178 instance NamedThing TyCon where