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
254 [] -- No stupid theta
255 (mkDataConIds bogus_wrap_name wrk_name data_con)
258 modu = ASSERT( isExternalName dc_name )
260 wrk_occ = mkDataConWorkerOcc (nameOccName dc_name)
261 wrk_key = incrUnique (nameUnique dc_name)
262 wrk_name = mkWiredInName modu wrk_occ wrk_key
263 (AnId (dataConWorkId data_con)) UserSyntax
264 bogus_wrap_name = pprPanic "Wired-in data wrapper id" (ppr dc_name)
265 -- Wired-in types are too simple to need wrappers
269 %************************************************************************
271 \subsection[TysWiredIn-tuples]{The tuple types}
273 %************************************************************************
276 tupleTyCon :: Boxity -> Arity -> TyCon
277 tupleTyCon boxity i | i > mAX_TUPLE_SIZE = fst (mk_tuple boxity i) -- Build one specially
278 tupleTyCon Boxed i = fst (boxedTupleArr ! i)
279 tupleTyCon Unboxed i = fst (unboxedTupleArr ! i)
281 tupleCon :: Boxity -> Arity -> DataCon
282 tupleCon boxity i | i > mAX_TUPLE_SIZE = snd (mk_tuple boxity i) -- Build one specially
283 tupleCon Boxed i = snd (boxedTupleArr ! i)
284 tupleCon Unboxed i = snd (unboxedTupleArr ! i)
286 boxedTupleArr, unboxedTupleArr :: Array Int (TyCon,DataCon)
287 boxedTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple Boxed i | i <- [0..mAX_TUPLE_SIZE]]
288 unboxedTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple Unboxed i | i <- [0..mAX_TUPLE_SIZE]]
290 mk_tuple :: Boxity -> Int -> (TyCon,DataCon)
291 mk_tuple boxity arity = (tycon, tuple_con)
293 tycon = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con boxity gen_info
294 modu = mkTupleModule boxity arity
295 tc_name = mkWiredInName modu (mkTupleOcc tcName boxity arity) tc_uniq
296 (ATyCon tycon) BuiltInSyntax
297 tc_kind = mkArrowKinds (map tyVarKind tyvars) res_kind
298 res_kind | isBoxed boxity = liftedTypeKind
299 | otherwise = ubxTupleKind
301 tyvars | isBoxed boxity = take arity alphaTyVars
302 | otherwise = take arity openAlphaTyVars
304 tuple_con = pcDataCon dc_name tyvars tyvar_tys tycon
305 tyvar_tys = mkTyVarTys tyvars
306 dc_name = mkWiredInName modu (mkTupleOcc dataName boxity arity) dc_uniq
307 (ADataCon tuple_con) BuiltInSyntax
308 tc_uniq = mkTupleTyConUnique boxity arity
309 dc_uniq = mkTupleDataConUnique boxity arity
310 gen_info = True -- Tuples all have generics..
311 -- hmm: that's a *lot* of code
314 unitTyCon = tupleTyCon Boxed 0
315 unitDataCon :: DataCon
316 unitDataCon = head (tyConDataCons unitTyCon)
318 unitDataConId = dataConWorkId unitDataCon
321 pairTyCon = tupleTyCon Boxed 2
323 unboxedSingletonTyCon :: TyCon
324 unboxedSingletonTyCon = tupleTyCon Unboxed 1
325 unboxedSingletonDataCon :: DataCon
326 unboxedSingletonDataCon = tupleCon Unboxed 1
328 unboxedPairTyCon :: TyCon
329 unboxedPairTyCon = tupleTyCon Unboxed 2
330 unboxedPairDataCon :: DataCon
331 unboxedPairDataCon = tupleCon Unboxed 2
334 %************************************************************************
336 \subsection[TysWiredIn-boxed-prim]{The ``boxed primitive'' types (@Char@, @Int@, etc)}
338 %************************************************************************
342 charTy = mkTyConTy charTyCon
345 charTyCon = pcNonRecDataTyCon charTyConName [] [charDataCon]
346 charDataCon :: DataCon
347 charDataCon = pcDataCon charDataConName [] [charPrimTy] charTyCon
350 stringTy = mkListTy charTy -- convenience only
355 intTy = mkTyConTy intTyCon
358 intTyCon = pcNonRecDataTyCon intTyConName [] [intDataCon]
359 intDataCon :: DataCon
360 intDataCon = pcDataCon intDataConName [] [intPrimTy] intTyCon
365 wordTy = mkTyConTy wordTyCon
368 wordTyCon = pcNonRecDataTyCon wordTyConName [] [wordDataCon]
369 wordDataCon :: DataCon
370 wordDataCon = pcDataCon wordDataConName [] [wordPrimTy] wordTyCon
375 floatTy = mkTyConTy floatTyCon
378 floatTyCon = pcNonRecDataTyCon floatTyConName [] [floatDataCon]
379 floatDataCon :: DataCon
380 floatDataCon = pcDataCon floatDataConName [] [floatPrimTy] floatTyCon
385 doubleTy = mkTyConTy doubleTyCon
388 doubleTyCon = pcNonRecDataTyCon doubleTyConName [] [doubleDataCon]
390 doubleDataCon :: DataCon
391 doubleDataCon = pcDataCon doubleDataConName [] [doublePrimTy] doubleTyCon
395 %************************************************************************
397 \subsection[TysWiredIn-Bool]{The @Bool@ type}
399 %************************************************************************
401 An ordinary enumeration type, but deeply wired in. There are no
402 magical operations on @Bool@ (just the regular Prelude code).
404 {\em BEGIN IDLE SPECULATION BY SIMON}
406 This is not the only way to encode @Bool@. A more obvious coding makes
407 @Bool@ just a boxed up version of @Bool#@, like this:
410 data Bool = MkBool Bool#
413 Unfortunately, this doesn't correspond to what the Report says @Bool@
414 looks like! Furthermore, we get slightly less efficient code (I
415 think) with this coding. @gtInt@ would look like this:
418 gtInt :: Int -> Int -> Bool
419 gtInt x y = case x of I# x# ->
421 case (gtIntPrim x# y#) of
425 Notice that the result of the @gtIntPrim@ comparison has to be turned
426 into an integer (here called @b#@), and returned in a @MkBool@ box.
428 The @if@ expression would compile to this:
431 MkBool b# -> case b# of { 1# -> e1; 0# -> e2 }
434 I think this code is a little less efficient than the previous code,
435 but I'm not certain. At all events, corresponding with the Report is
436 important. The interesting thing is that the language is expressive
437 enough to describe more than one alternative; and that a type doesn't
438 necessarily need to be a straightforwardly boxed version of its
439 primitive counterpart.
441 {\em END IDLE SPECULATION BY SIMON}
445 boolTy = mkTyConTy boolTyCon
448 boolTyCon = pcTyCon True NonRecursive boolTyConName
449 [] [falseDataCon, trueDataCon]
451 falseDataCon, trueDataCon :: DataCon
452 falseDataCon = pcDataCon falseDataConName [] [] boolTyCon
453 trueDataCon = pcDataCon trueDataConName [] [] boolTyCon
455 falseDataConId, trueDataConId :: Id
456 falseDataConId = dataConWorkId falseDataCon
457 trueDataConId = dataConWorkId trueDataCon
460 %************************************************************************
462 \subsection[TysWiredIn-List]{The @List@ type (incl ``build'' magic)}
464 %************************************************************************
466 Special syntax, deeply wired in, but otherwise an ordinary algebraic
469 data [] a = [] | a : (List a)
471 data (,) a b = (,,) a b
476 mkListTy :: Type -> Type
477 mkListTy ty = mkTyConApp listTyCon [ty]
480 listTyCon = pcRecDataTyCon listTyConName alpha_tyvar [nilDataCon, consDataCon]
482 nilDataCon :: DataCon
483 nilDataCon = pcDataCon nilDataConName alpha_tyvar [] listTyCon
485 consDataCon :: DataCon
486 consDataCon = pcDataConWithFixity True {- Declared infix -}
488 alpha_tyvar [alphaTy, mkTyConApp listTyCon alpha_ty] listTyCon
489 -- Interesting: polymorphic recursion would help here.
490 -- We can't use (mkListTy alphaTy) in the defn of consDataCon, else mkListTy
491 -- gets the over-specific type (Type -> Type)
494 %************************************************************************
496 \subsection[TysWiredIn-Tuples]{The @Tuple@ types}
498 %************************************************************************
500 The tuple types are definitely magic, because they form an infinite
505 They have a special family of type constructors, of type @TyCon@
506 These contain the tycon arity, but don't require a Unique.
509 They have a special family of constructors, of type
510 @Id@. Again these contain their arity but don't need a Unique.
513 There should be a magic way of generating the info tables and
514 entry code for all tuples.
516 But at the moment we just compile a Haskell source
517 file\srcloc{lib/prelude/...} containing declarations like:
520 data Tuple2 a b = Tup2 a b
521 data Tuple3 a b c = Tup3 a b c
522 data Tuple4 a b c d = Tup4 a b c d
525 The print-names associated with the magic @Id@s for tuple constructors
526 ``just happen'' to be the same as those generated by these
530 The instance environment should have a magic way to know
531 that each tuple type is an instances of classes @Eq@, @Ix@, @Ord@ and
532 so on. \ToDo{Not implemented yet.}
535 There should also be a way to generate the appropriate code for each
536 of these instances, but (like the info tables and entry code) it is
537 done by enumeration\srcloc{lib/prelude/InTup?.hs}.
541 mkTupleTy :: Boxity -> Int -> [Type] -> Type
542 mkTupleTy boxity arity tys = mkTyConApp (tupleTyCon boxity arity) tys
545 unitTy = mkTupleTy Boxed 0 []
548 %************************************************************************
550 \subsection[TysWiredIn-PArr]{The @[::]@ type}
552 %************************************************************************
554 Special syntax for parallel arrays needs some wired in definitions.
557 -- | Construct a type representing the application of the parallel array constructor
558 mkPArrTy :: Type -> Type
559 mkPArrTy ty = mkTyConApp parrTyCon [ty]
561 -- | Represents the type constructor of parallel arrays
563 -- * This must match the definition in @PrelPArr@
565 -- NB: Although the constructor is given here, it will not be accessible in
566 -- user code as it is not in the environment of any compiled module except
570 parrTyCon = pcNonRecDataTyCon parrTyConName alpha_tyvar [parrDataCon]
572 parrDataCon :: DataCon
573 parrDataCon = pcDataCon
575 alpha_tyvar -- forall'ed type variables
576 [intPrimTy, -- 1st argument: Int#
577 mkTyConApp -- 2nd argument: Array# a
582 -- | Check whether a type constructor is the constructor for parallel arrays
583 isPArrTyCon :: TyCon -> Bool
584 isPArrTyCon tc = tyConName tc == parrTyConName
586 -- | Fake array constructors
588 -- * These constructors are never really used to represent array values;
589 -- however, they are very convenient during desugaring (and, in particular,
590 -- in the pattern matching compiler) to treat array pattern just like
591 -- yet another constructor pattern
593 parrFakeCon :: Arity -> DataCon
594 parrFakeCon i | i > mAX_TUPLE_SIZE = mkPArrFakeCon i -- build one specially
595 parrFakeCon i = parrFakeConArr!i
597 -- pre-defined set of constructors
599 parrFakeConArr :: Array Int DataCon
600 parrFakeConArr = array (0, mAX_TUPLE_SIZE) [(i, mkPArrFakeCon i)
601 | i <- [0..mAX_TUPLE_SIZE]]
603 -- build a fake parallel array constructor for the given arity
605 mkPArrFakeCon :: Int -> DataCon
606 mkPArrFakeCon arity = data_con
608 data_con = pcDataCon name [tyvar] tyvarTys parrTyCon
609 tyvar = head alphaTyVars
610 tyvarTys = replicate arity $ mkTyVarTy tyvar
611 nameStr = mkFastString ("MkPArr" ++ show arity)
612 name = mkWiredInName gHC_PARR (mkDataOccFS nameStr) unique
613 (ADataCon data_con) UserSyntax
614 unique = mkPArrDataConUnique arity
616 -- | Checks whether a data constructor is a fake constructor for parallel arrays
617 isPArrFakeCon :: DataCon -> Bool
618 isPArrFakeCon dcon = dcon == parrFakeCon (dataConSourceArity dcon)