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