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 )
72 import BasicTypes ( Arity, RecFlag(..), Boxity(..), isBoxed,
75 import Type ( Type, mkTyConTy, mkTyConApp, mkTyVarTy, mkTyVarTys,
77 import Coercion ( unsafeCoercionTyCon, symCoercionTyCon,
78 transCoercionTyCon, leftCoercionTyCon,
79 rightCoercionTyCon, instCoercionTyCon )
80 import TypeRep ( mkArrowKinds, liftedTypeKind, ubxTupleKind )
81 import Unique ( incrUnique, mkTupleTyConUnique,
82 mkTupleDataConUnique, mkPArrDataConUnique )
87 alpha_tyvar = [alphaTyVar]
92 %************************************************************************
94 \subsection{Wired in type constructors}
96 %************************************************************************
98 If you change which things are wired in, make sure you change their
99 names in PrelNames, so they use wTcQual, wDataQual, etc
102 wiredInTyCons :: [TyCon] -- Excludes tuples
103 -- This list is used only to define PrelInfo.wiredInThings
105 -- It does not need to include kind constructors, because
106 -- all that wiredInThings does is to initialise the Name table,
107 -- and kind constructors don't appear in source code.
109 wiredInTyCons = [ unitTyCon -- Not treated like other tuples, because
110 -- it's defined in GHC.Base, and there's only
111 -- one of it. We put it in wiredInTyCons so
112 -- that it'll pre-populate the name cache, so
113 -- the special case in lookupOrigNameCache
114 -- doesn't need to look out for it
122 , unsafeCoercionTyCon
132 mkWiredInTyConName :: BuiltInSyntax -> Module -> FastString -> Unique -> TyCon -> Name
133 mkWiredInTyConName built_in mod fs uniq tycon
134 = mkWiredInName mod (mkOccNameFS tcName fs) uniq
135 Nothing -- No parent object
136 (ATyCon tycon) -- Relevant TyCon
139 mkWiredInDataConName :: BuiltInSyntax -> Module -> FastString -> Unique -> DataCon -> Name -> Name
140 mkWiredInDataConName built_in mod fs uniq datacon parent
141 = mkWiredInName mod (mkOccNameFS dataName fs) uniq
142 (Just parent) -- Name of parent TyCon
143 (ADataCon datacon) -- Relevant DataCon
146 charTyConName = mkWiredInTyConName UserSyntax gHC_BASE FSLIT("Char") charTyConKey charTyCon
147 charDataConName = mkWiredInDataConName UserSyntax gHC_BASE FSLIT("C#") charDataConKey charDataCon charTyConName
148 intTyConName = mkWiredInTyConName UserSyntax gHC_BASE FSLIT("Int") intTyConKey intTyCon
149 intDataConName = mkWiredInDataConName UserSyntax gHC_BASE FSLIT("I#") intDataConKey intDataCon intTyConName
151 boolTyConName = mkWiredInTyConName UserSyntax gHC_BASE FSLIT("Bool") boolTyConKey boolTyCon
152 falseDataConName = mkWiredInDataConName UserSyntax gHC_BASE FSLIT("False") falseDataConKey falseDataCon boolTyConName
153 trueDataConName = mkWiredInDataConName UserSyntax gHC_BASE FSLIT("True") trueDataConKey trueDataCon boolTyConName
154 listTyConName = mkWiredInTyConName BuiltInSyntax gHC_BASE FSLIT("[]") listTyConKey listTyCon
155 nilDataConName = mkWiredInDataConName BuiltInSyntax gHC_BASE FSLIT("[]") nilDataConKey nilDataCon listTyConName
156 consDataConName = mkWiredInDataConName BuiltInSyntax gHC_BASE FSLIT(":") consDataConKey consDataCon listTyConName
158 floatTyConName = mkWiredInTyConName UserSyntax gHC_FLOAT FSLIT("Float") floatTyConKey floatTyCon
159 floatDataConName = mkWiredInDataConName UserSyntax gHC_FLOAT FSLIT("F#") floatDataConKey floatDataCon floatTyConName
160 doubleTyConName = mkWiredInTyConName UserSyntax gHC_FLOAT FSLIT("Double") doubleTyConKey doubleTyCon
161 doubleDataConName = mkWiredInDataConName UserSyntax gHC_FLOAT FSLIT("D#") doubleDataConKey doubleDataCon doubleTyConName
163 parrTyConName = mkWiredInTyConName BuiltInSyntax gHC_PARR FSLIT("[::]") parrTyConKey parrTyCon
164 parrDataConName = mkWiredInDataConName UserSyntax gHC_PARR FSLIT("PArr") parrDataConKey parrDataCon parrTyConName
166 boolTyCon_RDR = nameRdrName boolTyConName
167 false_RDR = nameRdrName falseDataConName
168 true_RDR = nameRdrName trueDataConName
169 intTyCon_RDR = nameRdrName intTyConName
170 charTyCon_RDR = nameRdrName charTyConName
171 intDataCon_RDR = nameRdrName intDataConName
172 listTyCon_RDR = nameRdrName listTyConName
173 consDataCon_RDR = nameRdrName consDataConName
174 parrTyCon_RDR = nameRdrName parrTyConName
176 tySuperKindTyCon_RDR = nameRdrName tySuperKindTyConName
177 coSuperKindTyCon_RDR = nameRdrName coSuperKindTyConName
178 liftedTypeKindTyCon_RDR = nameRdrName liftedTypeKindTyConName
179 openTypeKindTyCon_RDR = nameRdrName openTypeKindTyConName
180 unliftedTypeKindTyCon_RDR = nameRdrName unliftedTypeKindTyConName
181 ubxTupleKindTyCon_RDR = nameRdrName ubxTupleKindTyConName
182 argTypeKindTyCon_RDR = nameRdrName argTypeKindTyConName
183 funKindTyCon_RDR = nameRdrName funKindTyConName
188 %************************************************************************
190 \subsection{mkWiredInTyCon}
192 %************************************************************************
195 pcNonRecDataTyCon = pcTyCon False NonRecursive
196 pcRecDataTyCon = pcTyCon False Recursive
198 pcTyCon is_enum is_rec name tyvars cons
201 tycon = mkAlgTyCon name
202 (mkArrowKinds (map tyVarKind tyvars) liftedTypeKind)
204 [] -- No stupid theta
205 (DataTyCon cons is_enum)
206 [] -- No record selectors
208 True -- All the wired-in tycons have generics
209 False -- Not in GADT syntax
211 pcDataCon :: Name -> [TyVar] -> [Type] -> TyCon -> DataCon
212 pcDataCon = pcDataConWithFixity False
214 pcDataConWithFixity :: Bool -> Name -> [TyVar] -> [Type] -> TyCon -> DataCon
215 -- The Name should be in the DataName name space; it's the name
216 -- of the DataCon itself.
218 -- The unique is the first of two free uniques;
219 -- the first is used for the datacon itself,
220 -- the second is used for the "worker name"
222 pcDataConWithFixity declared_infix dc_name tyvars arg_tys tycon
225 data_con = mkDataCon dc_name declared_infix
226 (map (const NotMarkedStrict) arg_tys)
227 [] -- No labelled fields
229 [] -- No existential type variables
230 [] -- No equality spec
233 [] -- No stupid theta
234 (mkDataConIds bogus_wrap_name wrk_name data_con)
237 mod = nameModule dc_name
238 wrk_occ = mkDataConWorkerOcc (nameOccName dc_name)
239 wrk_key = incrUnique (nameUnique dc_name)
240 wrk_name = mkWiredInName mod wrk_occ wrk_key
241 (Just (tyConName tycon))
242 (AnId (dataConWorkId data_con)) UserSyntax
243 bogus_wrap_name = pprPanic "Wired-in data wrapper id" (ppr dc_name)
244 -- Wired-in types are too simple to need wrappers
248 %************************************************************************
250 \subsection[TysWiredIn-tuples]{The tuple types}
252 %************************************************************************
255 tupleTyCon :: Boxity -> Arity -> TyCon
256 tupleTyCon boxity i | i > mAX_TUPLE_SIZE = fst (mk_tuple boxity i) -- Build one specially
257 tupleTyCon Boxed i = fst (boxedTupleArr ! i)
258 tupleTyCon Unboxed i = fst (unboxedTupleArr ! i)
260 tupleCon :: Boxity -> Arity -> DataCon
261 tupleCon boxity i | i > mAX_TUPLE_SIZE = snd (mk_tuple boxity i) -- Build one specially
262 tupleCon Boxed i = snd (boxedTupleArr ! i)
263 tupleCon Unboxed i = snd (unboxedTupleArr ! i)
265 boxedTupleArr, unboxedTupleArr :: Array Int (TyCon,DataCon)
266 boxedTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple Boxed i | i <- [0..mAX_TUPLE_SIZE]]
267 unboxedTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple Unboxed i | i <- [0..mAX_TUPLE_SIZE]]
269 mk_tuple :: Boxity -> Int -> (TyCon,DataCon)
270 mk_tuple boxity arity = (tycon, tuple_con)
272 tycon = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con boxity gen_info
273 mod = mkTupleModule boxity arity
274 tc_name = mkWiredInName mod (mkTupleOcc tcName boxity arity) tc_uniq
275 Nothing (ATyCon tycon) BuiltInSyntax
276 tc_kind = mkArrowKinds (map tyVarKind tyvars) res_kind
277 res_kind | isBoxed boxity = liftedTypeKind
278 | otherwise = ubxTupleKind
280 tyvars | isBoxed boxity = take arity alphaTyVars
281 | otherwise = take arity openAlphaTyVars
283 tuple_con = pcDataCon dc_name tyvars tyvar_tys tycon
284 tyvar_tys = mkTyVarTys tyvars
285 dc_name = mkWiredInName mod (mkTupleOcc dataName boxity arity) dc_uniq
286 (Just tc_name) (ADataCon tuple_con) BuiltInSyntax
287 tc_uniq = mkTupleTyConUnique boxity arity
288 dc_uniq = mkTupleDataConUnique boxity arity
289 gen_info = True -- Tuples all have generics..
290 -- hmm: that's a *lot* of code
292 unitTyCon = tupleTyCon Boxed 0
293 unitDataCon = head (tyConDataCons unitTyCon)
294 unitDataConId = dataConWorkId unitDataCon
296 pairTyCon = tupleTyCon Boxed 2
298 unboxedSingletonTyCon = tupleTyCon Unboxed 1
299 unboxedSingletonDataCon = tupleCon Unboxed 1
301 unboxedPairTyCon = tupleTyCon Unboxed 2
302 unboxedPairDataCon = tupleCon Unboxed 2
305 %************************************************************************
307 \subsection[TysWiredIn-boxed-prim]{The ``boxed primitive'' types (@Char@, @Int@, etc)}
309 %************************************************************************
312 -- The Void type is represented as a data type with no constructors
313 -- It's a built in type (i.e. there's no way to define it in Haskell;
314 -- the nearest would be
316 -- data Void = -- No constructors!
318 -- ) It's lifted; there is only one value of this
319 -- type, namely "void", whose semantics is just bottom.
321 -- Haskell 98 drops the definition of a Void type, so we just 'simulate'
328 charTy = mkTyConTy charTyCon
330 charTyCon = pcNonRecDataTyCon charTyConName [] [charDataCon]
331 charDataCon = pcDataCon charDataConName [] [charPrimTy] charTyCon
333 stringTy = mkListTy charTy -- convenience only
337 intTy = mkTyConTy intTyCon
339 intTyCon = pcNonRecDataTyCon intTyConName [] [intDataCon]
340 intDataCon = pcDataCon intDataConName [] [intPrimTy] intTyCon
344 floatTy = mkTyConTy floatTyCon
346 floatTyCon = pcNonRecDataTyCon floatTyConName [] [floatDataCon]
347 floatDataCon = pcDataCon floatDataConName [] [floatPrimTy] floatTyCon
351 doubleTy = mkTyConTy doubleTyCon
353 doubleTyCon = pcNonRecDataTyCon doubleTyConName [] [doubleDataCon]
354 doubleDataCon = pcDataCon doubleDataConName [] [doublePrimTy] doubleTyCon
358 %************************************************************************
360 \subsection[TysWiredIn-Bool]{The @Bool@ type}
362 %************************************************************************
364 An ordinary enumeration type, but deeply wired in. There are no
365 magical operations on @Bool@ (just the regular Prelude code).
367 {\em BEGIN IDLE SPECULATION BY SIMON}
369 This is not the only way to encode @Bool@. A more obvious coding makes
370 @Bool@ just a boxed up version of @Bool#@, like this:
373 data Bool = MkBool Bool#
376 Unfortunately, this doesn't correspond to what the Report says @Bool@
377 looks like! Furthermore, we get slightly less efficient code (I
378 think) with this coding. @gtInt@ would look like this:
381 gtInt :: Int -> Int -> Bool
382 gtInt x y = case x of I# x# ->
384 case (gtIntPrim x# y#) of
388 Notice that the result of the @gtIntPrim@ comparison has to be turned
389 into an integer (here called @b#@), and returned in a @MkBool@ box.
391 The @if@ expression would compile to this:
394 MkBool b# -> case b# of { 1# -> e1; 0# -> e2 }
397 I think this code is a little less efficient than the previous code,
398 but I'm not certain. At all events, corresponding with the Report is
399 important. The interesting thing is that the language is expressive
400 enough to describe more than one alternative; and that a type doesn't
401 necessarily need to be a straightforwardly boxed version of its
402 primitive counterpart.
404 {\em END IDLE SPECULATION BY SIMON}
407 boolTy = mkTyConTy boolTyCon
409 boolTyCon = pcTyCon True NonRecursive boolTyConName
410 [] [falseDataCon, trueDataCon]
412 falseDataCon = pcDataCon falseDataConName [] [] boolTyCon
413 trueDataCon = pcDataCon trueDataConName [] [] boolTyCon
415 falseDataConId = dataConWorkId falseDataCon
416 trueDataConId = dataConWorkId trueDataCon
419 %************************************************************************
421 \subsection[TysWiredIn-List]{The @List@ type (incl ``build'' magic)}
423 %************************************************************************
425 Special syntax, deeply wired in, but otherwise an ordinary algebraic
428 data [] a = [] | a : (List a)
430 data (,) a b = (,,) a b
435 mkListTy :: Type -> Type
436 mkListTy ty = mkTyConApp listTyCon [ty]
438 listTyCon = pcRecDataTyCon listTyConName alpha_tyvar [nilDataCon, consDataCon]
440 nilDataCon = pcDataCon nilDataConName alpha_tyvar [] listTyCon
441 consDataCon = pcDataConWithFixity True {- Declared infix -}
443 alpha_tyvar [alphaTy, mkTyConApp listTyCon alpha_ty] listTyCon
444 -- Interesting: polymorphic recursion would help here.
445 -- We can't use (mkListTy alphaTy) in the defn of consDataCon, else mkListTy
446 -- gets the over-specific type (Type -> Type)
449 %************************************************************************
451 \subsection[TysWiredIn-Tuples]{The @Tuple@ types}
453 %************************************************************************
455 The tuple types are definitely magic, because they form an infinite
460 They have a special family of type constructors, of type @TyCon@
461 These contain the tycon arity, but don't require a Unique.
464 They have a special family of constructors, of type
465 @Id@. Again these contain their arity but don't need a Unique.
468 There should be a magic way of generating the info tables and
469 entry code for all tuples.
471 But at the moment we just compile a Haskell source
472 file\srcloc{lib/prelude/...} containing declarations like:
475 data Tuple2 a b = Tup2 a b
476 data Tuple3 a b c = Tup3 a b c
477 data Tuple4 a b c d = Tup4 a b c d
480 The print-names associated with the magic @Id@s for tuple constructors
481 ``just happen'' to be the same as those generated by these
485 The instance environment should have a magic way to know
486 that each tuple type is an instances of classes @Eq@, @Ix@, @Ord@ and
487 so on. \ToDo{Not implemented yet.}
490 There should also be a way to generate the appropriate code for each
491 of these instances, but (like the info tables and entry code) it is
492 done by enumeration\srcloc{lib/prelude/InTup?.hs}.
496 mkTupleTy :: Boxity -> Int -> [Type] -> Type
497 mkTupleTy boxity arity tys = mkTyConApp (tupleTyCon boxity arity) tys
499 unitTy = mkTupleTy Boxed 0 []
502 %************************************************************************
504 \subsection[TysWiredIn-PArr]{The @[::]@ type}
506 %************************************************************************
508 Special syntax for parallel arrays needs some wired in definitions.
511 -- construct a type representing the application of the parallel array
514 mkPArrTy :: Type -> Type
515 mkPArrTy ty = mkTyConApp parrTyCon [ty]
517 -- represents the type constructor of parallel arrays
519 -- * this must match the definition in `PrelPArr'
521 -- NB: Although the constructor is given here, it will not be accessible in
522 -- user code as it is not in the environment of any compiled module except
526 parrTyCon = pcNonRecDataTyCon parrTyConName alpha_tyvar [parrDataCon]
528 parrDataCon :: DataCon
529 parrDataCon = pcDataCon
531 alpha_tyvar -- forall'ed type variables
532 [intPrimTy, -- 1st argument: Int#
533 mkTyConApp -- 2nd argument: Array# a
538 -- check whether a type constructor is the constructor for parallel arrays
540 isPArrTyCon :: TyCon -> Bool
541 isPArrTyCon tc = tyConName tc == parrTyConName
543 -- fake array constructors
545 -- * these constructors are never really used to represent array values;
546 -- however, they are very convenient during desugaring (and, in particular,
547 -- in the pattern matching compiler) to treat array pattern just like
548 -- yet another constructor pattern
550 parrFakeCon :: Arity -> DataCon
551 parrFakeCon i | i > mAX_TUPLE_SIZE = mkPArrFakeCon i -- build one specially
552 parrFakeCon i = parrFakeConArr!i
554 -- pre-defined set of constructors
556 parrFakeConArr :: Array Int DataCon
557 parrFakeConArr = array (0, mAX_TUPLE_SIZE) [(i, mkPArrFakeCon i)
558 | i <- [0..mAX_TUPLE_SIZE]]
560 -- build a fake parallel array constructor for the given arity
562 mkPArrFakeCon :: Int -> DataCon
563 mkPArrFakeCon arity = data_con
565 data_con = pcDataCon name [tyvar] tyvarTys parrTyCon
566 tyvar = head alphaTyVars
567 tyvarTys = replicate arity $ mkTyVarTy tyvar
568 nameStr = mkFastString ("MkPArr" ++ show arity)
569 name = mkWiredInName gHC_PARR (mkOccNameFS dataName nameStr) uniq
570 Nothing (ADataCon data_con) UserSyntax
571 uniq = mkPArrDataConUnique arity
573 -- checks whether a data constructor is a fake constructor for parallel arrays
575 isPArrFakeCon :: DataCon -> Bool
576 isPArrFakeCon dcon = dcon == parrFakeCon (dataConSourceArity dcon)