2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[TyCon]{The @TyCon@ datatype}
8 TyCon, KindCon, SuperKindCon, ArgVrcs,
11 DataConDetails(..), visibleDataCons,
13 isFunTyCon, isUnLiftedTyCon, isBoxedTyCon, isProductTyCon,
14 isAlgTyCon, isDataTyCon, isSynTyCon, isNewTyCon, isPrimTyCon,
16 isTupleTyCon, isUnboxedTupleTyCon, isBoxedTupleTyCon, tupleTyConBoxity,
17 isRecursiveTyCon, newTyConRep,
19 mkForeignTyCon, isForeignTyCon,
38 tyConDataConDetails, tyConDataCons, tyConDataCons_maybe, tyConFamilySize,
43 isClassTyCon, tyConClass_maybe,
51 tyConGenIds, tyConGenInfo
54 #include "HsVersions.h"
56 import {-# SOURCE #-} TypeRep ( Type, PredType, Kind, SuperKind )
57 -- Should just be Type(Type), but this fails due to bug present up to
58 -- and including 4.02 involving slurping of hi-boot files. Bug is now fixed.
60 import {-# SOURCE #-} DataCon ( DataCon, isExistentialDataCon )
63 import Var ( TyVar, Id )
64 import Class ( Class )
65 import BasicTypes ( Arity, RecFlag(..), Boxity(..),
67 import Name ( Name, nameUnique, NamedThing(getName) )
68 import PrelNames ( Unique, Uniquable(..), anyBoxConKey )
69 import PrimRep ( PrimRep(..), isFollowableRep )
70 import Maybes ( expectJust )
75 %************************************************************************
77 \subsection{The data type}
79 %************************************************************************
83 type SuperKindCon = TyCon
87 tyConUnique :: Unique,
94 | AlgTyCon { -- Tuples, data type, and newtype decls.
95 -- All lifted, all boxed
96 tyConUnique :: Unique,
101 tyConTyVars :: [TyVar],
102 tyConArgVrcs :: ArgVrcs,
103 algTyConTheta :: [PredType],
105 dataCons :: DataConDetails DataCon,
107 selIds :: [Id], -- Its record selectors (if any)
109 algTyConFlavour :: AlgTyConFlavour,
110 algTyConRec :: RecFlag, -- Tells whether the data type is part of
111 -- a mutually-recursive group or not
113 genInfo :: Maybe (EP Id), -- Convert T <-> Tring
114 -- Some TyCons don't have it;
115 -- e.g. the TyCon for a Class dictionary,
116 -- and TyCons with unboxed arguments
118 algTyConClass :: Maybe Class
119 -- Just cl if this tycon came from a class declaration
122 | PrimTyCon { -- Primitive types; cannot be defined in Haskell
123 -- Now includes foreign-imported types
124 tyConUnique :: Unique,
128 tyConArgVrcs :: ArgVrcs,
129 primTyConRep :: PrimRep, -- Many primitive tycons are unboxed, but some are
130 -- boxed (represented by pointers). The PrimRep tells.
132 isUnLifted :: Bool, -- Most primitive tycons are unlifted,
133 -- but foreign-imported ones may not be
134 tyConExtName :: Maybe FastString
139 tyConUnique :: Unique,
143 tyConBoxed :: Boxity,
144 tyConTyVars :: [TyVar],
146 genInfo :: Maybe (EP Id) -- Generic type and conv funs
150 tyConUnique :: Unique,
155 tyConTyVars :: [TyVar], -- Bound tyvars
156 synTyConDefn :: Type, -- Right-hand side, mentioning these type vars.
157 -- Acts as a template for the expansion when
158 -- the tycon is applied to some types.
159 tyConArgVrcs :: ArgVrcs
162 | KindCon { -- Type constructor at the kind level
163 tyConUnique :: Unique,
165 tyConKind :: SuperKind,
169 | SuperKindCon { -- The type of kind variables or boxity variables,
170 tyConUnique :: Unique,
174 type ArgVrcs = [(Bool,Bool)] -- Tyvar variance info: [(occPos,occNeg)]
177 = DataTyCon -- Data type
179 | EnumTyCon -- Special sort of enumeration type
181 | NewTyCon Type -- Newtype, with its *ultimate* representation type
182 -- By 'ultimate' I mean that the rep type is not itself
183 -- a newtype or type synonym.
185 -- The rep type has free type variables the tyConTyVars
187 -- newtype T a = MkT [(a,Int)]
188 -- The rep type is [(a,Int)]
190 -- The rep type isn't entirely simple:
191 -- for a recursive newtype we pick () as the rep type
194 data DataConDetails datacon
195 = DataCons [datacon] -- Its data constructors, with fully polymorphic types
196 -- A type can have zero constructors
198 | Unknown -- We're importing this data type from an hi-boot file
199 -- and we don't know what its constructors are
201 | HasCons Int -- In a quest for compilation speed we have imported
202 -- only the number of constructors (to get return
203 -- conventions right) but not the constructors themselves
205 visibleDataCons (DataCons cs) = cs
206 visibleDataCons other = []
210 %************************************************************************
212 \subsection{TyCon Construction}
214 %************************************************************************
216 Note: the TyCon constructors all take a Kind as one argument, even though
217 they could, in principle, work out their Kind from their other arguments.
218 But to do so they need functions from Types, and that makes a nasty
219 module mutual-recursion. And they aren't called from many places.
220 So we compromise, and move their Kind calculation to the call site.
223 mkSuperKindCon :: Name -> SuperKindCon
224 mkSuperKindCon name = SuperKindCon {
225 tyConUnique = nameUnique name,
229 mkKindCon :: Name -> SuperKind -> KindCon
232 tyConUnique = nameUnique name,
238 mkFunTyCon :: Name -> Kind -> TyCon
241 tyConUnique = nameUnique name,
247 tyConGenInfo :: TyCon -> Maybe (EP Id)
248 tyConGenInfo (AlgTyCon { genInfo = info }) = info
249 tyConGenInfo (TupleTyCon { genInfo = info }) = info
250 tyConGenInfo other = Nothing
252 tyConGenIds :: TyCon -> [Id]
253 -- Returns the generic-programming Ids; these Ids need bindings
254 tyConGenIds tycon = case tyConGenInfo tycon of
256 Just (EP from to) -> [from,to]
258 -- This is the making of a TyCon. Just the same as the old mkAlgTyCon,
259 -- but now you also have to pass in the generic information about the type
260 -- constructor - you can get hold of it easily (see Generics module)
261 mkAlgTyCon name kind tyvars theta argvrcs cons sels flavour rec
265 tyConUnique = nameUnique name,
267 tyConArity = length tyvars,
268 tyConTyVars = tyvars,
269 tyConArgVrcs = argvrcs,
270 algTyConTheta = theta,
273 algTyConClass = Nothing,
274 algTyConFlavour = flavour,
279 mkClassTyCon name kind tyvars argvrcs con clas flavour rec
282 tyConUnique = nameUnique name,
284 tyConArity = length tyvars,
285 tyConTyVars = tyvars,
286 tyConArgVrcs = argvrcs,
288 dataCons = DataCons [con],
290 algTyConClass = Just clas,
291 algTyConFlavour = flavour,
297 mkTupleTyCon name kind arity tyvars con boxed gen_info
299 tyConUnique = nameUnique name,
304 tyConTyVars = tyvars,
309 -- Foreign-imported (.NET) type constructors are represented
310 -- as primitive, but *lifted*, TyCons for now. They are lifted
311 -- because the Haskell type T representing the (foreign) .NET
312 -- type T is actually implemented (in ILX) as a thunk<T>
314 mkForeignTyCon name ext_name kind arity arg_vrcs
317 tyConUnique = nameUnique name,
320 tyConArgVrcs = arg_vrcs,
321 primTyConRep = PtrRep,
323 tyConExtName = ext_name
327 -- most Prim tycons are lifted
328 mkPrimTyCon name kind arity arg_vrcs rep
329 = mkPrimTyCon' name kind arity arg_vrcs rep True
331 -- but RealWorld is lifted
332 mkLiftedPrimTyCon name kind arity arg_vrcs rep
333 = mkPrimTyCon' name kind arity arg_vrcs rep False
335 mkPrimTyCon' name kind arity arg_vrcs rep is_unlifted
338 tyConUnique = nameUnique name,
341 tyConArgVrcs = arg_vrcs,
343 isUnLifted = is_unlifted,
344 tyConExtName = Nothing
347 mkSynTyCon name kind arity tyvars rhs argvrcs
350 tyConUnique = nameUnique name,
353 tyConTyVars = tyvars,
355 tyConArgVrcs = argvrcs
358 setTyConName tc name = tc {tyConName = name, tyConUnique = nameUnique name}
363 isFunTyCon (FunTyCon {}) = True
366 isPrimTyCon (PrimTyCon {}) = True
367 isPrimTyCon _ = False
369 isUnLiftedTyCon (PrimTyCon {isUnLifted = is_unlifted}) = is_unlifted
370 isUnLiftedTyCon (TupleTyCon {tyConBoxed = boxity}) = not (isBoxed boxity)
371 isUnLiftedTyCon _ = False
373 -- isBoxedTyCon should not be applied to SynTyCon, nor KindCon
374 isBoxedTyCon (AlgTyCon {}) = True
375 isBoxedTyCon (FunTyCon {}) = True
376 isBoxedTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity
377 isBoxedTyCon (PrimTyCon {primTyConRep = rep}) = isFollowableRep rep
379 -- isAlgTyCon returns True for both @data@ and @newtype@
380 isAlgTyCon (AlgTyCon {}) = True
381 isAlgTyCon (TupleTyCon {}) = True
382 isAlgTyCon other = False
384 -- isDataTyCon returns True for data types that are represented by
385 -- heap-allocated constructors.
386 -- These are srcutinised by Core-level @case@ expressions, and they
387 -- get info tables allocated for them.
388 -- True for all @data@ types
389 -- False for newtypes
391 isDataTyCon (AlgTyCon {algTyConFlavour = new_or_data, algTyConRec = is_rec})
392 = case new_or_data of
396 isDataTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity
397 isDataTyCon other = False
399 isNewTyCon (AlgTyCon {algTyConFlavour = NewTyCon _}) = True
400 isNewTyCon other = False
402 newTyConRep :: TyCon -> ([TyVar], Type)
403 newTyConRep (AlgTyCon {tyConTyVars = tvs, algTyConFlavour = NewTyCon rep}) = (tvs, rep)
406 -- has *one* constructor,
407 -- is *not* existential
409 -- may be DataType or NewType,
410 -- may be unboxed or not,
411 -- may be recursive or not
412 isProductTyCon (AlgTyCon {dataCons = DataCons [data_con]}) = not (isExistentialDataCon data_con)
413 isProductTyCon (TupleTyCon {}) = True
414 isProductTyCon other = False
416 isSynTyCon (SynTyCon {}) = True
419 isEnumerationTyCon (AlgTyCon {algTyConFlavour = EnumTyCon}) = True
420 isEnumerationTyCon other = False
422 -- The unit tycon didn't used to be classed as a tuple tycon
423 -- but I thought that was silly so I've undone it
424 -- If it can't be for some reason, it should be a AlgTyCon
425 isTupleTyCon (TupleTyCon {}) = True
426 isTupleTyCon other = False
428 isUnboxedTupleTyCon (TupleTyCon {tyConBoxed = boxity}) = not (isBoxed boxity)
429 isUnboxedTupleTyCon other = False
431 isBoxedTupleTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity
432 isBoxedTupleTyCon other = False
434 tupleTyConBoxity tc = tyConBoxed tc
436 isRecursiveTyCon (AlgTyCon {algTyConRec = Recursive}) = True
437 isRecursiveTyCon other = False
439 -- isForeignTyCon identifies foreign-imported type constructors
440 -- For the moment, they are primitive but lifted, but that may change
441 isForeignTyCon (PrimTyCon {isUnLifted = is_unlifted}) = not is_unlifted
442 isForeignTyCon other = False
446 tyConDataConDetails :: TyCon -> DataConDetails DataCon
447 tyConDataConDetails (AlgTyCon {dataCons = cons}) = cons
448 tyConDataConDetails (TupleTyCon {dataCon = con}) = DataCons [con]
449 tyConDataConDetails other = Unknown
451 tyConDataCons :: TyCon -> [DataCon]
452 tyConDataCons tycon = expectJust "tyConDataCons" (tyConDataCons_maybe tycon)
454 tyConDataCons_maybe :: TyCon -> Maybe [DataCon]
455 tyConDataCons_maybe (AlgTyCon {dataCons = DataCons cons}) = Just cons
456 tyConDataCons_maybe (TupleTyCon {dataCon = con}) = Just [con]
457 tyConDataCons_maybe other = Nothing
459 tyConFamilySize :: TyCon -> Int
460 tyConFamilySize (AlgTyCon {dataCons = DataCons cs}) = length cs
461 tyConFamilySize (AlgTyCon {dataCons = HasCons n}) = n
462 tyConFamilySize (TupleTyCon {}) = 1
464 tyConFamilySize other = pprPanic "tyConFamilySize:" (ppr other)
467 tyConSelIds :: TyCon -> [Id]
468 tyConSelIds (AlgTyCon {selIds = sels}) = sels
469 tyConSelIds other_tycon = []
473 tyConPrimRep :: TyCon -> PrimRep
474 tyConPrimRep (PrimTyCon {primTyConRep = rep}) = rep
475 tyConPrimRep tc = ASSERT( not (isUnboxedTupleTyCon tc) )
477 -- We should not be asking what the representation of an
478 -- unboxed tuple is, because it isn't a first class value.
482 tyConTheta :: TyCon -> [PredType]
483 tyConTheta (AlgTyCon {algTyConTheta = theta}) = theta
484 tyConTheta (TupleTyCon {}) = []
485 -- shouldn't ask about anything else
488 @tyConArgVrcs_maybe@ gives a list of (occPos,occNeg) flags, one for
489 each tyvar, if available. See @calcAlgTyConArgVrcs@ for how this is
490 actually computed (in another file).
493 tyConArgVrcs_maybe :: TyCon -> Maybe ArgVrcs
495 tyConArgVrcs_maybe (FunTyCon {} ) = Just [(False,True),(True,False)]
496 tyConArgVrcs_maybe (AlgTyCon {tyConArgVrcs = oi}) = Just oi
497 tyConArgVrcs_maybe (PrimTyCon {tyConArgVrcs = oi}) = Just oi
498 tyConArgVrcs_maybe (TupleTyCon {tyConArity = arity }) = Just (replicate arity (True,False))
499 tyConArgVrcs_maybe (SynTyCon {tyConArgVrcs = oi }) = Just oi
500 tyConArgVrcs_maybe _ = Nothing
504 getSynTyConDefn :: TyCon -> ([TyVar], Type)
505 getSynTyConDefn (SynTyCon {tyConTyVars = tyvars, synTyConDefn = ty}) = (tyvars,ty)
509 maybeTyConSingleCon :: TyCon -> Maybe DataCon
510 maybeTyConSingleCon (AlgTyCon {dataCons = DataCons [c]}) = Just c
511 maybeTyConSingleCon (AlgTyCon {}) = Nothing
512 maybeTyConSingleCon (TupleTyCon {dataCon = con}) = Just con
513 maybeTyConSingleCon (PrimTyCon {}) = Nothing
514 maybeTyConSingleCon (FunTyCon {}) = Nothing -- case at funty
515 maybeTyConSingleCon tc = pprPanic "maybeTyConSingleCon: unexpected tycon " $ ppr tc
519 isClassTyCon :: TyCon -> Bool
520 isClassTyCon (AlgTyCon {algTyConClass = Just _}) = True
521 isClassTyCon other_tycon = False
523 tyConClass_maybe :: TyCon -> Maybe Class
524 tyConClass_maybe (AlgTyCon {algTyConClass = maybe_clas}) = maybe_clas
525 tyConClass_maybe ther_tycon = Nothing
529 %************************************************************************
531 \subsection[TyCon-instances]{Instance declarations for @TyCon@}
533 %************************************************************************
535 @TyCon@s are compared by comparing their @Unique@s.
537 The strictness analyser needs @Ord@. It is a lexicographic order with
538 the property @(a<=b) || (b<=a)@.
541 instance Eq TyCon where
542 a == b = case (a `compare` b) of { EQ -> True; _ -> False }
543 a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
545 instance Ord TyCon where
546 a <= b = case (a `compare` b) of { LT -> True; EQ -> True; GT -> False }
547 a < b = case (a `compare` b) of { LT -> True; EQ -> False; GT -> False }
548 a >= b = case (a `compare` b) of { LT -> False; EQ -> True; GT -> True }
549 a > b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True }
550 compare a b = getUnique a `compare` getUnique b
552 instance Uniquable TyCon where
553 getUnique tc = tyConUnique tc
555 instance Outputable TyCon where
556 ppr tc = ppr (getName tc)
558 instance NamedThing TyCon where
563 %************************************************************************
565 \subsection{Kind constructors}
567 %************************************************************************
569 @matchesTyCon tc1 tc2@ checks whether an appliation
570 (tc1 t1..tn) matches (tc2 t1..tn). By "matches" we basically mean "equals",
571 except that at the kind level tc2 might have more boxity info than tc1.
574 matchesTyCon :: TyCon -- Expected (e.g. arg type of function)
575 -> TyCon -- Inferred (e.g. type of actual arg to function)
578 matchesTyCon tc1 tc2 = uniq1 == uniq2 || uniq1 == anyBoxConKey
580 uniq1 = tyConUnique tc1
581 uniq2 = tyConUnique tc2