2 % (c) The GRASP Project, Glasgow University, 1994-1998
4 \section[TysWiredIn]{Wired-in knowledge about {\em non-primitive} types}
6 This module tracks the ``state interface'' document, ``GHC prelude:
7 types and operations.''
10 -- | This module is about types that can be defined in Haskell, but which
11 -- must be wired into the compiler nonetheless.
13 -- * All wired in things
17 boolTy, boolTyCon, boolTyCon_RDR, boolTyConName,
18 trueDataCon, trueDataConId, true_RDR,
19 falseDataCon, falseDataConId, false_RDR,
22 charTyCon, charDataCon, charTyCon_RDR,
23 charTy, stringTy, charTyConName,
26 doubleTyCon, doubleDataCon, doubleTy, doubleTyConName,
29 floatTyCon, floatDataCon, floatTy, floatTyConName,
32 intTyCon, intDataCon, intTyCon_RDR, intDataCon_RDR, intTyConName,
36 wordTyCon, wordDataCon, wordTyConName, wordTy,
39 listTyCon, nilDataCon, consDataCon,
40 listTyCon_RDR, consDataCon_RDR, listTyConName,
46 unitTyCon, unitDataCon, unitDataConId, pairTyCon,
47 unboxedSingletonTyCon, unboxedSingletonDataCon,
48 unboxedPairTyCon, unboxedPairDataCon,
55 parrTyCon, parrFakeCon, isPArrTyCon, isPArrFakeCon,
56 parrTyCon_RDR, parrTyConName
59 #include "HsVersions.h"
61 import {-# SOURCE #-} MkId( mkDataConIds )
68 import Constants ( mAX_TUPLE_SIZE )
69 import Module ( Module )
72 import OccName ( mkTcOccFS, mkDataOccFS, mkTupleOcc, mkDataConWorkerOcc,
74 import DataCon ( DataCon, mkDataCon, dataConWorkId, dataConSourceArity )
76 import TyCon ( TyCon, AlgTyConRhs(DataTyCon), tyConDataCons,
77 mkTupleTyCon, mkAlgTyCon, tyConName,
78 TyConParent(NoParentTyCon) )
80 import BasicTypes ( Arity, RecFlag(..), Boxity(..), isBoxed,
83 import Type ( Type, mkTyConTy, mkTyConApp, mkTyVarTy, mkTyVarTys,
85 import Coercion ( unsafeCoercionTyCon, symCoercionTyCon,
86 transCoercionTyCon, leftCoercionTyCon,
87 rightCoercionTyCon, instCoercionTyCon )
88 import TypeRep ( mkArrowKinds, liftedTypeKind, ubxTupleKind )
89 import Unique ( incrUnique, mkTupleTyConUnique,
90 mkTupleDataConUnique, mkPArrDataConUnique )
95 alpha_tyvar :: [TyVar]
96 alpha_tyvar = [alphaTyVar]
103 %************************************************************************
105 \subsection{Wired in type constructors}
107 %************************************************************************
109 If you change which things are wired in, make sure you change their
110 names in PrelNames, so they use wTcQual, wDataQual, etc
113 wiredInTyCons :: [TyCon] -- Excludes tuples
114 -- This list is used only to define PrelInfo.wiredInThings
116 -- It does not need to include kind constructors, because
117 -- all that wiredInThings does is to initialise the Name table,
118 -- and kind constructors don't appear in source code.
120 wiredInTyCons = [ unitTyCon -- Not treated like other tuples, because
121 -- it's defined in GHC.Base, and there's only
122 -- one of it. We put it in wiredInTyCons so
123 -- that it'll pre-populate the name cache, so
124 -- the special case in lookupOrigNameCache
125 -- doesn't need to look out for it
133 , unsafeCoercionTyCon
143 mkWiredInTyConName :: BuiltInSyntax -> Module -> FastString -> Unique -> TyCon -> Name
144 mkWiredInTyConName built_in modu fs unique tycon
145 = mkWiredInName modu (mkTcOccFS fs) unique
146 (ATyCon tycon) -- Relevant TyCon
149 mkWiredInDataConName :: BuiltInSyntax -> Module -> FastString -> Unique -> DataCon -> Name
150 mkWiredInDataConName built_in modu fs unique datacon
151 = mkWiredInName modu (mkDataOccFS fs) unique
152 (ADataCon datacon) -- Relevant DataCon
155 charTyConName, charDataConName, intTyConName, intDataConName :: Name
156 charTyConName = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "Char") charTyConKey charTyCon
157 charDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "C#") charDataConKey charDataCon
158 intTyConName = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "Int") intTyConKey intTyCon
159 intDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "I#") intDataConKey intDataCon
161 boolTyConName, falseDataConName, trueDataConName :: Name
162 boolTyConName = mkWiredInTyConName UserSyntax gHC_BOOL (fsLit "Bool") boolTyConKey boolTyCon
163 falseDataConName = mkWiredInDataConName UserSyntax gHC_BOOL (fsLit "False") falseDataConKey falseDataCon
164 trueDataConName = mkWiredInDataConName UserSyntax gHC_BOOL (fsLit "True") trueDataConKey trueDataCon
166 listTyConName, nilDataConName, consDataConName :: Name
167 listTyConName = mkWiredInTyConName BuiltInSyntax gHC_TYPES (fsLit "[]") listTyConKey listTyCon
168 nilDataConName = mkWiredInDataConName BuiltInSyntax gHC_TYPES (fsLit "[]") nilDataConKey nilDataCon
169 consDataConName = mkWiredInDataConName BuiltInSyntax gHC_TYPES (fsLit ":") consDataConKey consDataCon
171 floatTyConName, floatDataConName, doubleTyConName, doubleDataConName :: Name
172 floatTyConName = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "Float") floatTyConKey floatTyCon
173 floatDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "F#") floatDataConKey floatDataCon
174 doubleTyConName = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "Double") doubleTyConKey doubleTyCon
175 doubleDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "D#") doubleDataConKey doubleDataCon
177 parrTyConName, parrDataConName :: Name
178 parrTyConName = mkWiredInTyConName BuiltInSyntax gHC_PARR (fsLit "[::]") parrTyConKey parrTyCon
179 parrDataConName = mkWiredInDataConName UserSyntax gHC_PARR (fsLit "PArr") parrDataConKey parrDataCon
181 boolTyCon_RDR, false_RDR, true_RDR, intTyCon_RDR, charTyCon_RDR,
182 intDataCon_RDR, listTyCon_RDR, consDataCon_RDR, parrTyCon_RDR:: RdrName
183 boolTyCon_RDR = nameRdrName boolTyConName
184 false_RDR = nameRdrName falseDataConName
185 true_RDR = nameRdrName trueDataConName
186 intTyCon_RDR = nameRdrName intTyConName
187 charTyCon_RDR = nameRdrName charTyConName
188 intDataCon_RDR = nameRdrName intDataConName
189 listTyCon_RDR = nameRdrName listTyConName
190 consDataCon_RDR = nameRdrName consDataConName
191 parrTyCon_RDR = nameRdrName parrTyConName
193 tySuperKindTyCon_RDR = nameRdrName tySuperKindTyConName
194 coSuperKindTyCon_RDR = nameRdrName coSuperKindTyConName
195 liftedTypeKindTyCon_RDR = nameRdrName liftedTypeKindTyConName
196 openTypeKindTyCon_RDR = nameRdrName openTypeKindTyConName
197 unliftedTypeKindTyCon_RDR = nameRdrName unliftedTypeKindTyConName
198 ubxTupleKindTyCon_RDR = nameRdrName ubxTupleKindTyConName
199 argTypeKindTyCon_RDR = nameRdrName argTypeKindTyConName
200 funKindTyCon_RDR = nameRdrName funKindTyConName
205 %************************************************************************
207 \subsection{mkWiredInTyCon}
209 %************************************************************************
212 pcNonRecDataTyCon :: Name -> [TyVar] -> [DataCon] -> TyCon
213 pcNonRecDataTyCon = pcTyCon False NonRecursive
214 pcRecDataTyCon :: Name -> [TyVar] -> [DataCon] -> TyCon
215 pcRecDataTyCon = pcTyCon False Recursive
217 pcTyCon :: Bool -> RecFlag -> Name -> [TyVar] -> [DataCon] -> TyCon
218 pcTyCon is_enum is_rec name tyvars cons
221 tycon = mkAlgTyCon name
222 (mkArrowKinds (map tyVarKind tyvars) liftedTypeKind)
224 [] -- No stupid theta
225 (DataTyCon cons is_enum)
226 [] -- No record selectors
229 True -- All the wired-in tycons have generics
230 False -- Not in GADT syntax
232 pcDataCon :: Name -> [TyVar] -> [Type] -> TyCon -> DataCon
233 pcDataCon = pcDataConWithFixity False
235 pcDataConWithFixity :: Bool -> Name -> [TyVar] -> [Type] -> TyCon -> DataCon
236 -- The Name should be in the DataName name space; it's the name
237 -- of the DataCon itself.
239 -- The unique is the first of two free uniques;
240 -- the first is used for the datacon itself,
241 -- the second is used for the "worker name"
243 pcDataConWithFixity declared_infix dc_name tyvars arg_tys tycon
246 data_con = mkDataCon dc_name declared_infix
247 (map (const NotMarkedStrict) arg_tys)
248 [] -- No labelled fields
250 [] -- No existential type variables
251 [] -- No equality spec
253 arg_tys (mkTyConApp tycon (mkTyVarTys tyvars))
255 [] -- No stupid theta
256 (mkDataConIds bogus_wrap_name wrk_name data_con)
259 modu = ASSERT( isExternalName dc_name )
261 wrk_occ = mkDataConWorkerOcc (nameOccName dc_name)
262 wrk_key = incrUnique (nameUnique dc_name)
263 wrk_name = mkWiredInName modu wrk_occ wrk_key
264 (AnId (dataConWorkId data_con)) UserSyntax
265 bogus_wrap_name = pprPanic "Wired-in data wrapper id" (ppr dc_name)
266 -- Wired-in types are too simple to need wrappers
270 %************************************************************************
272 \subsection[TysWiredIn-tuples]{The tuple types}
274 %************************************************************************
277 tupleTyCon :: Boxity -> Arity -> TyCon
278 tupleTyCon boxity i | i > mAX_TUPLE_SIZE = fst (mk_tuple boxity i) -- Build one specially
279 tupleTyCon Boxed i = fst (boxedTupleArr ! i)
280 tupleTyCon Unboxed i = fst (unboxedTupleArr ! i)
282 tupleCon :: Boxity -> Arity -> DataCon
283 tupleCon boxity i | i > mAX_TUPLE_SIZE = snd (mk_tuple boxity i) -- Build one specially
284 tupleCon Boxed i = snd (boxedTupleArr ! i)
285 tupleCon Unboxed i = snd (unboxedTupleArr ! i)
287 boxedTupleArr, unboxedTupleArr :: Array Int (TyCon,DataCon)
288 boxedTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple Boxed i | i <- [0..mAX_TUPLE_SIZE]]
289 unboxedTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple Unboxed i | i <- [0..mAX_TUPLE_SIZE]]
291 mk_tuple :: Boxity -> Int -> (TyCon,DataCon)
292 mk_tuple boxity arity = (tycon, tuple_con)
294 tycon = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con boxity gen_info
295 modu = mkTupleModule boxity arity
296 tc_name = mkWiredInName modu (mkTupleOcc tcName boxity arity) tc_uniq
297 (ATyCon tycon) BuiltInSyntax
298 tc_kind = mkArrowKinds (map tyVarKind tyvars) res_kind
299 res_kind | isBoxed boxity = liftedTypeKind
300 | otherwise = ubxTupleKind
302 tyvars | isBoxed boxity = take arity alphaTyVars
303 | otherwise = take arity openAlphaTyVars
305 tuple_con = pcDataCon dc_name tyvars tyvar_tys tycon
306 tyvar_tys = mkTyVarTys tyvars
307 dc_name = mkWiredInName modu (mkTupleOcc dataName boxity arity) dc_uniq
308 (ADataCon tuple_con) BuiltInSyntax
309 tc_uniq = mkTupleTyConUnique boxity arity
310 dc_uniq = mkTupleDataConUnique boxity arity
311 gen_info = True -- Tuples all have generics..
312 -- hmm: that's a *lot* of code
315 unitTyCon = tupleTyCon Boxed 0
316 unitDataCon :: DataCon
317 unitDataCon = head (tyConDataCons unitTyCon)
319 unitDataConId = dataConWorkId unitDataCon
322 pairTyCon = tupleTyCon Boxed 2
324 unboxedSingletonTyCon :: TyCon
325 unboxedSingletonTyCon = tupleTyCon Unboxed 1
326 unboxedSingletonDataCon :: DataCon
327 unboxedSingletonDataCon = tupleCon Unboxed 1
329 unboxedPairTyCon :: TyCon
330 unboxedPairTyCon = tupleTyCon Unboxed 2
331 unboxedPairDataCon :: DataCon
332 unboxedPairDataCon = tupleCon Unboxed 2
335 %************************************************************************
337 \subsection[TysWiredIn-boxed-prim]{The ``boxed primitive'' types (@Char@, @Int@, etc)}
339 %************************************************************************
343 charTy = mkTyConTy charTyCon
346 charTyCon = pcNonRecDataTyCon charTyConName [] [charDataCon]
347 charDataCon :: DataCon
348 charDataCon = pcDataCon charDataConName [] [charPrimTy] charTyCon
351 stringTy = mkListTy charTy -- convenience only
356 intTy = mkTyConTy intTyCon
359 intTyCon = pcNonRecDataTyCon intTyConName [] [intDataCon]
360 intDataCon :: DataCon
361 intDataCon = pcDataCon intDataConName [] [intPrimTy] intTyCon
366 wordTy = mkTyConTy wordTyCon
369 wordTyCon = pcNonRecDataTyCon wordTyConName [] [wordDataCon]
370 wordDataCon :: DataCon
371 wordDataCon = pcDataCon wordDataConName [] [wordPrimTy] wordTyCon
376 floatTy = mkTyConTy floatTyCon
379 floatTyCon = pcNonRecDataTyCon floatTyConName [] [floatDataCon]
380 floatDataCon :: DataCon
381 floatDataCon = pcDataCon floatDataConName [] [floatPrimTy] floatTyCon
386 doubleTy = mkTyConTy doubleTyCon
389 doubleTyCon = pcNonRecDataTyCon doubleTyConName [] [doubleDataCon]
391 doubleDataCon :: DataCon
392 doubleDataCon = pcDataCon doubleDataConName [] [doublePrimTy] doubleTyCon
396 %************************************************************************
398 \subsection[TysWiredIn-Bool]{The @Bool@ type}
400 %************************************************************************
402 An ordinary enumeration type, but deeply wired in. There are no
403 magical operations on @Bool@ (just the regular Prelude code).
405 {\em BEGIN IDLE SPECULATION BY SIMON}
407 This is not the only way to encode @Bool@. A more obvious coding makes
408 @Bool@ just a boxed up version of @Bool#@, like this:
411 data Bool = MkBool Bool#
414 Unfortunately, this doesn't correspond to what the Report says @Bool@
415 looks like! Furthermore, we get slightly less efficient code (I
416 think) with this coding. @gtInt@ would look like this:
419 gtInt :: Int -> Int -> Bool
420 gtInt x y = case x of I# x# ->
422 case (gtIntPrim x# y#) of
426 Notice that the result of the @gtIntPrim@ comparison has to be turned
427 into an integer (here called @b#@), and returned in a @MkBool@ box.
429 The @if@ expression would compile to this:
432 MkBool b# -> case b# of { 1# -> e1; 0# -> e2 }
435 I think this code is a little less efficient than the previous code,
436 but I'm not certain. At all events, corresponding with the Report is
437 important. The interesting thing is that the language is expressive
438 enough to describe more than one alternative; and that a type doesn't
439 necessarily need to be a straightforwardly boxed version of its
440 primitive counterpart.
442 {\em END IDLE SPECULATION BY SIMON}
446 boolTy = mkTyConTy boolTyCon
449 boolTyCon = pcTyCon True NonRecursive boolTyConName
450 [] [falseDataCon, trueDataCon]
452 falseDataCon, trueDataCon :: DataCon
453 falseDataCon = pcDataCon falseDataConName [] [] boolTyCon
454 trueDataCon = pcDataCon trueDataConName [] [] boolTyCon
456 falseDataConId, trueDataConId :: Id
457 falseDataConId = dataConWorkId falseDataCon
458 trueDataConId = dataConWorkId trueDataCon
461 %************************************************************************
463 \subsection[TysWiredIn-List]{The @List@ type (incl ``build'' magic)}
465 %************************************************************************
467 Special syntax, deeply wired in, but otherwise an ordinary algebraic
470 data [] a = [] | a : (List a)
472 data (,) a b = (,,) a b
477 mkListTy :: Type -> Type
478 mkListTy ty = mkTyConApp listTyCon [ty]
481 listTyCon = pcRecDataTyCon listTyConName alpha_tyvar [nilDataCon, consDataCon]
483 nilDataCon :: DataCon
484 nilDataCon = pcDataCon nilDataConName alpha_tyvar [] listTyCon
486 consDataCon :: DataCon
487 consDataCon = pcDataConWithFixity True {- Declared infix -}
489 alpha_tyvar [alphaTy, mkTyConApp listTyCon alpha_ty] listTyCon
490 -- Interesting: polymorphic recursion would help here.
491 -- We can't use (mkListTy alphaTy) in the defn of consDataCon, else mkListTy
492 -- gets the over-specific type (Type -> Type)
495 %************************************************************************
497 \subsection[TysWiredIn-Tuples]{The @Tuple@ types}
499 %************************************************************************
501 The tuple types are definitely magic, because they form an infinite
506 They have a special family of type constructors, of type @TyCon@
507 These contain the tycon arity, but don't require a Unique.
510 They have a special family of constructors, of type
511 @Id@. Again these contain their arity but don't need a Unique.
514 There should be a magic way of generating the info tables and
515 entry code for all tuples.
517 But at the moment we just compile a Haskell source
518 file\srcloc{lib/prelude/...} containing declarations like:
521 data Tuple2 a b = Tup2 a b
522 data Tuple3 a b c = Tup3 a b c
523 data Tuple4 a b c d = Tup4 a b c d
526 The print-names associated with the magic @Id@s for tuple constructors
527 ``just happen'' to be the same as those generated by these
531 The instance environment should have a magic way to know
532 that each tuple type is an instances of classes @Eq@, @Ix@, @Ord@ and
533 so on. \ToDo{Not implemented yet.}
536 There should also be a way to generate the appropriate code for each
537 of these instances, but (like the info tables and entry code) it is
538 done by enumeration\srcloc{lib/prelude/InTup?.hs}.
542 mkTupleTy :: Boxity -> Int -> [Type] -> Type
543 mkTupleTy boxity arity tys = mkTyConApp (tupleTyCon boxity arity) tys
546 unitTy = mkTupleTy Boxed 0 []
549 %************************************************************************
551 \subsection[TysWiredIn-PArr]{The @[::]@ type}
553 %************************************************************************
555 Special syntax for parallel arrays needs some wired in definitions.
558 -- | Construct a type representing the application of the parallel array constructor
559 mkPArrTy :: Type -> Type
560 mkPArrTy ty = mkTyConApp parrTyCon [ty]
562 -- | Represents the type constructor of parallel arrays
564 -- * This must match the definition in @PrelPArr@
566 -- NB: Although the constructor is given here, it will not be accessible in
567 -- user code as it is not in the environment of any compiled module except
571 parrTyCon = pcNonRecDataTyCon parrTyConName alpha_tyvar [parrDataCon]
573 parrDataCon :: DataCon
574 parrDataCon = pcDataCon
576 alpha_tyvar -- forall'ed type variables
577 [intPrimTy, -- 1st argument: Int#
578 mkTyConApp -- 2nd argument: Array# a
583 -- | Check whether a type constructor is the constructor for parallel arrays
584 isPArrTyCon :: TyCon -> Bool
585 isPArrTyCon tc = tyConName tc == parrTyConName
587 -- | Fake array constructors
589 -- * These constructors are never really used to represent array values;
590 -- however, they are very convenient during desugaring (and, in particular,
591 -- in the pattern matching compiler) to treat array pattern just like
592 -- yet another constructor pattern
594 parrFakeCon :: Arity -> DataCon
595 parrFakeCon i | i > mAX_TUPLE_SIZE = mkPArrFakeCon i -- build one specially
596 parrFakeCon i = parrFakeConArr!i
598 -- pre-defined set of constructors
600 parrFakeConArr :: Array Int DataCon
601 parrFakeConArr = array (0, mAX_TUPLE_SIZE) [(i, mkPArrFakeCon i)
602 | i <- [0..mAX_TUPLE_SIZE]]
604 -- build a fake parallel array constructor for the given arity
606 mkPArrFakeCon :: Int -> DataCon
607 mkPArrFakeCon arity = data_con
609 data_con = pcDataCon name [tyvar] tyvarTys parrTyCon
610 tyvar = head alphaTyVars
611 tyvarTys = replicate arity $ mkTyVarTy tyvar
612 nameStr = mkFastString ("MkPArr" ++ show arity)
613 name = mkWiredInName gHC_PARR (mkDataOccFS nameStr) unique
614 (ADataCon data_con) UserSyntax
615 unique = mkPArrDataConUnique arity
617 -- | Checks whether a data constructor is a fake constructor for parallel arrays
618 isPArrFakeCon :: DataCon -> Bool
619 isPArrFakeCon dcon = dcon == parrFakeCon (dataConSourceArity dcon)