2 % (c) The GRASP Project, Glasgow University, 1994-1998
4 \section[TysWiredIn]{Wired-in knowledge about {\em non-primitive} types}
6 This module is about types that can be defined in Haskell, but which
7 must be wired into the compiler nonetheless.
9 This module tracks the ``state interface'' document, ``GHC prelude:
10 types and operations.''
16 boolTy, boolTyCon, boolTyCon_RDR, boolTyConName,
17 trueDataCon, trueDataConId, true_RDR,
18 falseDataCon, falseDataConId, false_RDR,
20 charTyCon, charDataCon, charTyCon_RDR,
21 charTy, stringTy, charTyConName,
24 doubleTyCon, doubleDataCon, doubleTy, doubleTyConName,
26 floatTyCon, floatDataCon, floatTy, floatTyConName,
28 intTyCon, intDataCon, intTyCon_RDR, intDataCon_RDR, intTyConName,
31 listTyCon, nilDataCon, consDataCon,
32 listTyCon_RDR, consDataCon_RDR, listTyConName,
38 unitTyCon, unitDataCon, unitDataConId, pairTyCon,
39 unboxedSingletonTyCon, unboxedSingletonDataCon,
40 unboxedPairTyCon, unboxedPairDataCon,
47 parrTyCon, parrFakeCon, isPArrTyCon, isPArrFakeCon,
48 parrTyCon_RDR, parrTyConName
51 #include "HsVersions.h"
53 import {-# SOURCE #-} MkId( mkDataConIds )
60 import Constants ( mAX_TUPLE_SIZE )
61 import Module ( Module )
62 import RdrName ( nameRdrName )
63 import Name ( Name, BuiltInSyntax(..), nameUnique, nameOccName,
64 nameModule, mkWiredInName )
65 import OccName ( mkOccNameFS, tcName, dataName, mkTupleOcc,
67 import DataCon ( DataCon, mkDataCon, dataConWorkId, dataConSourceArity )
68 import Var ( TyVar, tyVarKind )
69 import TyCon ( TyCon, AlgTyConRhs(DataTyCon), tyConDataCons,
70 mkTupleTyCon, mkAlgTyCon, tyConName,
71 AlgTyConParent(NoParentTyCon) )
73 import BasicTypes ( Arity, RecFlag(..), Boxity(..), isBoxed,
76 import Type ( Type, mkTyConTy, mkTyConApp, mkTyVarTy, mkTyVarTys,
78 import Coercion ( unsafeCoercionTyCon, symCoercionTyCon,
79 transCoercionTyCon, leftCoercionTyCon,
80 rightCoercionTyCon, instCoercionTyCon )
81 import TypeRep ( mkArrowKinds, liftedTypeKind, ubxTupleKind )
82 import Unique ( incrUnique, mkTupleTyConUnique,
83 mkTupleDataConUnique, mkPArrDataConUnique )
88 alpha_tyvar = [alphaTyVar]
93 %************************************************************************
95 \subsection{Wired in type constructors}
97 %************************************************************************
99 If you change which things are wired in, make sure you change their
100 names in PrelNames, so they use wTcQual, wDataQual, etc
103 wiredInTyCons :: [TyCon] -- Excludes tuples
104 -- This list is used only to define PrelInfo.wiredInThings
106 -- It does not need to include kind constructors, because
107 -- all that wiredInThings does is to initialise the Name table,
108 -- and kind constructors don't appear in source code.
110 wiredInTyCons = [ unitTyCon -- Not treated like other tuples, because
111 -- it's defined in GHC.Base, and there's only
112 -- one of it. We put it in wiredInTyCons so
113 -- that it'll pre-populate the name cache, so
114 -- the special case in lookupOrigNameCache
115 -- doesn't need to look out for it
123 , unsafeCoercionTyCon
133 mkWiredInTyConName :: BuiltInSyntax -> Module -> FastString -> Unique -> TyCon -> Name
134 mkWiredInTyConName built_in mod fs uniq tycon
135 = mkWiredInName mod (mkOccNameFS tcName fs) uniq
136 Nothing -- No parent object
137 (ATyCon tycon) -- Relevant TyCon
140 mkWiredInDataConName :: BuiltInSyntax -> Module -> FastString -> Unique -> DataCon -> Name -> Name
141 mkWiredInDataConName built_in mod fs uniq datacon parent
142 = mkWiredInName mod (mkOccNameFS dataName fs) uniq
143 (Just parent) -- Name of parent TyCon
144 (ADataCon datacon) -- Relevant DataCon
147 charTyConName = mkWiredInTyConName UserSyntax gHC_BASE FSLIT("Char") charTyConKey charTyCon
148 charDataConName = mkWiredInDataConName UserSyntax gHC_BASE FSLIT("C#") charDataConKey charDataCon charTyConName
149 intTyConName = mkWiredInTyConName UserSyntax gHC_BASE FSLIT("Int") intTyConKey intTyCon
150 intDataConName = mkWiredInDataConName UserSyntax gHC_BASE FSLIT("I#") intDataConKey intDataCon intTyConName
152 boolTyConName = mkWiredInTyConName UserSyntax gHC_BASE FSLIT("Bool") boolTyConKey boolTyCon
153 falseDataConName = mkWiredInDataConName UserSyntax gHC_BASE FSLIT("False") falseDataConKey falseDataCon boolTyConName
154 trueDataConName = mkWiredInDataConName UserSyntax gHC_BASE FSLIT("True") trueDataConKey trueDataCon boolTyConName
155 listTyConName = mkWiredInTyConName BuiltInSyntax gHC_BASE FSLIT("[]") listTyConKey listTyCon
156 nilDataConName = mkWiredInDataConName BuiltInSyntax gHC_BASE FSLIT("[]") nilDataConKey nilDataCon listTyConName
157 consDataConName = mkWiredInDataConName BuiltInSyntax gHC_BASE FSLIT(":") consDataConKey consDataCon listTyConName
159 floatTyConName = mkWiredInTyConName UserSyntax gHC_FLOAT FSLIT("Float") floatTyConKey floatTyCon
160 floatDataConName = mkWiredInDataConName UserSyntax gHC_FLOAT FSLIT("F#") floatDataConKey floatDataCon floatTyConName
161 doubleTyConName = mkWiredInTyConName UserSyntax gHC_FLOAT FSLIT("Double") doubleTyConKey doubleTyCon
162 doubleDataConName = mkWiredInDataConName UserSyntax gHC_FLOAT FSLIT("D#") doubleDataConKey doubleDataCon doubleTyConName
164 parrTyConName = mkWiredInTyConName BuiltInSyntax gHC_PARR FSLIT("[::]") parrTyConKey parrTyCon
165 parrDataConName = mkWiredInDataConName UserSyntax gHC_PARR FSLIT("PArr") parrDataConKey parrDataCon parrTyConName
167 boolTyCon_RDR = nameRdrName boolTyConName
168 false_RDR = nameRdrName falseDataConName
169 true_RDR = nameRdrName trueDataConName
170 intTyCon_RDR = nameRdrName intTyConName
171 charTyCon_RDR = nameRdrName charTyConName
172 intDataCon_RDR = nameRdrName intDataConName
173 listTyCon_RDR = nameRdrName listTyConName
174 consDataCon_RDR = nameRdrName consDataConName
175 parrTyCon_RDR = nameRdrName parrTyConName
177 tySuperKindTyCon_RDR = nameRdrName tySuperKindTyConName
178 coSuperKindTyCon_RDR = nameRdrName coSuperKindTyConName
179 liftedTypeKindTyCon_RDR = nameRdrName liftedTypeKindTyConName
180 openTypeKindTyCon_RDR = nameRdrName openTypeKindTyConName
181 unliftedTypeKindTyCon_RDR = nameRdrName unliftedTypeKindTyConName
182 ubxTupleKindTyCon_RDR = nameRdrName ubxTupleKindTyConName
183 argTypeKindTyCon_RDR = nameRdrName argTypeKindTyConName
184 funKindTyCon_RDR = nameRdrName funKindTyConName
189 %************************************************************************
191 \subsection{mkWiredInTyCon}
193 %************************************************************************
196 pcNonRecDataTyCon = pcTyCon False NonRecursive
197 pcRecDataTyCon = pcTyCon False Recursive
199 pcTyCon is_enum is_rec name tyvars cons
202 tycon = mkAlgTyCon name
203 (mkArrowKinds (map tyVarKind tyvars) liftedTypeKind)
205 [] -- No stupid theta
206 (DataTyCon cons is_enum)
207 [] -- No record selectors
210 True -- All the wired-in tycons have generics
211 False -- Not in GADT syntax
213 pcDataCon :: Name -> [TyVar] -> [Type] -> TyCon -> DataCon
214 pcDataCon = pcDataConWithFixity False
216 pcDataConWithFixity :: Bool -> Name -> [TyVar] -> [Type] -> TyCon -> DataCon
217 -- The Name should be in the DataName name space; it's the name
218 -- of the DataCon itself.
220 -- The unique is the first of two free uniques;
221 -- the first is used for the datacon itself,
222 -- the second is used for the "worker name"
224 pcDataConWithFixity declared_infix dc_name tyvars arg_tys tycon
227 data_con = mkDataCon dc_name declared_infix
228 (map (const NotMarkedStrict) arg_tys)
229 [] -- No labelled fields
231 [] -- No existential type variables
232 [] -- No equality spec
235 [] -- No stupid theta
236 (mkDataConIds bogus_wrap_name wrk_name data_con)
239 mod = nameModule dc_name
240 wrk_occ = mkDataConWorkerOcc (nameOccName dc_name)
241 wrk_key = incrUnique (nameUnique dc_name)
242 wrk_name = mkWiredInName mod wrk_occ wrk_key
243 (Just (tyConName tycon))
244 (AnId (dataConWorkId data_con)) UserSyntax
245 bogus_wrap_name = pprPanic "Wired-in data wrapper id" (ppr dc_name)
246 -- Wired-in types are too simple to need wrappers
250 %************************************************************************
252 \subsection[TysWiredIn-tuples]{The tuple types}
254 %************************************************************************
257 tupleTyCon :: Boxity -> Arity -> TyCon
258 tupleTyCon boxity i | i > mAX_TUPLE_SIZE = fst (mk_tuple boxity i) -- Build one specially
259 tupleTyCon Boxed i = fst (boxedTupleArr ! i)
260 tupleTyCon Unboxed i = fst (unboxedTupleArr ! i)
262 tupleCon :: Boxity -> Arity -> DataCon
263 tupleCon boxity i | i > mAX_TUPLE_SIZE = snd (mk_tuple boxity i) -- Build one specially
264 tupleCon Boxed i = snd (boxedTupleArr ! i)
265 tupleCon Unboxed i = snd (unboxedTupleArr ! i)
267 boxedTupleArr, unboxedTupleArr :: Array Int (TyCon,DataCon)
268 boxedTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple Boxed i | i <- [0..mAX_TUPLE_SIZE]]
269 unboxedTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple Unboxed i | i <- [0..mAX_TUPLE_SIZE]]
271 mk_tuple :: Boxity -> Int -> (TyCon,DataCon)
272 mk_tuple boxity arity = (tycon, tuple_con)
274 tycon = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con boxity gen_info
275 mod = mkTupleModule boxity arity
276 tc_name = mkWiredInName mod (mkTupleOcc tcName boxity arity) tc_uniq
277 Nothing (ATyCon tycon) BuiltInSyntax
278 tc_kind = mkArrowKinds (map tyVarKind tyvars) res_kind
279 res_kind | isBoxed boxity = liftedTypeKind
280 | otherwise = ubxTupleKind
282 tyvars | isBoxed boxity = take arity alphaTyVars
283 | otherwise = take arity openAlphaTyVars
285 tuple_con = pcDataCon dc_name tyvars tyvar_tys tycon
286 tyvar_tys = mkTyVarTys tyvars
287 dc_name = mkWiredInName mod (mkTupleOcc dataName boxity arity) dc_uniq
288 (Just tc_name) (ADataCon tuple_con) BuiltInSyntax
289 tc_uniq = mkTupleTyConUnique boxity arity
290 dc_uniq = mkTupleDataConUnique boxity arity
291 gen_info = True -- Tuples all have generics..
292 -- hmm: that's a *lot* of code
294 unitTyCon = tupleTyCon Boxed 0
295 unitDataCon = head (tyConDataCons unitTyCon)
296 unitDataConId = dataConWorkId unitDataCon
298 pairTyCon = tupleTyCon Boxed 2
300 unboxedSingletonTyCon = tupleTyCon Unboxed 1
301 unboxedSingletonDataCon = tupleCon Unboxed 1
303 unboxedPairTyCon = tupleTyCon Unboxed 2
304 unboxedPairDataCon = tupleCon Unboxed 2
307 %************************************************************************
309 \subsection[TysWiredIn-boxed-prim]{The ``boxed primitive'' types (@Char@, @Int@, etc)}
311 %************************************************************************
314 -- The Void type is represented as a data type with no constructors
315 -- It's a built in type (i.e. there's no way to define it in Haskell;
316 -- the nearest would be
318 -- data Void = -- No constructors!
320 -- ) It's lifted; there is only one value of this
321 -- type, namely "void", whose semantics is just bottom.
323 -- Haskell 98 drops the definition of a Void type, so we just 'simulate'
330 charTy = mkTyConTy charTyCon
332 charTyCon = pcNonRecDataTyCon charTyConName [] [charDataCon]
333 charDataCon = pcDataCon charDataConName [] [charPrimTy] charTyCon
335 stringTy = mkListTy charTy -- convenience only
339 intTy = mkTyConTy intTyCon
341 intTyCon = pcNonRecDataTyCon intTyConName [] [intDataCon]
342 intDataCon = pcDataCon intDataConName [] [intPrimTy] intTyCon
346 floatTy = mkTyConTy floatTyCon
348 floatTyCon = pcNonRecDataTyCon floatTyConName [] [floatDataCon]
349 floatDataCon = pcDataCon floatDataConName [] [floatPrimTy] floatTyCon
353 doubleTy = mkTyConTy doubleTyCon
355 doubleTyCon = pcNonRecDataTyCon doubleTyConName [] [doubleDataCon]
356 doubleDataCon = pcDataCon doubleDataConName [] [doublePrimTy] doubleTyCon
360 %************************************************************************
362 \subsection[TysWiredIn-Bool]{The @Bool@ type}
364 %************************************************************************
366 An ordinary enumeration type, but deeply wired in. There are no
367 magical operations on @Bool@ (just the regular Prelude code).
369 {\em BEGIN IDLE SPECULATION BY SIMON}
371 This is not the only way to encode @Bool@. A more obvious coding makes
372 @Bool@ just a boxed up version of @Bool#@, like this:
375 data Bool = MkBool Bool#
378 Unfortunately, this doesn't correspond to what the Report says @Bool@
379 looks like! Furthermore, we get slightly less efficient code (I
380 think) with this coding. @gtInt@ would look like this:
383 gtInt :: Int -> Int -> Bool
384 gtInt x y = case x of I# x# ->
386 case (gtIntPrim x# y#) of
390 Notice that the result of the @gtIntPrim@ comparison has to be turned
391 into an integer (here called @b#@), and returned in a @MkBool@ box.
393 The @if@ expression would compile to this:
396 MkBool b# -> case b# of { 1# -> e1; 0# -> e2 }
399 I think this code is a little less efficient than the previous code,
400 but I'm not certain. At all events, corresponding with the Report is
401 important. The interesting thing is that the language is expressive
402 enough to describe more than one alternative; and that a type doesn't
403 necessarily need to be a straightforwardly boxed version of its
404 primitive counterpart.
406 {\em END IDLE SPECULATION BY SIMON}
409 boolTy = mkTyConTy boolTyCon
411 boolTyCon = pcTyCon True NonRecursive boolTyConName
412 [] [falseDataCon, trueDataCon]
414 falseDataCon = pcDataCon falseDataConName [] [] boolTyCon
415 trueDataCon = pcDataCon trueDataConName [] [] boolTyCon
417 falseDataConId = dataConWorkId falseDataCon
418 trueDataConId = dataConWorkId trueDataCon
421 %************************************************************************
423 \subsection[TysWiredIn-List]{The @List@ type (incl ``build'' magic)}
425 %************************************************************************
427 Special syntax, deeply wired in, but otherwise an ordinary algebraic
430 data [] a = [] | a : (List a)
432 data (,) a b = (,,) a b
437 mkListTy :: Type -> Type
438 mkListTy ty = mkTyConApp listTyCon [ty]
440 listTyCon = pcRecDataTyCon listTyConName alpha_tyvar [nilDataCon, consDataCon]
442 nilDataCon = pcDataCon nilDataConName alpha_tyvar [] listTyCon
443 consDataCon = pcDataConWithFixity True {- Declared infix -}
445 alpha_tyvar [alphaTy, mkTyConApp listTyCon alpha_ty] listTyCon
446 -- Interesting: polymorphic recursion would help here.
447 -- We can't use (mkListTy alphaTy) in the defn of consDataCon, else mkListTy
448 -- gets the over-specific type (Type -> Type)
451 %************************************************************************
453 \subsection[TysWiredIn-Tuples]{The @Tuple@ types}
455 %************************************************************************
457 The tuple types are definitely magic, because they form an infinite
462 They have a special family of type constructors, of type @TyCon@
463 These contain the tycon arity, but don't require a Unique.
466 They have a special family of constructors, of type
467 @Id@. Again these contain their arity but don't need a Unique.
470 There should be a magic way of generating the info tables and
471 entry code for all tuples.
473 But at the moment we just compile a Haskell source
474 file\srcloc{lib/prelude/...} containing declarations like:
477 data Tuple2 a b = Tup2 a b
478 data Tuple3 a b c = Tup3 a b c
479 data Tuple4 a b c d = Tup4 a b c d
482 The print-names associated with the magic @Id@s for tuple constructors
483 ``just happen'' to be the same as those generated by these
487 The instance environment should have a magic way to know
488 that each tuple type is an instances of classes @Eq@, @Ix@, @Ord@ and
489 so on. \ToDo{Not implemented yet.}
492 There should also be a way to generate the appropriate code for each
493 of these instances, but (like the info tables and entry code) it is
494 done by enumeration\srcloc{lib/prelude/InTup?.hs}.
498 mkTupleTy :: Boxity -> Int -> [Type] -> Type
499 mkTupleTy boxity arity tys = mkTyConApp (tupleTyCon boxity arity) tys
501 unitTy = mkTupleTy Boxed 0 []
504 %************************************************************************
506 \subsection[TysWiredIn-PArr]{The @[::]@ type}
508 %************************************************************************
510 Special syntax for parallel arrays needs some wired in definitions.
513 -- construct a type representing the application of the parallel array
516 mkPArrTy :: Type -> Type
517 mkPArrTy ty = mkTyConApp parrTyCon [ty]
519 -- represents the type constructor of parallel arrays
521 -- * this must match the definition in `PrelPArr'
523 -- NB: Although the constructor is given here, it will not be accessible in
524 -- user code as it is not in the environment of any compiled module except
528 parrTyCon = pcNonRecDataTyCon parrTyConName alpha_tyvar [parrDataCon]
530 parrDataCon :: DataCon
531 parrDataCon = pcDataCon
533 alpha_tyvar -- forall'ed type variables
534 [intPrimTy, -- 1st argument: Int#
535 mkTyConApp -- 2nd argument: Array# a
540 -- check whether a type constructor is the constructor for parallel arrays
542 isPArrTyCon :: TyCon -> Bool
543 isPArrTyCon tc = tyConName tc == parrTyConName
545 -- fake array constructors
547 -- * these constructors are never really used to represent array values;
548 -- however, they are very convenient during desugaring (and, in particular,
549 -- in the pattern matching compiler) to treat array pattern just like
550 -- yet another constructor pattern
552 parrFakeCon :: Arity -> DataCon
553 parrFakeCon i | i > mAX_TUPLE_SIZE = mkPArrFakeCon i -- build one specially
554 parrFakeCon i = parrFakeConArr!i
556 -- pre-defined set of constructors
558 parrFakeConArr :: Array Int DataCon
559 parrFakeConArr = array (0, mAX_TUPLE_SIZE) [(i, mkPArrFakeCon i)
560 | i <- [0..mAX_TUPLE_SIZE]]
562 -- build a fake parallel array constructor for the given arity
564 mkPArrFakeCon :: Int -> DataCon
565 mkPArrFakeCon arity = data_con
567 data_con = pcDataCon name [tyvar] tyvarTys parrTyCon
568 tyvar = head alphaTyVars
569 tyvarTys = replicate arity $ mkTyVarTy tyvar
570 nameStr = mkFastString ("MkPArr" ++ show arity)
571 name = mkWiredInName gHC_PARR (mkOccNameFS dataName nameStr) uniq
572 Nothing (ADataCon data_con) UserSyntax
573 uniq = mkPArrDataConUnique arity
575 -- checks whether a data constructor is a fake constructor for parallel arrays
577 isPArrFakeCon :: DataCon -> Bool
578 isPArrFakeCon dcon = dcon == parrFakeCon (dataConSourceArity dcon)