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