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