2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
4 \section[TyCon]{The @TyCon@ datatype}
7 #include "HsVersions.h"
10 TyCon(..), -- NB: some pals need to see representation
12 Arity(..), NewOrData(..),
14 isFunTyCon, isPrimTyCon, isBoxedTyCon,
15 isDataTyCon, isSynTyCon, isNewTyCon,
31 tyConArity, synTyConArity,
39 CHK_Ubiq() -- debugging consistency check
41 import TyLoop ( Type(..), GenType,
44 mkTupleCon, dataConSig,
48 import TyVar ( GenTyVar, alphaTyVars, alphaTyVar, betaTyVar )
49 import Usage ( GenUsage, Usage(..) )
50 import Kind ( Kind, mkBoxedTypeKind, mkArrowKind, resultKind, argKind )
53 import Name ( Name, RdrName(..), appendRdr, nameUnique,
54 mkTupleTyConName, mkFunTyConName
56 import Unique ( Unique, funTyConKey, mkTupleTyConUnique )
57 import Pretty ( Pretty(..), PrettyRep )
58 import SrcLoc ( SrcLoc, mkBuiltinSrcLoc )
59 import Util ( panic, panic#, pprPanic{-ToDo:rm-}, nOfThem, isIn, Ord3(..) )
70 = FunTyCon -- Kind = Type -> Type -> Type
72 | DataTyCon Unique{-TyConKey-}
76 [(Class,Type)] -- Its context
77 [Id] -- Its data constructors, with fully polymorphic types
78 [Class] -- Classes which have derived instances
81 | TupleTyCon Unique -- cached
82 Name -- again, we could do without this, but
83 -- it makes life somewhat easier
84 Arity -- just a special case of DataTyCon
85 -- Kind = BoxedTypeKind
86 -- -> ... (n times) ...
90 | PrimTyCon -- Primitive types; cannot be defined in Haskell
91 Unique -- Always unboxed; hence never represented by a closure
92 Name -- Often represented by a bit-pattern for the thing
93 Kind -- itself (eg Int#), but sometimes by a pointer to
95 | SpecTyCon -- A specialised TyCon; eg (Arr# Int#), or (List Int#)
97 [Maybe Type] -- Specialising types
99 -- OLD STUFF ABOUT Array types. Use SpecTyCon instead
100 -- ([PrimRep] -> PrimRep) -- a heap-allocated object (eg ArrInt#).
101 -- The primitive types Arr# and StablePtr# have
102 -- parameters (hence arity /= 0); but the rest don't.
103 -- Only arrays use the list in a non-trivial way.
104 -- Length of that list must == arity.
111 [TyVar] -- Argument type variables
112 Type -- Right-hand side, mentioning these type vars.
113 -- Acts as a template for the expansion when
114 -- the tycon is applied to some types.
117 = NewType -- "newtype Blah ..."
118 | DataType -- "data Blah ..."
122 mkFunTyCon = FunTyCon
123 mkSpecTyCon = SpecTyCon
126 = TupleTyCon u n arity
128 n = mkTupleTyConName arity
132 = DataTyCon (nameUnique name) name
134 = PrimTyCon (nameUnique name) name
136 = SynTyCon (nameUnique name) name
138 isFunTyCon FunTyCon = True
141 isPrimTyCon (PrimTyCon _ _ _) = True
142 isPrimTyCon _ = False
144 -- At present there are no unboxed non-primitive types, so
145 -- isBoxedTyCon is just the negation of isPrimTyCon.
146 isBoxedTyCon = not . isPrimTyCon
148 -- isDataTyCon returns False for @newtype@.
149 -- Not sure about this decision yet.
150 isDataTyCon (DataTyCon _ _ _ _ _ _ _ DataType) = True
151 isDataTyCon (TupleTyCon _ _ _) = True
152 isDataTyCon other = False
154 isNewTyCon (DataTyCon _ _ _ _ _ _ _ NewType) = True
155 isNewTyCon other = False
157 isSynTyCon (SynTyCon _ _ _ _ _ _) = True
162 -- Special cases to avoid reconstructing lots of kinds
163 kind1 = mkBoxedTypeKind `mkArrowKind` mkBoxedTypeKind
164 kind2 = mkBoxedTypeKind `mkArrowKind` kind1
166 tyConKind :: TyCon -> Kind
167 tyConKind FunTyCon = kind2
168 tyConKind (DataTyCon _ _ kind _ _ _ _ _) = kind
169 tyConKind (PrimTyCon _ _ kind) = kind
170 tyConKind (SynTyCon _ _ k _ _ _) = k
172 tyConKind (TupleTyCon _ _ n)
175 mkArrow 0 = mkBoxedTypeKind
178 mkArrow n = mkBoxedTypeKind `mkArrowKind` mkArrow (n-1)
180 tyConKind (SpecTyCon tc tys)
181 = spec (tyConKind tc) tys
184 spec kind (Just _ : tys) = spec (resultKind kind) tys
185 spec kind (Nothing : tys) =
186 argKind kind `mkArrowKind` spec (resultKind kind) tys
190 tyConUnique :: TyCon -> Unique
191 tyConUnique FunTyCon = funTyConKey
192 tyConUnique (DataTyCon uniq _ _ _ _ _ _ _) = uniq
193 tyConUnique (TupleTyCon uniq _ _) = uniq
194 tyConUnique (PrimTyCon uniq _ _) = uniq
195 tyConUnique (SynTyCon uniq _ _ _ _ _) = uniq
196 tyConUnique (SpecTyCon _ _ ) = panic "tyConUnique:SpecTyCon"
198 tyConArity :: TyCon -> Arity
199 tyConArity FunTyCon = 2
200 tyConArity (DataTyCon _ _ _ tvs _ _ _ _) = length tvs
201 tyConArity (TupleTyCon _ _ arity) = arity
202 tyConArity (PrimTyCon _ _ _) = 0 -- ??
203 tyConArity (SpecTyCon _ _) = 0
204 tyConArity (SynTyCon _ _ _ arity _ _) = arity
206 synTyConArity :: TyCon -> Maybe Arity -- Nothing <=> not a syn tycon
207 synTyConArity (SynTyCon _ _ _ arity _ _) = Just arity
208 synTyConArity _ = Nothing
212 tyConTyVars :: TyCon -> [TyVar]
213 tyConTyVars FunTyCon = [alphaTyVar,betaTyVar]
214 tyConTyVars (DataTyCon _ _ _ tvs _ _ _ _) = tvs
215 tyConTyVars (TupleTyCon _ _ arity) = take arity alphaTyVars
216 tyConTyVars (SynTyCon _ _ _ _ tvs _) = tvs
217 tyConTyVars (PrimTyCon _ _ _) = panic "tyConTyVars:PrimTyCon"
218 tyConTyVars (SpecTyCon _ _ ) = panic "tyConTyVars:SpecTyCon"
222 tyConDataCons :: TyCon -> [Id]
223 tyConFamilySize :: TyCon -> Int
225 tyConDataCons (DataTyCon _ _ _ _ _ data_cons _ _) = data_cons
226 tyConDataCons (TupleTyCon _ _ a) = [mkTupleCon a]
227 tyConDataCons other = []
228 -- You may think this last equation should fail,
229 -- but it's quite convenient to return no constructors for
230 -- a synonym; see for example the call in TcTyClsDecls.
232 tyConFamilySize (DataTyCon _ _ _ _ _ data_cons _ _) = length data_cons
233 tyConFamilySize (TupleTyCon _ _ _) = 1
235 tyConFamilySize other = pprPanic "tyConFamilySize:" (pprTyCon PprDebug other)
240 tyConDerivings :: TyCon -> [Class]
241 tyConDerivings (DataTyCon _ _ _ _ _ _ derivs _) = derivs
242 tyConDerivings other = []
246 getSynTyConDefn :: TyCon -> ([TyVar], Type)
247 getSynTyConDefn (SynTyCon _ _ _ _ tyvars ty) = (tyvars,ty)
251 maybeTyConSingleCon :: TyCon -> Maybe Id
253 maybeTyConSingleCon (TupleTyCon _ _ arity) = Just (mkTupleCon arity)
254 maybeTyConSingleCon (DataTyCon _ _ _ _ _ [c] _ _) = Just c
255 maybeTyConSingleCon (DataTyCon _ _ _ _ _ _ _ _) = Nothing
256 maybeTyConSingleCon (PrimTyCon _ _ _) = Nothing
257 maybeTyConSingleCon (SpecTyCon tc tys) = panic "maybeTyConSingleCon:SpecTyCon"
258 -- requires DataCons of TyCon
260 isEnumerationTyCon (TupleTyCon _ _ arity)
262 isEnumerationTyCon (DataTyCon _ _ _ _ _ data_cons _ _)
263 = not (null data_cons) && all is_nullary data_cons
265 is_nullary con = case (dataConSig con) of { (_,_, arg_tys, _) ->
269 @derivedFor@ reports if we have an {\em obviously}-derived instance
270 for the given class/tycon. Of course, you might be deriving something
271 because it a superclass of some other obviously-derived class --- this
272 function doesn't deal with that.
274 ToDo: what about derivings for specialised tycons !!!
277 derivedFor :: Class -> TyCon -> Bool
278 derivedFor clas (DataTyCon _ _ _ _ _ _ derivs _) = isIn "derivedFor" clas derivs
279 derivedFor clas something_weird = False
282 %************************************************************************
284 \subsection[TyCon-instances]{Instance declarations for @TyCon@}
286 %************************************************************************
288 @TyCon@s are compared by comparing their @Unique@s.
290 The strictness analyser needs @Ord@. It is a lexicographic order with
291 the property @(a<=b) || (b<=a)@.
294 instance Ord3 TyCon where
295 cmp FunTyCon FunTyCon = EQ_
296 cmp (DataTyCon a _ _ _ _ _ _ _) (DataTyCon b _ _ _ _ _ _ _) = a `cmp` b
297 cmp (SynTyCon a _ _ _ _ _) (SynTyCon b _ _ _ _ _) = a `cmp` b
298 cmp (TupleTyCon _ _ a) (TupleTyCon _ _ b) = a `cmp` b
299 cmp (PrimTyCon a _ _) (PrimTyCon b _ _) = a `cmp` b
300 cmp (SpecTyCon tc1 mtys1) (SpecTyCon tc2 mtys2)
301 = panic# "cmp on SpecTyCons" -- case (tc1 `cmp` tc2) of { EQ_ -> mtys1 `cmp` mtys2; xxx -> xxx }
303 -- now we *know* the tags are different, so...
305 | tag1 _LT_ tag2 = LT_
308 tag1 = tag_TyCon other_1
309 tag2 = tag_TyCon other_2
311 tag_TyCon FunTyCon = ILIT(1)
312 tag_TyCon (DataTyCon _ _ _ _ _ _ _ _) = ILIT(2)
313 tag_TyCon (TupleTyCon _ _ _) = ILIT(3)
314 tag_TyCon (PrimTyCon _ _ _) = ILIT(4)
315 tag_TyCon (SpecTyCon _ _) = ILIT(5)
316 tag_TyCon (SynTyCon _ _ _ _ _ _) = ILIT(6)
318 instance Eq TyCon where
319 a == b = case (a `cmp` b) of { EQ_ -> True; _ -> False }
320 a /= b = case (a `cmp` b) of { EQ_ -> False; _ -> True }
322 instance Ord TyCon where
323 a <= b = case (a `cmp` b) of { LT_ -> True; EQ_ -> True; GT__ -> False }
324 a < b = case (a `cmp` b) of { LT_ -> True; EQ_ -> False; GT__ -> False }
325 a >= b = case (a `cmp` b) of { LT_ -> False; EQ_ -> True; GT__ -> True }
326 a > b = case (a `cmp` b) of { LT_ -> False; EQ_ -> False; GT__ -> True }
327 _tagCmp a b = case (a `cmp` b) of { LT_ -> _LT; EQ_ -> _EQ; GT__ -> _GT }
329 instance Uniquable TyCon where
330 uniqueOf (DataTyCon u _ _ _ _ _ _ _) = u
331 uniqueOf (TupleTyCon u _ _) = u
332 uniqueOf (PrimTyCon u _ _) = u
333 uniqueOf (SynTyCon u _ _ _ _ _) = u
334 uniqueOf tc@(SpecTyCon _ _) = panic "uniqueOf:SpecTyCon"
335 uniqueOf tc = uniqueOf (getName tc)
339 instance NamedThing TyCon where
340 getName (DataTyCon _ n _ _ _ _ _ _) = n
341 getName (PrimTyCon _ n _) = n
342 getName (SpecTyCon tc _) = getName tc
343 getName (SynTyCon _ n _ _ _ _) = n
344 getName FunTyCon = mkFunTyConName
345 getName (TupleTyCon _ n _) = n
346 getName tc = panic "TyCon.getName"
349 getName (SpecTyCon tc tys) = let (m,n) = moduleNamePair tc in
350 (m, n _APPEND_ specMaybeTysSuffix tys)
351 getName other_tc = moduleNamePair (expectJust "tycon1" (getName other_tc))
352 getName other = Nothing