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 {-# 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,
52         listTyCon_RDR, consDataCon_RDR, listTyConName,
53         mkListTy, mkPromotedListTy,
54
55         -- * Tuples
56         mkTupleTy, mkBoxedTupleTy,
57         tupleTyCon, promotedTupleTyCon,
58         tupleCon, 
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         -- * Implicit parameter predicates
76         mkIPName
77     ) where
78
79 #include "HsVersions.h"
80
81 import {-# SOURCE #-} MkId( mkDataConIds )
82
83 -- friends:
84 import PrelNames
85 import TysPrim
86
87 -- others:
88 import Coercion
89 import Constants        ( mAX_TUPLE_SIZE )
90 import Module           ( Module )
91 import DataCon
92 import Var
93 import TyCon
94 import TypeRep
95 import RdrName
96 import Name
97 import BasicTypes       ( TupleSort(..), tupleSortBoxity, IPName(..), 
98                           Arity, RecFlag(..), Boxity(..), HsBang(..) )
99 import Unique           ( incrUnique, mkTupleTyConUnique,
100                           mkTupleDataConUnique, mkPArrDataConUnique )
101 import Data.Array
102 import FastString
103 import Outputable
104 import Config
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 -> [TyVar] -> [DataCon] -> TyCon
233 pcNonRecDataTyCon = pcTyCon False NonRecursive
234 pcRecDataTyCon :: Name -> [TyVar] -> [DataCon] -> TyCon
235 pcRecDataTyCon    = pcTyCon False Recursive
236
237 pcTyCon :: Bool -> RecFlag -> Name -> [TyVar] -> [DataCon] -> TyCon
238 pcTyCon is_enum is_rec name tyvars cons
239   = tycon
240   where
241     tycon = mkAlgTyCon name
242                 (mkArrowKinds (map tyVarKind tyvars) liftedTypeKind)
243                 tyvars
244                 []              -- No stupid theta
245                 (DataTyCon cons is_enum)
246                 NoParentTyCon
247                 is_rec
248                 False           -- Not in GADT syntax
249
250 pcDataCon :: Name -> [TyVar] -> [Type] -> TyCon -> DataCon
251 pcDataCon = pcDataConWithFixity False
252
253 pcDataCon' :: Name -> Unique -> [TyVar] -> [Type] -> TyCon -> DataCon
254 pcDataCon' = pcDataConWithFixity' False
255
256 pcDataConWithFixity :: Bool -> Name -> [TyVar] -> [Type] -> TyCon -> DataCon
257 pcDataConWithFixity infx n = pcDataConWithFixity' infx n (incrUnique (nameUnique n))
258 -- The Name's unique is the first of two free uniques;
259 -- the first is used for the datacon itself,
260 -- the second is used for the "worker name"
261 --
262 -- To support this the mkPreludeDataConUnique function "allocates"
263 -- one DataCon unique per pair of Ints.
264
265 pcDataConWithFixity' :: Bool -> Name -> Unique -> [TyVar] -> [Type] -> TyCon -> DataCon
266 -- The Name should be in the DataName name space; it's the name
267 -- of the DataCon itself.
268
269 pcDataConWithFixity' declared_infix dc_name wrk_key tyvars arg_tys tycon
270   = data_con
271   where
272     data_con = mkDataCon dc_name declared_infix
273                 (map (const HsNoBang) arg_tys)
274                 []      -- No labelled fields
275                 tyvars
276                 []      -- No existential type variables
277                 []      -- No equality spec
278                 []      -- No theta
279                 arg_tys (mkTyConApp tycon (mkTyVarTys tyvars)) 
280                 tycon
281                 []      -- No stupid theta
282                 (mkDataConIds bogus_wrap_name wrk_name data_con)
283                 
284
285     modu     = ASSERT( isExternalName dc_name ) 
286                nameModule dc_name
287     wrk_occ  = mkDataConWorkerOcc (nameOccName dc_name)
288     wrk_name = mkWiredInName modu wrk_occ wrk_key
289                              (AnId (dataConWorkId data_con)) UserSyntax
290     bogus_wrap_name = pprPanic "Wired-in data wrapper id" (ppr dc_name)
291         -- Wired-in types are too simple to need wrappers
292 \end{code}
293
294
295 %************************************************************************
296 %*                                                                      *
297 \subsection[TysWiredIn-tuples]{The tuple types}
298 %*                                                                      *
299 %************************************************************************
300
301 Note [How tuples work]
302 ~~~~~~~~~~~~~~~~~~~~~~
303 * There are three families of tuple TyCons and corresponding
304   DataCons, (boxed, unboxed, and constraint tuples), expressed by the
305   type BasicTypes.TupleSort.
306
307 * DataCons (and workers etc) for BoxedTuple and ConstraintTuple have
308     - distinct Uniques
309     - the same OccName
310   Using the same OccName means (hack!) that a single copy of the
311   runtime library code (info tables etc) works for both.
312
313 * When looking up an OccName in the original-name cache
314   (IfaceEnv.lookupOrigNameCache), we spot the tuple OccName to make sure
315   we get the right wired-in name.  This guy can't tell the difference
316   betweeen BoxedTuple and ConstraintTuple (same OccName!), so tuples
317   are not serialised into interface files using OccNames at all. 
318
319 \begin{code}
320 tupleTyCon :: TupleSort -> Arity -> TyCon
321 tupleTyCon sort i | i > mAX_TUPLE_SIZE = fst (mk_tuple sort i)  -- Build one specially
322 tupleTyCon BoxedTuple   i = fst (boxedTupleArr   ! i)
323 tupleTyCon UnboxedTuple i = fst (unboxedTupleArr ! i)
324 tupleTyCon ConstraintTuple    i = fst (factTupleArr    ! i)
325
326 promotedTupleTyCon :: TupleSort -> Arity -> TyCon
327 promotedTupleTyCon sort i = buildPromotedTyCon (tupleTyCon sort i)
328
329 tupleCon :: TupleSort -> Arity -> DataCon
330 tupleCon sort i | i > mAX_TUPLE_SIZE = snd (mk_tuple sort i)    -- Build one specially
331 tupleCon BoxedTuple   i = snd (boxedTupleArr   ! i)
332 tupleCon UnboxedTuple i = snd (unboxedTupleArr ! i)
333 tupleCon ConstraintTuple    i = snd (factTupleArr    ! i)
334
335 boxedTupleArr, unboxedTupleArr, factTupleArr :: Array Int (TyCon,DataCon)
336 boxedTupleArr   = listArray (0,mAX_TUPLE_SIZE) [mk_tuple BoxedTuple i | i <- [0..mAX_TUPLE_SIZE]]
337 unboxedTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple UnboxedTuple i | i <- [0..mAX_TUPLE_SIZE]]
338 factTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple ConstraintTuple i | i <- [0..mAX_TUPLE_SIZE]]
339
340 mk_tuple :: TupleSort -> Int -> (TyCon,DataCon)
341 mk_tuple sort arity = (tycon, tuple_con)
342   where
343         tycon   = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con sort 
344         modu    = mkTupleModule sort arity
345         tc_name = mkWiredInName modu (mkTupleOcc tcName sort arity) tc_uniq
346                                 (ATyCon tycon) BuiltInSyntax
347         tc_kind = mkArrowKinds (map tyVarKind tyvars) res_kind
348         res_kind = case sort of
349           BoxedTuple      -> liftedTypeKind
350           UnboxedTuple    -> ubxTupleKind
351           ConstraintTuple -> constraintKind
352
353         tyvars = take arity $ case sort of
354           BoxedTuple      -> alphaTyVars
355           UnboxedTuple    -> argAlphaTyVars     -- No nested unboxed tuples
356           ConstraintTuple -> tyVarList constraintKind
357
358         tuple_con = pcDataCon dc_name tyvars tyvar_tys tycon
359         tyvar_tys = mkTyVarTys tyvars
360         dc_name   = mkWiredInName modu (mkTupleOcc dataName sort arity) dc_uniq
361                                   (ADataCon tuple_con) BuiltInSyntax
362         tc_uniq   = mkTupleTyConUnique   sort arity
363         dc_uniq   = mkTupleDataConUnique sort arity
364
365 unitTyCon :: TyCon
366 unitTyCon     = tupleTyCon BoxedTuple 0
367 unitDataCon :: DataCon
368 unitDataCon   = head (tyConDataCons unitTyCon)
369 unitDataConId :: Id
370 unitDataConId = dataConWorkId unitDataCon
371
372 pairTyCon :: TyCon
373 pairTyCon = tupleTyCon BoxedTuple 2
374
375 unboxedUnitTyCon :: TyCon
376 unboxedUnitTyCon   = tupleTyCon UnboxedTuple 0
377 unboxedUnitDataCon :: DataCon
378 unboxedUnitDataCon = tupleCon   UnboxedTuple 0
379
380 unboxedSingletonTyCon :: TyCon
381 unboxedSingletonTyCon   = tupleTyCon UnboxedTuple 1
382 unboxedSingletonDataCon :: DataCon
383 unboxedSingletonDataCon = tupleCon   UnboxedTuple 1
384
385 unboxedPairTyCon :: TyCon
386 unboxedPairTyCon   = tupleTyCon UnboxedTuple 2
387 unboxedPairDataCon :: DataCon
388 unboxedPairDataCon = tupleCon   UnboxedTuple 2
389 \end{code}
390
391 %************************************************************************
392 %*                                                                      *
393 \subsection[TysWiredIn-ImplicitParams]{Special type constructors for implicit parameters}
394 %*                                                                      *
395 %************************************************************************
396
397 \begin{code}
398 mkIPName :: FastString
399          -> Unique -> Unique -> Unique -> Unique
400          -> IPName Name
401 mkIPName ip tycon_u datacon_u dc_wrk_u co_ax_u = name_ip
402   where
403     name_ip = IPName tycon_name
404
405     tycon_name = mkPrimTyConName ip tycon_u tycon
406     tycon      = mkAlgTyCon tycon_name
407                    (liftedTypeKind `mkArrowKind` constraintKind)
408                    [alphaTyVar]
409                    []      -- No stupid theta
410                    (NewTyCon { data_con    = datacon, 
411                                nt_rhs      = mkTyVarTy alphaTyVar,
412                                nt_etad_rhs = ([alphaTyVar], mkTyVarTy alphaTyVar),
413                                nt_co       = mkNewTypeCo co_ax_name tycon [alphaTyVar] (mkTyVarTy alphaTyVar) })
414                    (IPTyCon name_ip)
415                    NonRecursive
416                    False
417
418     datacon_name = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "IPBox") datacon_u datacon
419     datacon      = pcDataCon' datacon_name dc_wrk_u [alphaTyVar] [mkTyVarTy alphaTyVar] tycon
420
421     co_ax_name = mkPrimTyConName ip co_ax_u tycon
422 \end{code}
423
424 %************************************************************************
425 %*                                                                      *
426 \subsection[TysWiredIn-boxed-prim]{The ``boxed primitive'' types (@Char@, @Int@, etc)}
427 %*                                                                      *
428 %************************************************************************
429
430 \begin{code}
431 eqTyCon :: TyCon
432 eqTyCon = mkAlgTyCon eqTyConName
433             (ForAllTy kv $ mkArrowKinds [k, k] constraintKind)
434             [kv, a, b]
435             []      -- No stupid theta
436             (DataTyCon [eqBoxDataCon] False)
437             NoParentTyCon
438             NonRecursive
439             False
440   where
441     kv = kKiVar
442     k = mkTyVarTy kv
443     a:b:_ = tyVarList k
444
445 eqBoxDataCon :: DataCon
446 eqBoxDataCon = pcDataCon eqBoxDataConName args [TyConApp eqPrimTyCon (map mkTyVarTy args)] eqTyCon
447   where
448     kv = kKiVar
449     k = mkTyVarTy kv
450     a:b:_ = tyVarList k
451     args = [kv, a, b]
452 \end{code}
453
454 \begin{code}
455 charTy :: Type
456 charTy = mkTyConTy charTyCon
457
458 charTyCon :: TyCon
459 charTyCon   = pcNonRecDataTyCon charTyConName [] [charDataCon]
460 charDataCon :: DataCon
461 charDataCon = pcDataCon charDataConName [] [charPrimTy] charTyCon
462
463 stringTy :: Type
464 stringTy = mkListTy charTy -- convenience only
465 \end{code}
466
467 \begin{code}
468 integerTyCon :: TyCon
469 integerTyCon = case cIntegerLibraryType of
470                IntegerGMP ->
471                    pcNonRecDataTyCon integerRealTyConName []
472                                      [integerGmpSDataCon, integerGmpJDataCon]
473                _ ->
474                    panic "Evaluated integerTyCon, but not using IntegerGMP"
475
476 integerGmpSDataCon :: DataCon
477 integerGmpSDataCon = pcDataCon integerGmpSDataConName []
478                                [intPrimTy]
479                                integerTyCon
480
481 -- integerGmpJDataCon isn't exported, but we need to define it to fill
482 -- out integerTyCon
483 integerGmpJDataCon :: DataCon
484 integerGmpJDataCon = pcDataCon integerGmpJDataConName []
485                                [intPrimTy, byteArrayPrimTy]
486                                integerTyCon
487 \end{code}
488
489 \begin{code}
490 intTy :: Type
491 intTy = mkTyConTy intTyCon 
492
493 intTyCon :: TyCon
494 intTyCon = pcNonRecDataTyCon intTyConName [] [intDataCon]
495 intDataCon :: DataCon
496 intDataCon = pcDataCon intDataConName [] [intPrimTy] intTyCon
497 \end{code}
498
499 \begin{code}
500 wordTy :: Type
501 wordTy = mkTyConTy wordTyCon 
502
503 wordTyCon :: TyCon
504 wordTyCon = pcNonRecDataTyCon wordTyConName [] [wordDataCon]
505 wordDataCon :: DataCon
506 wordDataCon = pcDataCon wordDataConName [] [wordPrimTy] wordTyCon
507 \end{code}
508
509 \begin{code}
510 floatTy :: Type
511 floatTy = mkTyConTy floatTyCon
512
513 floatTyCon :: TyCon
514 floatTyCon   = pcNonRecDataTyCon floatTyConName   [] [floatDataCon]
515 floatDataCon :: DataCon
516 floatDataCon = pcDataCon         floatDataConName [] [floatPrimTy] floatTyCon
517 \end{code}
518
519 \begin{code}
520 doubleTy :: Type
521 doubleTy = mkTyConTy doubleTyCon
522
523 doubleTyCon :: TyCon
524 doubleTyCon = pcNonRecDataTyCon doubleTyConName [] [doubleDataCon]
525
526 doubleDataCon :: DataCon
527 doubleDataCon = pcDataCon doubleDataConName [] [doublePrimTy] doubleTyCon
528 \end{code}
529
530
531 %************************************************************************
532 %*                                                                      *
533 \subsection[TysWiredIn-Bool]{The @Bool@ type}
534 %*                                                                      *
535 %************************************************************************
536
537 An ordinary enumeration type, but deeply wired in.  There are no
538 magical operations on @Bool@ (just the regular Prelude code).
539
540 {\em BEGIN IDLE SPECULATION BY SIMON}
541
542 This is not the only way to encode @Bool@.  A more obvious coding makes
543 @Bool@ just a boxed up version of @Bool#@, like this:
544 \begin{verbatim}
545 type Bool# = Int#
546 data Bool = MkBool Bool#
547 \end{verbatim}
548
549 Unfortunately, this doesn't correspond to what the Report says @Bool@
550 looks like!  Furthermore, we get slightly less efficient code (I
551 think) with this coding. @gtInt@ would look like this:
552
553 \begin{verbatim}
554 gtInt :: Int -> Int -> Bool
555 gtInt x y = case x of I# x# ->
556             case y of I# y# ->
557             case (gtIntPrim x# y#) of
558                 b# -> MkBool b#
559 \end{verbatim}
560
561 Notice that the result of the @gtIntPrim@ comparison has to be turned
562 into an integer (here called @b#@), and returned in a @MkBool@ box.
563
564 The @if@ expression would compile to this:
565 \begin{verbatim}
566 case (gtInt x y) of
567   MkBool b# -> case b# of { 1# -> e1; 0# -> e2 }
568 \end{verbatim}
569
570 I think this code is a little less efficient than the previous code,
571 but I'm not certain.  At all events, corresponding with the Report is
572 important.  The interesting thing is that the language is expressive
573 enough to describe more than one alternative; and that a type doesn't
574 necessarily need to be a straightforwardly boxed version of its
575 primitive counterpart.
576
577 {\em END IDLE SPECULATION BY SIMON}
578
579 \begin{code}
580 boolTy :: Type
581 boolTy = mkTyConTy boolTyCon
582
583 boolTyCon :: TyCon
584 boolTyCon = pcTyCon True NonRecursive boolTyConName
585                     [] [falseDataCon, trueDataCon]
586
587 falseDataCon, trueDataCon :: DataCon
588 falseDataCon = pcDataCon falseDataConName [] [] boolTyCon
589 trueDataCon  = pcDataCon trueDataConName  [] [] boolTyCon
590
591 falseDataConId, trueDataConId :: Id
592 falseDataConId = dataConWorkId falseDataCon
593 trueDataConId  = dataConWorkId trueDataCon
594
595 orderingTyCon :: TyCon
596 orderingTyCon = pcTyCon True NonRecursive orderingTyConName
597                         [] [ltDataCon, eqDataCon, gtDataCon]
598
599 ltDataCon, eqDataCon, gtDataCon :: DataCon
600 ltDataCon = pcDataCon ltDataConName  [] [] orderingTyCon
601 eqDataCon = pcDataCon eqDataConName  [] [] orderingTyCon
602 gtDataCon = pcDataCon gtDataConName  [] [] orderingTyCon
603
604 ltDataConId, eqDataConId, gtDataConId :: Id
605 ltDataConId = dataConWorkId ltDataCon
606 eqDataConId = dataConWorkId eqDataCon
607 gtDataConId = dataConWorkId gtDataCon
608 \end{code}
609
610 %************************************************************************
611 %*                                                                      *
612 \subsection[TysWiredIn-List]{The @List@ type (incl ``build'' magic)}
613 %*                                                                      *
614 %************************************************************************
615
616 Special syntax, deeply wired in, but otherwise an ordinary algebraic
617 data types:
618 \begin{verbatim}
619 data [] a = [] | a : (List a)
620 data () = ()
621 data (,) a b = (,,) a b
622 ...
623 \end{verbatim}
624
625 \begin{code}
626 mkListTy :: Type -> Type
627 mkListTy ty = mkTyConApp listTyCon [ty]
628
629 listTyCon :: TyCon
630 listTyCon = pcRecDataTyCon listTyConName alpha_tyvar [nilDataCon, consDataCon]
631
632 mkPromotedListTy :: Type -> Type
633 mkPromotedListTy ty = mkTyConApp promotedListTyCon [ty]
634
635 promotedListTyCon :: TyCon
636 promotedListTyCon = buildPromotedTyCon listTyCon
637
638 nilDataCon :: DataCon
639 nilDataCon  = pcDataCon nilDataConName alpha_tyvar [] listTyCon
640
641 consDataCon :: DataCon
642 consDataCon = pcDataConWithFixity True {- Declared infix -}
643                consDataConName
644                alpha_tyvar [alphaTy, mkTyConApp listTyCon alpha_ty] listTyCon
645 -- Interesting: polymorphic recursion would help here.
646 -- We can't use (mkListTy alphaTy) in the defn of consDataCon, else mkListTy
647 -- gets the over-specific type (Type -> Type)
648 \end{code}
649
650 %************************************************************************
651 %*                                                                      *
652 \subsection[TysWiredIn-Tuples]{The @Tuple@ types}
653 %*                                                                      *
654 %************************************************************************
655
656 The tuple types are definitely magic, because they form an infinite
657 family.
658
659 \begin{itemize}
660 \item
661 They have a special family of type constructors, of type @TyCon@
662 These contain the tycon arity, but don't require a Unique.
663
664 \item
665 They have a special family of constructors, of type
666 @Id@. Again these contain their arity but don't need a Unique.
667
668 \item
669 There should be a magic way of generating the info tables and
670 entry code for all tuples.
671
672 But at the moment we just compile a Haskell source
673 file\srcloc{lib/prelude/...} containing declarations like:
674 \begin{verbatim}
675 data Tuple0             = Tup0
676 data Tuple2  a b        = Tup2  a b
677 data Tuple3  a b c      = Tup3  a b c
678 data Tuple4  a b c d    = Tup4  a b c d
679 ...
680 \end{verbatim}
681 The print-names associated with the magic @Id@s for tuple constructors
682 ``just happen'' to be the same as those generated by these
683 declarations.
684
685 \item
686 The instance environment should have a magic way to know
687 that each tuple type is an instances of classes @Eq@, @Ix@, @Ord@ and
688 so on. \ToDo{Not implemented yet.}
689
690 \item
691 There should also be a way to generate the appropriate code for each
692 of these instances, but (like the info tables and entry code) it is
693 done by enumeration\srcloc{lib/prelude/InTup?.hs}.
694 \end{itemize}
695
696 \begin{code}
697 mkTupleTy :: TupleSort -> [Type] -> Type
698 -- Special case for *boxed* 1-tuples, which are represented by the type itself
699 mkTupleTy sort [ty] | Boxed <- tupleSortBoxity sort = ty
700 mkTupleTy sort tys = mkTyConApp (tupleTyCon sort (length tys)) tys
701
702 -- | Build the type of a small tuple that holds the specified type of thing
703 mkBoxedTupleTy :: [Type] -> Type
704 mkBoxedTupleTy tys = mkTupleTy BoxedTuple tys
705
706 unitTy :: Type
707 unitTy = mkTupleTy BoxedTuple []
708 \end{code}
709
710 %************************************************************************
711 %*                                                                      *
712 \subsection[TysWiredIn-PArr]{The @[::]@ type}
713 %*                                                                      *
714 %************************************************************************
715
716 Special syntax for parallel arrays needs some wired in definitions.
717
718 \begin{code}
719 -- | Construct a type representing the application of the parallel array constructor 
720 mkPArrTy    :: Type -> Type
721 mkPArrTy ty  = mkTyConApp parrTyCon [ty]
722
723 -- | Represents the type constructor of parallel arrays
724 --
725 --  * This must match the definition in @PrelPArr@
726 --
727 -- NB: Although the constructor is given here, it will not be accessible in
728 --     user code as it is not in the environment of any compiled module except
729 --     @PrelPArr@.
730 --
731 parrTyCon :: TyCon
732 parrTyCon  = pcNonRecDataTyCon parrTyConName alpha_tyvar [parrDataCon]
733
734 parrDataCon :: DataCon
735 parrDataCon  = pcDataCon 
736                  parrDataConName 
737                  alpha_tyvar            -- forall'ed type variables
738                  [intTy,                -- 1st argument: Int
739                   mkTyConApp            -- 2nd argument: Array# a
740                     arrayPrimTyCon 
741                     alpha_ty] 
742                  parrTyCon
743
744 -- | Check whether a type constructor is the constructor for parallel arrays
745 isPArrTyCon    :: TyCon -> Bool
746 isPArrTyCon tc  = tyConName tc == parrTyConName
747
748 -- | Fake array constructors
749 --
750 -- * These constructors are never really used to represent array values;
751 --   however, they are very convenient during desugaring (and, in particular,
752 --   in the pattern matching compiler) to treat array pattern just like
753 --   yet another constructor pattern
754 --
755 parrFakeCon                        :: Arity -> DataCon
756 parrFakeCon i | i > mAX_TUPLE_SIZE  = mkPArrFakeCon  i  -- build one specially
757 parrFakeCon i                       = parrFakeConArr!i
758
759 -- pre-defined set of constructors
760 --
761 parrFakeConArr :: Array Int DataCon
762 parrFakeConArr  = array (0, mAX_TUPLE_SIZE) [(i, mkPArrFakeCon i)   
763                                             | i <- [0..mAX_TUPLE_SIZE]]
764
765 -- build a fake parallel array constructor for the given arity
766 --
767 mkPArrFakeCon       :: Int -> DataCon
768 mkPArrFakeCon arity  = data_con
769   where
770         data_con  = pcDataCon name [tyvar] tyvarTys parrTyCon
771         tyvar     = head alphaTyVars
772         tyvarTys  = replicate arity $ mkTyVarTy tyvar
773         nameStr   = mkFastString ("MkPArr" ++ show arity)
774         name      = mkWiredInName gHC_PARR' (mkDataOccFS nameStr) unique
775                                   (ADataCon data_con) UserSyntax
776         unique      = mkPArrDataConUnique arity
777
778 -- | Checks whether a data constructor is a fake constructor for parallel arrays
779 isPArrFakeCon      :: DataCon -> Bool
780 isPArrFakeCon dcon  = dcon == parrFakeCon (dataConSourceArity dcon)
781 \end{code}