Merge branch 'master' of http://darcs.haskell.org/ghc
[ghc.git] / compiler / prelude / TysWiredIn.lhs
1 %
2 % (c) The GRASP Project, Glasgow University, 1994-1998
3 %
4 \section[TysWiredIn]{Wired-in knowledge about {\em non-primitive} types}
5
6 \begin{code}
7 -- | This module is about types that can be defined in Haskell, but which
8 --   must be wired into the compiler nonetheless.  C.f module TysPrim
9 module TysWiredIn (
10         -- * All wired in things
11         wiredInTyCons,
12
13         -- * Bool
14         boolTy, boolTyCon, boolTyCon_RDR, boolTyConName,
15         trueDataCon,  trueDataConId,  true_RDR,
16         falseDataCon, falseDataConId, false_RDR,
17
18         -- * Ordering
19         ltDataCon, ltDataConId,
20         eqDataCon, eqDataConId,
21         gtDataCon, gtDataConId,
22
23         -- * Char
24         charTyCon, charDataCon, charTyCon_RDR,
25         charTy, stringTy, charTyConName,
26
27         -- integer-gmp only:
28         integerGmpSDataCon,
29
30         -- * Double
31         doubleTyCon, doubleDataCon, doubleTy, doubleTyConName, 
32         
33         -- * Float
34         floatTyCon, floatDataCon, floatTy, floatTyConName,
35
36         -- * Int
37         intTyCon, intDataCon, intTyCon_RDR, intDataCon_RDR, intTyConName,
38         intTy,
39
40         -- * Word
41         wordTyCon, wordDataCon, wordTyConName, wordTy,
42
43         -- * List
44         listTyCon, nilDataCon, consDataCon,
45         listTyCon_RDR, consDataCon_RDR, listTyConName,
46         mkListTy,
47
48         -- * Tuples
49         mkTupleTy, mkBoxedTupleTy,
50         tupleTyCon, tupleCon, 
51         unitTyCon, unitDataCon, unitDataConId, pairTyCon, 
52         unboxedSingletonTyCon, unboxedSingletonDataCon,
53         unboxedPairTyCon, unboxedPairDataCon,
54
55         -- * Unit
56         unitTy,
57
58         -- * Parallel arrays
59         mkPArrTy,
60         parrTyCon, parrFakeCon, isPArrTyCon, isPArrFakeCon,
61         parrTyCon_RDR, parrTyConName,
62
63         -- * Equality predicates
64         eqTyCon_RDR, eqTyCon, eqTyConName, eqBoxDataCon,
65
66         -- * Implicit parameter predicates
67         mkIPName
68     ) where
69
70 #include "HsVersions.h"
71
72 import {-# SOURCE #-} MkId( mkDataConIds )
73
74 -- friends:
75 import PrelNames
76 import TysPrim
77
78 -- others:
79 import Coercion
80 import Constants        ( mAX_TUPLE_SIZE )
81 import Module           ( Module )
82 import DataCon          ( DataCon, mkDataCon, dataConWorkId, dataConSourceArity )
83 import Var
84 import TyCon
85 import TypeRep
86 import RdrName
87 import Name
88 import BasicTypes       ( TupleSort(..), tupleSortBoxity, IPName(..), Arity, RecFlag(..), Boxity(..), HsBang(..) )
89 import Unique           ( incrUnique, mkTupleTyConUnique,
90                           mkTupleDataConUnique, mkPArrDataConUnique )
91 import Data.Array
92 import FastString
93 import Outputable
94 import Config
95
96 alpha_tyvar :: [TyVar]
97 alpha_tyvar = [alphaTyVar]
98
99 alpha_ty :: [Type]
100 alpha_ty = [alphaTy]
101 \end{code}
102
103
104 %************************************************************************
105 %*                                                                      *
106 \subsection{Wired in type constructors}
107 %*                                                                      *
108 %************************************************************************
109
110 If you change which things are wired in, make sure you change their
111 names in PrelNames, so they use wTcQual, wDataQual, etc
112
113 \begin{code}
114 -- This list is used only to define PrelInfo.wiredInThings. That in turn
115 -- is used to initialise the name environment carried around by the renamer.
116 -- This means that if we look up the name of a TyCon (or its implicit binders)
117 -- that occurs in this list that name will be assigned the wired-in key we
118 -- define here.
119 --
120 -- Because of their infinite nature, this list excludes tuples, Any and implicit
121 -- parameter TyCons. Instead, we have a hack in lookupOrigNameCache to deal with
122 -- these names.
123 --
124 -- See also Note [Known-key names]
125 wiredInTyCons :: [TyCon]
126
127 wiredInTyCons = [ unitTyCon     -- Not treated like other tuples, because
128                                 -- it's defined in GHC.Base, and there's only
129                                 -- one of it.  We put it in wiredInTyCons so
130                                 -- that it'll pre-populate the name cache, so
131                                 -- the special case in lookupOrigNameCache 
132                                 -- doesn't need to look out for it
133               , boolTyCon
134               , charTyCon
135               , doubleTyCon
136               , floatTyCon
137               , intTyCon
138               , listTyCon
139               , parrTyCon
140               , eqTyCon
141               ]
142            ++ (case cIntegerLibraryType of
143                IntegerGMP -> [integerTyCon]
144                _ -> [])
145 \end{code}
146
147 \begin{code}
148 mkWiredInTyConName :: BuiltInSyntax -> Module -> FastString -> Unique -> TyCon -> Name
149 mkWiredInTyConName built_in modu fs unique tycon
150   = mkWiredInName modu (mkTcOccFS fs) unique
151                   (ATyCon tycon)        -- Relevant TyCon
152                   built_in
153
154 mkWiredInDataConName :: BuiltInSyntax -> Module -> FastString -> Unique -> DataCon -> Name
155 mkWiredInDataConName built_in modu fs unique datacon
156   = mkWiredInName modu (mkDataOccFS fs) unique
157                   (ADataCon datacon)    -- Relevant DataCon
158                   built_in
159
160 eqTyConName, eqBoxDataConName :: Name
161 eqTyConName      = mkWiredInTyConName   BuiltInSyntax gHC_TYPES (fsLit "~")   eqTyConKey      eqTyCon
162 eqBoxDataConName = mkWiredInDataConName UserSyntax        gHC_TYPES (fsLit "Eq#") eqBoxDataConKey eqBoxDataCon
163
164 charTyConName, charDataConName, intTyConName, intDataConName :: Name
165 charTyConName     = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Char") charTyConKey charTyCon
166 charDataConName   = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "C#") charDataConKey charDataCon
167 intTyConName      = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Int") intTyConKey   intTyCon
168 intDataConName    = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "I#") intDataConKey  intDataCon
169
170 boolTyConName, falseDataConName, trueDataConName :: Name
171 boolTyConName     = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Bool") boolTyConKey boolTyCon
172 falseDataConName  = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "False") falseDataConKey falseDataCon
173 trueDataConName   = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "True")  trueDataConKey  trueDataCon
174
175 listTyConName, nilDataConName, consDataConName :: Name
176 listTyConName     = mkWiredInTyConName   BuiltInSyntax gHC_TYPES (fsLit "[]") listTyConKey listTyCon
177 nilDataConName    = mkWiredInDataConName BuiltInSyntax gHC_TYPES (fsLit "[]") nilDataConKey nilDataCon 
178 consDataConName   = mkWiredInDataConName BuiltInSyntax gHC_TYPES (fsLit ":") consDataConKey consDataCon
179
180 floatTyConName, floatDataConName, doubleTyConName, doubleDataConName :: Name
181 floatTyConName     = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Float") floatTyConKey floatTyCon
182 floatDataConName   = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "F#") floatDataConKey floatDataCon
183 doubleTyConName    = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Double") doubleTyConKey doubleTyCon
184 doubleDataConName  = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "D#") doubleDataConKey doubleDataCon
185
186 -- For integer-gmp only:
187 integerRealTyConName :: Name
188 integerRealTyConName    = case cIntegerLibraryType of
189                           IntegerGMP -> mkWiredInTyConName   UserSyntax gHC_INTEGER_TYPE (fsLit "Integer") integerTyConKey integerTyCon
190                           _ ->          panic "integerRealTyConName evaluated, but not integer-gmp"
191 integerGmpSDataConName, integerGmpJDataConName :: Name
192 integerGmpSDataConName = mkWiredInDataConName UserSyntax gHC_INTEGER_TYPE (fsLit "S#") integerGmpSDataConKey integerGmpSDataCon
193 integerGmpJDataConName = mkWiredInDataConName UserSyntax gHC_INTEGER_TYPE (fsLit "J#") integerGmpJDataConKey integerGmpJDataCon
194
195 parrTyConName, parrDataConName :: Name
196 parrTyConName   = mkWiredInTyConName   BuiltInSyntax 
197                     gHC_PARR' (fsLit "[::]") parrTyConKey parrTyCon 
198 parrDataConName = mkWiredInDataConName UserSyntax    
199                     gHC_PARR' (fsLit "PArr") parrDataConKey parrDataCon
200
201 boolTyCon_RDR, false_RDR, true_RDR, intTyCon_RDR, charTyCon_RDR,
202     intDataCon_RDR, listTyCon_RDR, consDataCon_RDR, parrTyCon_RDR, eqTyCon_RDR :: RdrName
203 boolTyCon_RDR   = nameRdrName boolTyConName
204 false_RDR       = nameRdrName falseDataConName
205 true_RDR        = nameRdrName trueDataConName
206 intTyCon_RDR    = nameRdrName intTyConName
207 charTyCon_RDR   = nameRdrName charTyConName
208 intDataCon_RDR  = nameRdrName intDataConName
209 listTyCon_RDR   = nameRdrName listTyConName
210 consDataCon_RDR = nameRdrName consDataConName
211 parrTyCon_RDR   = nameRdrName parrTyConName
212 eqTyCon_RDR     = nameRdrName eqTyConName
213 \end{code}
214
215
216 %************************************************************************
217 %*                                                                      *
218 \subsection{mkWiredInTyCon}
219 %*                                                                      *
220 %************************************************************************
221
222 \begin{code}
223 pcNonRecDataTyCon :: Name -> [TyVar] -> [DataCon] -> TyCon
224 pcNonRecDataTyCon = pcTyCon False NonRecursive
225 pcRecDataTyCon :: Name -> [TyVar] -> [DataCon] -> TyCon
226 pcRecDataTyCon    = pcTyCon False Recursive
227
228 pcTyCon :: Bool -> RecFlag -> Name -> [TyVar] -> [DataCon] -> TyCon
229 pcTyCon is_enum is_rec name tyvars cons
230   = tycon
231   where
232     tycon = mkAlgTyCon name
233                 (mkArrowKinds (map tyVarKind tyvars) liftedTypeKind)
234                 tyvars
235                 []              -- No stupid theta
236                 (DataTyCon cons is_enum)
237                 NoParentTyCon
238                 is_rec
239                 False           -- Not in GADT syntax
240
241 pcDataCon :: Name -> [TyVar] -> [Type] -> TyCon -> DataCon
242 pcDataCon = pcDataConWithFixity False
243
244 pcDataCon' :: Name -> Unique -> [TyVar] -> [Type] -> TyCon -> DataCon
245 pcDataCon' = pcDataConWithFixity' False
246
247 pcDataConWithFixity :: Bool -> Name -> [TyVar] -> [Type] -> TyCon -> DataCon
248 pcDataConWithFixity infx n = pcDataConWithFixity' infx n (incrUnique (nameUnique n))
249 -- The Name's unique is the first of two free uniques;
250 -- the first is used for the datacon itself,
251 -- the second is used for the "worker name"
252 --
253 -- To support this the mkPreludeDataConUnique function "allocates"
254 -- one DataCon unique per pair of Ints.
255
256 pcDataConWithFixity' :: Bool -> Name -> Unique -> [TyVar] -> [Type] -> TyCon -> DataCon
257 -- The Name should be in the DataName name space; it's the name
258 -- of the DataCon itself.
259
260 pcDataConWithFixity' declared_infix dc_name wrk_key tyvars arg_tys tycon
261   = data_con
262   where
263     data_con = mkDataCon dc_name declared_infix
264                 (map (const HsNoBang) arg_tys)
265                 []      -- No labelled fields
266                 tyvars
267                 []      -- No existential type variables
268                 []      -- No equality spec
269                 []      -- No theta
270                 arg_tys (mkTyConApp tycon (mkTyVarTys tyvars)) 
271                 tycon
272                 []      -- No stupid theta
273                 (mkDataConIds bogus_wrap_name wrk_name data_con)
274                 
275
276     modu     = ASSERT( isExternalName dc_name ) 
277                nameModule dc_name
278     wrk_occ  = mkDataConWorkerOcc (nameOccName dc_name)
279     wrk_name = mkWiredInName modu wrk_occ wrk_key
280                              (AnId (dataConWorkId data_con)) UserSyntax
281     bogus_wrap_name = pprPanic "Wired-in data wrapper id" (ppr dc_name)
282         -- Wired-in types are too simple to need wrappers
283 \end{code}
284
285
286 %************************************************************************
287 %*                                                                      *
288 \subsection[TysWiredIn-tuples]{The tuple types}
289 %*                                                                      *
290 %************************************************************************
291
292 Note [How tuples work]
293 ~~~~~~~~~~~~~~~~~~~~~~
294 * There are three families of tuple TyCons and corresponding
295   DataCons, (boxed, unboxed, and constraint tuples), expressed by the
296   type BasicTypes.TupleSort.
297
298 * DataCons (and workers etc) for BoxedTuple and ConstraintTuple have
299     - distinct Uniques
300     - the same OccName
301   Using the same OccName means (hack!) that a single copy of the
302   runtime library code (info tables etc) works for both.
303
304 * When looking up an OccName in the original-name cache
305   (IfaceEnv.lookupOrigNameCache), we spot the tuple OccName to make sure
306   we get the right wired-in name.  This guy can't tell the difference
307   betweeen BoxedTuple and ConstraintTuple (same OccName!), so tuples
308   are not serialised into interface files using OccNames at all. 
309
310 \begin{code}
311 tupleTyCon :: TupleSort -> Arity -> TyCon
312 tupleTyCon sort i | i > mAX_TUPLE_SIZE = fst (mk_tuple sort i)  -- Build one specially
313 tupleTyCon BoxedTuple   i = fst (boxedTupleArr   ! i)
314 tupleTyCon UnboxedTuple i = fst (unboxedTupleArr ! i)
315 tupleTyCon ConstraintTuple    i = fst (factTupleArr    ! i)
316
317 tupleCon :: TupleSort -> Arity -> DataCon
318 tupleCon sort i | i > mAX_TUPLE_SIZE = snd (mk_tuple sort i)    -- Build one specially
319 tupleCon BoxedTuple   i = snd (boxedTupleArr   ! i)
320 tupleCon UnboxedTuple i = snd (unboxedTupleArr ! i)
321 tupleCon ConstraintTuple    i = snd (factTupleArr    ! i)
322
323 boxedTupleArr, unboxedTupleArr, factTupleArr :: Array Int (TyCon,DataCon)
324 boxedTupleArr   = listArray (0,mAX_TUPLE_SIZE) [mk_tuple BoxedTuple i | i <- [0..mAX_TUPLE_SIZE]]
325 unboxedTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple UnboxedTuple i | i <- [0..mAX_TUPLE_SIZE]]
326 factTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple ConstraintTuple i | i <- [0..mAX_TUPLE_SIZE]]
327
328 mk_tuple :: TupleSort -> Int -> (TyCon,DataCon)
329 mk_tuple sort arity = (tycon, tuple_con)
330   where
331         tycon   = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con sort 
332         modu    = mkTupleModule sort arity
333         tc_name = mkWiredInName modu (mkTupleOcc tcName sort arity) tc_uniq
334                                 (ATyCon tycon) BuiltInSyntax
335         tc_kind = mkArrowKinds (map tyVarKind tyvars) res_kind
336         res_kind = case sort of
337           BoxedTuple      -> liftedTypeKind
338           UnboxedTuple    -> ubxTupleKind
339           ConstraintTuple -> constraintKind
340
341         tyvars = take arity $ case sort of
342           BoxedTuple      -> alphaTyVars
343           UnboxedTuple    -> argAlphaTyVars     -- No nested unboxed tuples
344           ConstraintTuple -> tyVarList constraintKind
345
346         tuple_con = pcDataCon dc_name tyvars tyvar_tys tycon
347         tyvar_tys = mkTyVarTys tyvars
348         dc_name   = mkWiredInName modu (mkTupleOcc dataName sort arity) dc_uniq
349                                   (ADataCon tuple_con) BuiltInSyntax
350         tc_uniq   = mkTupleTyConUnique   sort arity
351         dc_uniq   = mkTupleDataConUnique sort arity
352
353 unitTyCon :: TyCon
354 unitTyCon     = tupleTyCon BoxedTuple 0
355 unitDataCon :: DataCon
356 unitDataCon   = head (tyConDataCons unitTyCon)
357 unitDataConId :: Id
358 unitDataConId = dataConWorkId unitDataCon
359
360 pairTyCon :: TyCon
361 pairTyCon = tupleTyCon BoxedTuple 2
362
363 unboxedSingletonTyCon :: TyCon
364 unboxedSingletonTyCon   = tupleTyCon UnboxedTuple 1
365 unboxedSingletonDataCon :: DataCon
366 unboxedSingletonDataCon = tupleCon   UnboxedTuple 1
367
368 unboxedPairTyCon :: TyCon
369 unboxedPairTyCon   = tupleTyCon UnboxedTuple 2
370 unboxedPairDataCon :: DataCon
371 unboxedPairDataCon = tupleCon   UnboxedTuple 2
372 \end{code}
373
374 %************************************************************************
375 %*                                                                      *
376 \subsection[TysWiredIn-ImplicitParams]{Special type constructors for implicit parameters}
377 %*                                                                      *
378 %************************************************************************
379
380 \begin{code}
381 mkIPName :: FastString
382          -> Unique -> Unique -> Unique -> Unique
383          -> IPName Name
384 mkIPName ip tycon_u datacon_u dc_wrk_u co_ax_u = name_ip
385   where
386     name_ip = IPName tycon_name
387
388     tycon_name = mkPrimTyConName ip tycon_u tycon
389     tycon      = mkAlgTyCon tycon_name
390                    (liftedTypeKind `mkArrowKind` constraintKind)
391                    [alphaTyVar]
392                    []      -- No stupid theta
393                    (NewTyCon { data_con    = datacon, 
394                                nt_rhs      = mkTyVarTy alphaTyVar,
395                                nt_etad_rhs = ([alphaTyVar], mkTyVarTy alphaTyVar),
396                                nt_co       = mkNewTypeCo co_ax_name tycon [alphaTyVar] (mkTyVarTy alphaTyVar) })
397                    (IPTyCon name_ip)
398                    NonRecursive
399                    False
400
401     datacon_name = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "IPBox") datacon_u datacon
402     datacon      = pcDataCon' datacon_name dc_wrk_u [alphaTyVar] [mkTyVarTy alphaTyVar] tycon
403
404     co_ax_name = mkPrimTyConName ip co_ax_u tycon
405 \end{code}
406
407 %************************************************************************
408 %*                                                                      *
409 \subsection[TysWiredIn-boxed-prim]{The ``boxed primitive'' types (@Char@, @Int@, etc)}
410 %*                                                                      *
411 %************************************************************************
412
413 \begin{code}
414 eqTyCon :: TyCon
415 eqTyCon = mkAlgTyCon eqTyConName
416             (mkArrowKinds [openTypeKind, openTypeKind] constraintKind)
417             [alphaTyVar, betaTyVar]
418             []      -- No stupid theta
419             (DataTyCon [eqBoxDataCon] False)
420             NoParentTyCon
421             NonRecursive
422             False
423     
424 eqBoxDataCon :: DataCon
425 eqBoxDataCon = pcDataCon eqBoxDataConName [alphaTyVar, betaTyVar] [TyConApp eqPrimTyCon [mkTyVarTy alphaTyVar, mkTyVarTy betaTyVar]] eqTyCon
426 \end{code}
427
428 \begin{code}
429 charTy :: Type
430 charTy = mkTyConTy charTyCon
431
432 charTyCon :: TyCon
433 charTyCon   = pcNonRecDataTyCon charTyConName [] [charDataCon]
434 charDataCon :: DataCon
435 charDataCon = pcDataCon charDataConName [] [charPrimTy] charTyCon
436
437 stringTy :: Type
438 stringTy = mkListTy charTy -- convenience only
439 \end{code}
440
441 \begin{code}
442 integerTyCon :: TyCon
443 integerTyCon = case cIntegerLibraryType of
444                IntegerGMP ->
445                    pcNonRecDataTyCon integerRealTyConName []
446                                      [integerGmpSDataCon, integerGmpJDataCon]
447                _ ->
448                    panic "Evaluated integerTyCon, but not using IntegerGMP"
449
450 integerGmpSDataCon :: DataCon
451 integerGmpSDataCon = pcDataCon integerGmpSDataConName []
452                                [intPrimTy]
453                                integerTyCon
454
455 -- integerGmpJDataCon isn't exported, but we need to define it to fill
456 -- out integerTyCon
457 integerGmpJDataCon :: DataCon
458 integerGmpJDataCon = pcDataCon integerGmpJDataConName []
459                                [intPrimTy, byteArrayPrimTy]
460                                integerTyCon
461 \end{code}
462
463 \begin{code}
464 intTy :: Type
465 intTy = mkTyConTy intTyCon 
466
467 intTyCon :: TyCon
468 intTyCon = pcNonRecDataTyCon intTyConName [] [intDataCon]
469 intDataCon :: DataCon
470 intDataCon = pcDataCon intDataConName [] [intPrimTy] intTyCon
471 \end{code}
472
473 \begin{code}
474 wordTy :: Type
475 wordTy = mkTyConTy wordTyCon 
476
477 wordTyCon :: TyCon
478 wordTyCon = pcNonRecDataTyCon wordTyConName [] [wordDataCon]
479 wordDataCon :: DataCon
480 wordDataCon = pcDataCon wordDataConName [] [wordPrimTy] wordTyCon
481 \end{code}
482
483 \begin{code}
484 floatTy :: Type
485 floatTy = mkTyConTy floatTyCon
486
487 floatTyCon :: TyCon
488 floatTyCon   = pcNonRecDataTyCon floatTyConName   [] [floatDataCon]
489 floatDataCon :: DataCon
490 floatDataCon = pcDataCon         floatDataConName [] [floatPrimTy] floatTyCon
491 \end{code}
492
493 \begin{code}
494 doubleTy :: Type
495 doubleTy = mkTyConTy doubleTyCon
496
497 doubleTyCon :: TyCon
498 doubleTyCon = pcNonRecDataTyCon doubleTyConName [] [doubleDataCon]
499
500 doubleDataCon :: DataCon
501 doubleDataCon = pcDataCon doubleDataConName [] [doublePrimTy] doubleTyCon
502 \end{code}
503
504
505 %************************************************************************
506 %*                                                                      *
507 \subsection[TysWiredIn-Bool]{The @Bool@ type}
508 %*                                                                      *
509 %************************************************************************
510
511 An ordinary enumeration type, but deeply wired in.  There are no
512 magical operations on @Bool@ (just the regular Prelude code).
513
514 {\em BEGIN IDLE SPECULATION BY SIMON}
515
516 This is not the only way to encode @Bool@.  A more obvious coding makes
517 @Bool@ just a boxed up version of @Bool#@, like this:
518 \begin{verbatim}
519 type Bool# = Int#
520 data Bool = MkBool Bool#
521 \end{verbatim}
522
523 Unfortunately, this doesn't correspond to what the Report says @Bool@
524 looks like!  Furthermore, we get slightly less efficient code (I
525 think) with this coding. @gtInt@ would look like this:
526
527 \begin{verbatim}
528 gtInt :: Int -> Int -> Bool
529 gtInt x y = case x of I# x# ->
530             case y of I# y# ->
531             case (gtIntPrim x# y#) of
532                 b# -> MkBool b#
533 \end{verbatim}
534
535 Notice that the result of the @gtIntPrim@ comparison has to be turned
536 into an integer (here called @b#@), and returned in a @MkBool@ box.
537
538 The @if@ expression would compile to this:
539 \begin{verbatim}
540 case (gtInt x y) of
541   MkBool b# -> case b# of { 1# -> e1; 0# -> e2 }
542 \end{verbatim}
543
544 I think this code is a little less efficient than the previous code,
545 but I'm not certain.  At all events, corresponding with the Report is
546 important.  The interesting thing is that the language is expressive
547 enough to describe more than one alternative; and that a type doesn't
548 necessarily need to be a straightforwardly boxed version of its
549 primitive counterpart.
550
551 {\em END IDLE SPECULATION BY SIMON}
552
553 \begin{code}
554 boolTy :: Type
555 boolTy = mkTyConTy boolTyCon
556
557 boolTyCon :: TyCon
558 boolTyCon = pcTyCon True NonRecursive boolTyConName
559                     [] [falseDataCon, trueDataCon]
560
561 falseDataCon, trueDataCon :: DataCon
562 falseDataCon = pcDataCon falseDataConName [] [] boolTyCon
563 trueDataCon  = pcDataCon trueDataConName  [] [] boolTyCon
564
565 falseDataConId, trueDataConId :: Id
566 falseDataConId = dataConWorkId falseDataCon
567 trueDataConId  = dataConWorkId trueDataCon
568
569 orderingTyCon :: TyCon
570 orderingTyCon = pcTyCon True NonRecursive orderingTyConName
571                         [] [ltDataCon, eqDataCon, gtDataCon]
572
573 ltDataCon, eqDataCon, gtDataCon :: DataCon
574 ltDataCon = pcDataCon ltDataConName  [] [] orderingTyCon
575 eqDataCon = pcDataCon eqDataConName  [] [] orderingTyCon
576 gtDataCon = pcDataCon gtDataConName  [] [] orderingTyCon
577
578 ltDataConId, eqDataConId, gtDataConId :: Id
579 ltDataConId = dataConWorkId ltDataCon
580 eqDataConId = dataConWorkId eqDataCon
581 gtDataConId = dataConWorkId gtDataCon
582 \end{code}
583
584 %************************************************************************
585 %*                                                                      *
586 \subsection[TysWiredIn-List]{The @List@ type (incl ``build'' magic)}
587 %*                                                                      *
588 %************************************************************************
589
590 Special syntax, deeply wired in, but otherwise an ordinary algebraic
591 data types:
592 \begin{verbatim}
593 data [] a = [] | a : (List a)
594 data () = ()
595 data (,) a b = (,,) a b
596 ...
597 \end{verbatim}
598
599 \begin{code}
600 mkListTy :: Type -> Type
601 mkListTy ty = mkTyConApp listTyCon [ty]
602
603 listTyCon :: TyCon
604 listTyCon = pcRecDataTyCon listTyConName alpha_tyvar [nilDataCon, consDataCon]
605
606 nilDataCon :: DataCon
607 nilDataCon  = pcDataCon nilDataConName alpha_tyvar [] listTyCon
608
609 consDataCon :: DataCon
610 consDataCon = pcDataConWithFixity True {- Declared infix -}
611                consDataConName
612                alpha_tyvar [alphaTy, mkTyConApp listTyCon alpha_ty] listTyCon
613 -- Interesting: polymorphic recursion would help here.
614 -- We can't use (mkListTy alphaTy) in the defn of consDataCon, else mkListTy
615 -- gets the over-specific type (Type -> Type)
616 \end{code}
617
618 %************************************************************************
619 %*                                                                      *
620 \subsection[TysWiredIn-Tuples]{The @Tuple@ types}
621 %*                                                                      *
622 %************************************************************************
623
624 The tuple types are definitely magic, because they form an infinite
625 family.
626
627 \begin{itemize}
628 \item
629 They have a special family of type constructors, of type @TyCon@
630 These contain the tycon arity, but don't require a Unique.
631
632 \item
633 They have a special family of constructors, of type
634 @Id@. Again these contain their arity but don't need a Unique.
635
636 \item
637 There should be a magic way of generating the info tables and
638 entry code for all tuples.
639
640 But at the moment we just compile a Haskell source
641 file\srcloc{lib/prelude/...} containing declarations like:
642 \begin{verbatim}
643 data Tuple0             = Tup0
644 data Tuple2  a b        = Tup2  a b
645 data Tuple3  a b c      = Tup3  a b c
646 data Tuple4  a b c d    = Tup4  a b c d
647 ...
648 \end{verbatim}
649 The print-names associated with the magic @Id@s for tuple constructors
650 ``just happen'' to be the same as those generated by these
651 declarations.
652
653 \item
654 The instance environment should have a magic way to know
655 that each tuple type is an instances of classes @Eq@, @Ix@, @Ord@ and
656 so on. \ToDo{Not implemented yet.}
657
658 \item
659 There should also be a way to generate the appropriate code for each
660 of these instances, but (like the info tables and entry code) it is
661 done by enumeration\srcloc{lib/prelude/InTup?.hs}.
662 \end{itemize}
663
664 \begin{code}
665 mkTupleTy :: TupleSort -> [Type] -> Type
666 -- Special case for *boxed* 1-tuples, which are represented by the type itself
667 mkTupleTy sort [ty] | Boxed <- tupleSortBoxity sort = ty
668 mkTupleTy sort tys = mkTyConApp (tupleTyCon sort (length tys)) tys
669
670 -- | Build the type of a small tuple that holds the specified type of thing
671 mkBoxedTupleTy :: [Type] -> Type
672 mkBoxedTupleTy tys = mkTupleTy BoxedTuple tys
673
674 unitTy :: Type
675 unitTy = mkTupleTy BoxedTuple []
676 \end{code}
677
678 %************************************************************************
679 %*                                                                      *
680 \subsection[TysWiredIn-PArr]{The @[::]@ type}
681 %*                                                                      *
682 %************************************************************************
683
684 Special syntax for parallel arrays needs some wired in definitions.
685
686 \begin{code}
687 -- | Construct a type representing the application of the parallel array constructor 
688 mkPArrTy    :: Type -> Type
689 mkPArrTy ty  = mkTyConApp parrTyCon [ty]
690
691 -- | Represents the type constructor of parallel arrays
692 --
693 --  * This must match the definition in @PrelPArr@
694 --
695 -- NB: Although the constructor is given here, it will not be accessible in
696 --     user code as it is not in the environment of any compiled module except
697 --     @PrelPArr@.
698 --
699 parrTyCon :: TyCon
700 parrTyCon  = pcNonRecDataTyCon parrTyConName alpha_tyvar [parrDataCon]
701
702 parrDataCon :: DataCon
703 parrDataCon  = pcDataCon 
704                  parrDataConName 
705                  alpha_tyvar            -- forall'ed type variables
706                  [intTy,                -- 1st argument: Int
707                   mkTyConApp            -- 2nd argument: Array# a
708                     arrayPrimTyCon 
709                     alpha_ty] 
710                  parrTyCon
711
712 -- | Check whether a type constructor is the constructor for parallel arrays
713 isPArrTyCon    :: TyCon -> Bool
714 isPArrTyCon tc  = tyConName tc == parrTyConName
715
716 -- | Fake array constructors
717 --
718 -- * These constructors are never really used to represent array values;
719 --   however, they are very convenient during desugaring (and, in particular,
720 --   in the pattern matching compiler) to treat array pattern just like
721 --   yet another constructor pattern
722 --
723 parrFakeCon                        :: Arity -> DataCon
724 parrFakeCon i | i > mAX_TUPLE_SIZE  = mkPArrFakeCon  i  -- build one specially
725 parrFakeCon i                       = parrFakeConArr!i
726
727 -- pre-defined set of constructors
728 --
729 parrFakeConArr :: Array Int DataCon
730 parrFakeConArr  = array (0, mAX_TUPLE_SIZE) [(i, mkPArrFakeCon i)   
731                                             | i <- [0..mAX_TUPLE_SIZE]]
732
733 -- build a fake parallel array constructor for the given arity
734 --
735 mkPArrFakeCon       :: Int -> DataCon
736 mkPArrFakeCon arity  = data_con
737   where
738         data_con  = pcDataCon name [tyvar] tyvarTys parrTyCon
739         tyvar     = head alphaTyVars
740         tyvarTys  = replicate arity $ mkTyVarTy tyvar
741         nameStr   = mkFastString ("MkPArr" ++ show arity)
742         name      = mkWiredInName gHC_PARR' (mkDataOccFS nameStr) unique
743                                   (ADataCon data_con) UserSyntax
744         unique      = mkPArrDataConUnique arity
745
746 -- | Checks whether a data constructor is a fake constructor for parallel arrays
747 isPArrFakeCon      :: DataCon -> Bool
748 isPArrFakeCon dcon  = dcon == parrFakeCon (dataConSourceArity dcon)
749 \end{code}