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