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