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