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