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.''
14 wiredInTyCons, genericTyCons,
34 falseDataCon, falseDataConId,
56 unitTyCon, unitDataConId, pairTyCon,
57 unboxedSingletonTyCon, unboxedSingletonDataCon,
58 unboxedPairTyCon, unboxedPairDataCon,
61 genUnitTyCon, genUnitDataCon,
62 plusTyCon, inrDataCon, inlDataCon,
63 crossTyCon, crossDataCon,
67 trueDataCon, trueDataConId,
76 parrTyCon, parrFakeCon, isPArrTyCon, isPArrFakeCon
79 #include "HsVersions.h"
81 import {-# SOURCE #-} MkId( mkDataConId, mkDataConWrapId )
82 import {-# SOURCE #-} Generics( mkTyConGenInfo )
89 import Constants ( mAX_TUPLE_SIZE )
90 import Module ( mkPrelModule )
91 import Name ( Name, nameRdrName, nameUnique, nameOccName,
92 nameModule, mkWiredInName )
93 import OccName ( mkOccFS, tcName, dataName, mkWorkerOcc, mkGenOcc1, mkGenOcc2 )
94 import RdrName ( rdrNameOcc )
95 import DataCon ( DataCon, mkDataCon, dataConId, dataConSourceArity )
96 import Var ( TyVar, tyVarKind )
97 import TyCon ( TyCon, AlgTyConFlavour(..), DataConDetails(..), tyConDataCons,
98 mkTupleTyCon, mkAlgTyCon, tyConName
101 import BasicTypes ( Arity, RecFlag(..), Boxity(..), isBoxed, StrictnessMark(..) )
103 import Type ( Type, mkTyConTy, mkTyConApp, mkTyVarTy, mkTyVarTys,
104 mkArrowKinds, liftedTypeKind, unliftedTypeKind,
106 import Unique ( incrUnique, mkTupleTyConUnique,
107 mkTupleDataConUnique, mkPArrDataConUnique )
111 alpha_tyvar = [alphaTyVar]
113 alpha_beta_tyvars = [alphaTyVar, betaTyVar]
117 %************************************************************************
119 \subsection{Wired in type constructors}
121 %************************************************************************
124 wiredInTyCons :: [TyCon]
125 wiredInTyCons = data_tycons ++ tuple_tycons ++ unboxed_tuple_tycons
127 data_tycons = genericTyCons ++
142 genericTyCons :: [TyCon]
143 genericTyCons = [ plusTyCon, crossTyCon, genUnitTyCon ]
146 tuple_tycons = unitTyCon : [tupleTyCon Boxed i | i <- [2..mAX_TUPLE_SIZE] ]
147 unboxed_tuple_tycons = [tupleTyCon Unboxed i | i <- [1..mAX_TUPLE_SIZE] ]
151 %************************************************************************
153 \subsection{mkWiredInTyCon}
155 %************************************************************************
158 pcNonRecDataTyCon = pcTyCon DataTyCon NonRecursive
159 pcRecDataTyCon = pcTyCon DataTyCon Recursive
161 pcTyCon new_or_data is_rec name tyvars argvrcs cons
164 tycon = mkAlgTyCon name kind
169 [] -- No record selectors
174 mod = nameModule name
175 kind = mkArrowKinds (map tyVarKind tyvars) liftedTypeKind
176 gen_info = mk_tc_gen_info mod (nameUnique name) name tycon
178 -- We generate names for the generic to/from Ids by incrementing
179 -- the TyCon unique. So each Prelude tycon needs 3 slots, one
180 -- for itself and two more for the generic Ids.
181 mk_tc_gen_info mod tc_uniq tc_name tycon
182 = mkTyConGenInfo tycon [name1, name2]
184 tc_occ_name = nameOccName tc_name
185 occ_name1 = mkGenOcc1 tc_occ_name
186 occ_name2 = mkGenOcc2 tc_occ_name
187 fn1_key = incrUnique tc_uniq
188 fn2_key = incrUnique fn1_key
189 name1 = mkWiredInName mod occ_name1 fn1_key
190 name2 = mkWiredInName mod occ_name2 fn2_key
192 pcDataCon :: Name -> [TyVar] -> ThetaType -> [Type] -> TyCon -> DataCon
193 -- The unique is the first of two free uniques;
194 -- the first is used for the datacon itself and the worker;
195 -- the second is used for the wrapper.
197 pcDataCon name tyvars context arg_tys tycon
200 data_con = mkDataCon name
201 [ NotMarkedStrict | a <- arg_tys ]
202 [ {- no labelled fields -} ]
203 tyvars context [] [] arg_tys tycon work_id wrap_id
205 wrap_rdr = nameRdrName name
206 wrap_occ = rdrNameOcc wrap_rdr
208 mod = nameModule name
209 wrap_id = mkDataConWrapId data_con
211 work_occ = mkWorkerOcc wrap_occ
212 work_key = incrUnique (nameUnique name)
213 work_name = mkWiredInName mod work_occ work_key
214 work_id = mkDataConId work_name data_con
218 %************************************************************************
220 \subsection[TysWiredIn-tuples]{The tuple types}
222 %************************************************************************
225 tupleTyCon :: Boxity -> Arity -> TyCon
226 tupleTyCon boxity i | i > mAX_TUPLE_SIZE = fst (mk_tuple boxity i) -- Build one specially
227 tupleTyCon Boxed i = fst (boxedTupleArr ! i)
228 tupleTyCon Unboxed i = fst (unboxedTupleArr ! i)
230 tupleCon :: Boxity -> Arity -> DataCon
231 tupleCon boxity i | i > mAX_TUPLE_SIZE = snd (mk_tuple boxity i) -- Build one specially
232 tupleCon Boxed i = snd (boxedTupleArr ! i)
233 tupleCon Unboxed i = snd (unboxedTupleArr ! i)
235 boxedTupleArr, unboxedTupleArr :: Array Int (TyCon,DataCon)
236 boxedTupleArr = array (0,mAX_TUPLE_SIZE) [(i,mk_tuple Boxed i) | i <- [0..mAX_TUPLE_SIZE]]
237 unboxedTupleArr = array (0,mAX_TUPLE_SIZE) [(i,mk_tuple Unboxed i) | i <- [0..mAX_TUPLE_SIZE]]
239 mk_tuple :: Boxity -> Int -> (TyCon,DataCon)
240 mk_tuple boxity arity = (tycon, tuple_con)
242 tycon = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con boxity gen_info
243 tc_name = mkWiredInName mod (mkOccFS tcName name_str) tc_uniq
244 tc_kind = mkArrowKinds (map tyVarKind tyvars) res_kind
245 res_kind | isBoxed boxity = liftedTypeKind
246 | otherwise = unliftedTypeKind
248 tyvars | isBoxed boxity = take arity alphaTyVars
249 | otherwise = take arity openAlphaTyVars
251 tuple_con = pcDataCon name tyvars [] tyvar_tys tycon
252 tyvar_tys = mkTyVarTys tyvars
253 (mod_name, name_str) = mkTupNameStr boxity arity
254 name = mkWiredInName mod (mkOccFS dataName name_str) dc_uniq
255 tc_uniq = mkTupleTyConUnique boxity arity
256 dc_uniq = mkTupleDataConUnique boxity arity
257 mod = mkPrelModule mod_name
258 gen_info = mk_tc_gen_info mod tc_uniq tc_name tycon
260 unitTyCon = tupleTyCon Boxed 0
261 unitDataConId = dataConId (head (tyConDataCons unitTyCon))
263 pairTyCon = tupleTyCon Boxed 2
265 unboxedSingletonTyCon = tupleTyCon Unboxed 1
266 unboxedSingletonDataCon = tupleCon Unboxed 1
268 unboxedPairTyCon = tupleTyCon Unboxed 2
269 unboxedPairDataCon = tupleCon Unboxed 2
272 %************************************************************************
274 \subsection[TysWiredIn-boxed-prim]{The ``boxed primitive'' types (@Char@, @Int@, etc)}
276 %************************************************************************
279 -- The Void type is represented as a data type with no constructors
280 -- It's a built in type (i.e. there's no way to define it in Haskell;
281 -- the nearest would be
283 -- data Void = -- No constructors!
285 -- ) It's lifted; there is only one value of this
286 -- type, namely "void", whose semantics is just bottom.
288 -- Haskell 98 drops the definition of a Void type, so we just 'simulate'
295 charTy = mkTyConTy charTyCon
297 charTyCon = pcNonRecDataTyCon charTyConName [] [] [charDataCon]
298 charDataCon = pcDataCon charDataConName [] [] [charPrimTy] charTyCon
300 stringTy = mkListTy charTy -- convenience only
304 intTy = mkTyConTy intTyCon
306 intTyCon = pcNonRecDataTyCon intTyConName [] [] [intDataCon]
307 intDataCon = pcDataCon intDataConName [] [] [intPrimTy] intTyCon
311 wordTy = mkTyConTy wordTyCon
313 wordTyCon = pcNonRecDataTyCon wordTyConName [] [] [wordDataCon]
314 wordDataCon = pcDataCon wordDataConName [] [] [wordPrimTy] wordTyCon
318 addrTy = mkTyConTy addrTyCon
320 addrTyCon = pcNonRecDataTyCon addrTyConName [] [] [addrDataCon]
321 addrDataCon = pcDataCon addrDataConName [] [] [addrPrimTy] addrTyCon
325 ptrTy = mkTyConTy ptrTyCon
327 ptrTyCon = pcNonRecDataTyCon ptrTyConName alpha_tyvar [(True,False)] [ptrDataCon]
328 ptrDataCon = pcDataCon ptrDataConName alpha_tyvar [] [addrPrimTy] ptrTyCon
332 funPtrTy = mkTyConTy funPtrTyCon
334 funPtrTyCon = pcNonRecDataTyCon funPtrTyConName alpha_tyvar [(True,False)] [funPtrDataCon]
335 funPtrDataCon = pcDataCon funPtrDataConName alpha_tyvar [] [addrPrimTy] funPtrTyCon
339 floatTy = mkTyConTy floatTyCon
341 floatTyCon = pcNonRecDataTyCon floatTyConName [] [] [floatDataCon]
342 floatDataCon = pcDataCon floatDataConName [] [] [floatPrimTy] floatTyCon
346 doubleTy = mkTyConTy doubleTyCon
348 doubleTyCon = pcNonRecDataTyCon doubleTyConName [] [] [doubleDataCon]
349 doubleDataCon = pcDataCon doubleDataConName [] [] [doublePrimTy] doubleTyCon
354 = pcNonRecDataTyCon stablePtrTyConName
355 alpha_tyvar [(True,False)] [stablePtrDataCon]
358 = pcDataCon stablePtrDataConName
359 alpha_tyvar [] [mkStablePtrPrimTy alphaTy] stablePtrTyCon
364 = pcNonRecDataTyCon foreignObjTyConName
365 [] [] [foreignObjDataCon]
368 = pcDataCon foreignObjDataConName
369 [] [] [foreignObjPrimTy] foreignObjTyCon
374 = pcNonRecDataTyCon foreignPtrTyConName
375 alpha_tyvar [(True,False)] [foreignPtrDataCon]
378 = pcDataCon foreignPtrDataConName
379 alpha_tyvar [] [foreignObjPrimTy] foreignPtrTyCon
382 %************************************************************************
384 \subsection[TysWiredIn-Integer]{@Integer@ and its related ``pairing'' types}
386 %************************************************************************
388 @Integer@ and its pals are not really primitive. @Integer@ itself, first:
391 integerTy = mkTyConTy integerTyCon
393 integerTyCon = pcNonRecDataTyCon integerTyConName
394 [] [] [smallIntegerDataCon, largeIntegerDataCon]
396 smallIntegerDataCon = pcDataCon smallIntegerDataConName
397 [] [] [intPrimTy] integerTyCon
398 largeIntegerDataCon = pcDataCon largeIntegerDataConName
399 [] [] [intPrimTy, byteArrayPrimTy] integerTyCon
403 %************************************************************************
405 \subsection[TysWiredIn-Bool]{The @Bool@ type}
407 %************************************************************************
409 An ordinary enumeration type, but deeply wired in. There are no
410 magical operations on @Bool@ (just the regular Prelude code).
412 {\em BEGIN IDLE SPECULATION BY SIMON}
414 This is not the only way to encode @Bool@. A more obvious coding makes
415 @Bool@ just a boxed up version of @Bool#@, like this:
418 data Bool = MkBool Bool#
421 Unfortunately, this doesn't correspond to what the Report says @Bool@
422 looks like! Furthermore, we get slightly less efficient code (I
423 think) with this coding. @gtInt@ would look like this:
426 gtInt :: Int -> Int -> Bool
427 gtInt x y = case x of I# x# ->
429 case (gtIntPrim x# y#) of
433 Notice that the result of the @gtIntPrim@ comparison has to be turned
434 into an integer (here called @b#@), and returned in a @MkBool@ box.
436 The @if@ expression would compile to this:
439 MkBool b# -> case b# of { 1# -> e1; 0# -> e2 }
442 I think this code is a little less efficient than the previous code,
443 but I'm not certain. At all events, corresponding with the Report is
444 important. The interesting thing is that the language is expressive
445 enough to describe more than one alternative; and that a type doesn't
446 necessarily need to be a straightforwardly boxed version of its
447 primitive counterpart.
449 {\em END IDLE SPECULATION BY SIMON}
452 boolTy = mkTyConTy boolTyCon
454 boolTyCon = pcTyCon EnumTyCon NonRecursive boolTyConName
455 [] [] [falseDataCon, trueDataCon]
457 falseDataCon = pcDataCon falseDataConName [] [] [] boolTyCon
458 trueDataCon = pcDataCon trueDataConName [] [] [] boolTyCon
460 falseDataConId = dataConId falseDataCon
461 trueDataConId = dataConId trueDataCon
464 %************************************************************************
466 \subsection[TysWiredIn-List]{The @List@ type (incl ``build'' magic)}
468 %************************************************************************
470 Special syntax, deeply wired in, but otherwise an ordinary algebraic
473 data [] a = [] | a : (List a)
475 data (,) a b = (,,) a b
480 mkListTy :: Type -> Type
481 mkListTy ty = mkTyConApp listTyCon [ty]
483 listTyCon = pcRecDataTyCon listTyConName
484 alpha_tyvar [(True,False)] [nilDataCon, consDataCon]
486 nilDataCon = pcDataCon nilDataConName alpha_tyvar [] [] listTyCon
487 consDataCon = pcDataCon consDataConName
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
544 unitTy = mkTupleTy Boxed 0 []
547 %************************************************************************
549 \subsection[TysWiredIn-PArr]{The @[::]@ type}
551 %************************************************************************
553 Special syntax for parallel arrays needs some wired in definitions.
556 -- construct a type representing the application of the parallel array
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
579 (DataCons [parrDataCon]) -- The constructor defined in `PrelPArr'
580 [] -- No record selectors
585 mod = nameModule parrTyConName
586 kind = mkArrowKinds (map tyVarKind tyvars) liftedTypeKind
587 genInfo = mk_tc_gen_info mod (nameUnique parrTyConName) parrTyConName tycon
589 parrDataCon :: DataCon
590 parrDataCon = pcDataCon
592 alpha_tyvar -- forall'ed type variables
594 [intPrimTy, -- 1st argument: Int#
595 mkTyConApp -- 2nd argument: Array# a
600 -- check whether a type constructor is the constructor for parallel arrays
602 isPArrTyCon :: TyCon -> Bool
603 isPArrTyCon tc = tyConName tc == parrTyConName
605 -- fake array constructors
607 -- * these constructors are never really used to represent array values;
608 -- however, they are very convenient during desugaring (and, in particular,
609 -- in the pattern matching compiler) to treat array pattern just like
610 -- yet another constructor pattern
612 parrFakeCon :: Arity -> DataCon
613 parrFakeCon i | i > mAX_TUPLE_SIZE = mkPArrFakeCon i -- build one specially
614 parrFakeCon i = parrFakeConArr!i
616 -- pre-defined set of constructors
618 parrFakeConArr :: Array Int DataCon
619 parrFakeConArr = array (0, mAX_TUPLE_SIZE) [(i, mkPArrFakeCon i)
620 | i <- [0..mAX_TUPLE_SIZE]]
622 -- build a fake parallel array constructor for the given arity
624 mkPArrFakeCon :: Int -> DataCon
625 mkPArrFakeCon arity = pcDataCon name [tyvar] [] tyvarTys parrTyCon
627 tyvar = head alphaTyVars
628 tyvarTys = replicate arity $ mkTyVarTy tyvar
629 nameStr = _PK_ ("MkPArr" ++ show arity)
630 name = mkWiredInName mod (mkOccFS dataName nameStr) uniq
631 uniq = mkPArrDataConUnique arity
632 mod = mkPrelModule pREL_PARR_Name
634 -- checks whether a data constructor is a fake constructor for parallel arrays
636 isPArrFakeCon :: DataCon -> Bool
637 isPArrFakeCon dcon = dcon == parrFakeCon (dataConSourceArity dcon)
640 %************************************************************************
642 \subsection{Wired In Type Constructors for Representation Types}
644 %************************************************************************
646 The following code defines the wired in datatypes cross, plus, unit
647 and c_of needed for the generic methods.
649 Ok, so the basic story is that for each type constructor I need to
650 create 2 things - a TyCon and a DataCon and then we are basically
651 ok. There are going to be no arguments passed to these functions
652 because -well- there is nothing to pass to these functions.
656 crossTyCon = pcNonRecDataTyCon crossTyConName alpha_beta_tyvars [] [crossDataCon]
658 crossDataCon :: DataCon
659 crossDataCon = pcDataCon crossDataConName alpha_beta_tyvars [] [alphaTy, betaTy] crossTyCon
662 plusTyCon = pcNonRecDataTyCon plusTyConName alpha_beta_tyvars [] [inlDataCon, inrDataCon]
664 inlDataCon, inrDataCon :: DataCon
665 inlDataCon = pcDataCon inlDataConName alpha_beta_tyvars [] [alphaTy] plusTyCon
666 inrDataCon = pcDataCon inrDataConName alpha_beta_tyvars [] [betaTy] plusTyCon
668 genUnitTyCon :: TyCon -- The "1" type constructor for generics
669 genUnitTyCon = pcNonRecDataTyCon genUnitTyConName [] [] [genUnitDataCon]
671 genUnitDataCon :: DataCon
672 genUnitDataCon = pcDataCon genUnitDataConName [] [] [] genUnitTyCon