cf54f26043eb68a538fccc14cb60e56d6b00c510
[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         -- * Char
19         charTyCon, charDataCon, charTyCon_RDR,
20         charTy, stringTy, charTyConName,
21
22         -- * Double
23         doubleTyCon, doubleDataCon, doubleTy, doubleTyConName, 
24         
25         -- * Float
26         floatTyCon, floatDataCon, floatTy, floatTyConName,
27
28         -- * Int
29         intTyCon, intDataCon, intTyCon_RDR, intDataCon_RDR, intTyConName,
30         intTy,
31
32         -- * Word
33         wordTyCon, wordDataCon, wordTyConName, wordTy,
34
35         -- * List
36         listTyCon, nilDataCon, consDataCon,
37         listTyCon_RDR, consDataCon_RDR, listTyConName,
38         mkListTy,
39
40         -- * Tuples
41         mkTupleTy,
42         tupleTyCon, tupleCon, 
43         unitTyCon, unitDataCon, unitDataConId, pairTyCon, 
44         unboxedSingletonTyCon, unboxedSingletonDataCon,
45         unboxedPairTyCon, unboxedPairDataCon,
46
47         -- * Unit
48         unitTy,
49
50         -- * Parallel arrays
51         mkPArrTy,
52         parrTyCon, parrFakeCon, isPArrTyCon, isPArrFakeCon,
53         parrTyCon_RDR, parrTyConName
54     ) where
55
56 #include "HsVersions.h"
57
58 import {-# SOURCE #-} MkId( mkDataConIds )
59
60 -- friends:
61 import PrelNames
62 import TysPrim
63
64 -- others:
65 import Constants        ( mAX_TUPLE_SIZE )
66 import Module           ( Module )
67 import RdrName
68 import Name
69 import DataCon          ( DataCon, mkDataCon, dataConWorkId, dataConSourceArity )
70 import Var
71 import TyCon            ( TyCon, AlgTyConRhs(DataTyCon), tyConDataCons,
72                           mkTupleTyCon, mkAlgTyCon, tyConName,
73                           TyConParent(NoParentTyCon) )
74
75 import BasicTypes       ( Arity, RecFlag(..), Boxity(..), isBoxed,
76                           StrictnessMark(..) )
77
78 import Type             ( Type, mkTyConTy, mkTyConApp, mkTyVarTy, mkTyVarTys,
79                           TyThing(..) )
80 import Coercion         ( unsafeCoercionTyCon, symCoercionTyCon,
81                           transCoercionTyCon, leftCoercionTyCon, 
82                           rightCoercionTyCon, instCoercionTyCon )
83 import TypeRep          ( mkArrowKinds, liftedTypeKind, ubxTupleKind )
84 import Unique           ( incrUnique, mkTupleTyConUnique,
85                           mkTupleDataConUnique, mkPArrDataConUnique )
86 import Data.Array
87 import FastString
88 import Outputable
89
90 alpha_tyvar :: [TyVar]
91 alpha_tyvar = [alphaTyVar]
92
93 alpha_ty :: [Type]
94 alpha_ty = [alphaTy]
95 \end{code}
96
97
98 %************************************************************************
99 %*                                                                      *
100 \subsection{Wired in type constructors}
101 %*                                                                      *
102 %************************************************************************
103
104 If you change which things are wired in, make sure you change their
105 names in PrelNames, so they use wTcQual, wDataQual, etc
106
107 \begin{code}
108 wiredInTyCons :: [TyCon]        -- Excludes tuples
109 -- This list is used only to define PrelInfo.wiredInThings
110
111 -- It does not need to include kind constructors, because
112 -- all that wiredInThings does is to initialise the Name table,
113 -- and kind constructors don't appear in source code.
114
115 wiredInTyCons = [ unitTyCon     -- Not treated like other tuples, because
116                                 -- it's defined in GHC.Base, and there's only
117                                 -- one of it.  We put it in wiredInTyCons so
118                                 -- that it'll pre-populate the name cache, so
119                                 -- the special case in lookupOrigNameCache 
120                                 -- doesn't need to look out for it
121               , boolTyCon
122               , charTyCon
123               , doubleTyCon
124               , floatTyCon
125               , intTyCon
126               , listTyCon
127               , parrTyCon
128               , unsafeCoercionTyCon
129               , symCoercionTyCon
130               , transCoercionTyCon
131               , leftCoercionTyCon
132               , rightCoercionTyCon
133               , instCoercionTyCon
134               ]
135 \end{code}
136
137 \begin{code}
138 mkWiredInTyConName :: BuiltInSyntax -> Module -> FastString -> Unique -> TyCon -> Name
139 mkWiredInTyConName built_in modu fs unique tycon
140   = mkWiredInName modu (mkTcOccFS fs) unique
141                   (ATyCon tycon)        -- Relevant TyCon
142                   built_in
143
144 mkWiredInDataConName :: BuiltInSyntax -> Module -> FastString -> Unique -> DataCon -> Name
145 mkWiredInDataConName built_in modu fs unique datacon
146   = mkWiredInName modu (mkDataOccFS fs) unique
147                   (ADataCon datacon)    -- Relevant DataCon
148                   built_in
149
150 charTyConName, charDataConName, intTyConName, intDataConName :: Name
151 charTyConName     = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Char") charTyConKey charTyCon
152 charDataConName   = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "C#") charDataConKey charDataCon
153 intTyConName      = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Int") intTyConKey   intTyCon
154 intDataConName    = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "I#") intDataConKey  intDataCon
155
156 boolTyConName, falseDataConName, trueDataConName :: Name
157 boolTyConName     = mkWiredInTyConName   UserSyntax gHC_BOOL (fsLit "Bool") boolTyConKey boolTyCon
158 falseDataConName  = mkWiredInDataConName UserSyntax gHC_BOOL (fsLit "False") falseDataConKey falseDataCon
159 trueDataConName   = mkWiredInDataConName UserSyntax gHC_BOOL (fsLit "True")  trueDataConKey  trueDataCon 
160
161 listTyConName, nilDataConName, consDataConName :: Name
162 listTyConName     = mkWiredInTyConName   BuiltInSyntax gHC_TYPES (fsLit "[]") listTyConKey listTyCon
163 nilDataConName    = mkWiredInDataConName BuiltInSyntax gHC_TYPES (fsLit "[]") nilDataConKey nilDataCon 
164 consDataConName   = mkWiredInDataConName BuiltInSyntax gHC_TYPES (fsLit ":") consDataConKey consDataCon
165
166 floatTyConName, floatDataConName, doubleTyConName, doubleDataConName :: Name
167 floatTyConName     = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Float") floatTyConKey floatTyCon
168 floatDataConName   = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "F#") floatDataConKey floatDataCon
169 doubleTyConName    = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Double") doubleTyConKey doubleTyCon
170 doubleDataConName  = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "D#") doubleDataConKey doubleDataCon
171
172 parrTyConName, parrDataConName :: Name
173 parrTyConName     = mkWiredInTyConName   BuiltInSyntax gHC_PARR (fsLit "[::]") parrTyConKey parrTyCon 
174 parrDataConName   = mkWiredInDataConName UserSyntax    gHC_PARR (fsLit "PArr") parrDataConKey parrDataCon
175
176 boolTyCon_RDR, false_RDR, true_RDR, intTyCon_RDR, charTyCon_RDR,
177     intDataCon_RDR, listTyCon_RDR, consDataCon_RDR, parrTyCon_RDR:: RdrName
178 boolTyCon_RDR   = nameRdrName boolTyConName
179 false_RDR       = nameRdrName falseDataConName
180 true_RDR        = nameRdrName trueDataConName
181 intTyCon_RDR    = nameRdrName intTyConName
182 charTyCon_RDR   = nameRdrName charTyConName
183 intDataCon_RDR  = nameRdrName intDataConName
184 listTyCon_RDR   = nameRdrName listTyConName
185 consDataCon_RDR = nameRdrName consDataConName
186 parrTyCon_RDR   = nameRdrName parrTyConName
187 {-
188 tySuperKindTyCon_RDR     = nameRdrName tySuperKindTyConName
189 coSuperKindTyCon_RDR = nameRdrName coSuperKindTyConName
190 liftedTypeKindTyCon_RDR   = nameRdrName liftedTypeKindTyConName
191 openTypeKindTyCon_RDR     = nameRdrName openTypeKindTyConName
192 unliftedTypeKindTyCon_RDR = nameRdrName unliftedTypeKindTyConName
193 ubxTupleKindTyCon_RDR     = nameRdrName ubxTupleKindTyConName
194 argTypeKindTyCon_RDR      = nameRdrName argTypeKindTyConName
195 funKindTyCon_RDR          = nameRdrName funKindTyConName
196 -}
197 \end{code}
198
199
200 %************************************************************************
201 %*                                                                      *
202 \subsection{mkWiredInTyCon}
203 %*                                                                      *
204 %************************************************************************
205
206 \begin{code}
207 pcNonRecDataTyCon :: Name -> [TyVar] -> [DataCon] -> TyCon
208 pcNonRecDataTyCon = pcTyCon False NonRecursive
209 pcRecDataTyCon :: Name -> [TyVar] -> [DataCon] -> TyCon
210 pcRecDataTyCon    = pcTyCon False Recursive
211
212 pcTyCon :: Bool -> RecFlag -> Name -> [TyVar] -> [DataCon] -> TyCon
213 pcTyCon is_enum is_rec name tyvars cons
214   = tycon
215   where
216     tycon = mkAlgTyCon name
217                 (mkArrowKinds (map tyVarKind tyvars) liftedTypeKind)
218                 tyvars
219                 []              -- No stupid theta
220                 (DataTyCon cons is_enum)
221                 NoParentTyCon
222                 is_rec
223                 True            -- All the wired-in tycons have generics
224                 False           -- Not in GADT syntax
225
226 pcDataCon :: Name -> [TyVar] -> [Type] -> TyCon -> DataCon
227 pcDataCon = pcDataConWithFixity False
228
229 pcDataConWithFixity :: Bool -> Name -> [TyVar] -> [Type] -> TyCon -> DataCon
230 -- The Name should be in the DataName name space; it's the name
231 -- of the DataCon itself.
232 --
233 -- The unique is the first of two free uniques;
234 -- the first is used for the datacon itself,
235 -- the second is used for the "worker name"
236
237 pcDataConWithFixity declared_infix dc_name tyvars arg_tys tycon
238   = data_con
239   where
240     data_con = mkDataCon dc_name declared_infix
241                 (map (const NotMarkedStrict) arg_tys)
242                 []      -- No labelled fields
243                 tyvars
244                 []      -- No existential type variables
245                 []      -- No equality spec
246                 []      -- No theta
247                 arg_tys (mkTyConApp tycon (mkTyVarTys tyvars)) 
248                 tycon
249                 []      -- No stupid theta
250                 (mkDataConIds bogus_wrap_name wrk_name data_con)
251                 
252
253     modu     = ASSERT( isExternalName dc_name ) 
254                nameModule dc_name
255     wrk_occ  = mkDataConWorkerOcc (nameOccName dc_name)
256     wrk_key  = incrUnique (nameUnique dc_name)
257     wrk_name = mkWiredInName modu wrk_occ wrk_key
258                              (AnId (dataConWorkId data_con)) UserSyntax
259     bogus_wrap_name = pprPanic "Wired-in data wrapper id" (ppr dc_name)
260         -- Wired-in types are too simple to need wrappers
261 \end{code}
262
263
264 %************************************************************************
265 %*                                                                      *
266 \subsection[TysWiredIn-tuples]{The tuple types}
267 %*                                                                      *
268 %************************************************************************
269
270 \begin{code}
271 tupleTyCon :: Boxity -> Arity -> TyCon
272 tupleTyCon boxity i | i > mAX_TUPLE_SIZE = fst (mk_tuple boxity i)      -- Build one specially
273 tupleTyCon Boxed   i = fst (boxedTupleArr   ! i)
274 tupleTyCon Unboxed i = fst (unboxedTupleArr ! i)
275
276 tupleCon :: Boxity -> Arity -> DataCon
277 tupleCon boxity i | i > mAX_TUPLE_SIZE = snd (mk_tuple boxity i)        -- Build one specially
278 tupleCon Boxed   i = snd (boxedTupleArr   ! i)
279 tupleCon Unboxed i = snd (unboxedTupleArr ! i)
280
281 boxedTupleArr, unboxedTupleArr :: Array Int (TyCon,DataCon)
282 boxedTupleArr   = listArray (0,mAX_TUPLE_SIZE) [mk_tuple Boxed i | i <- [0..mAX_TUPLE_SIZE]]
283 unboxedTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple Unboxed i | i <- [0..mAX_TUPLE_SIZE]]
284
285 mk_tuple :: Boxity -> Int -> (TyCon,DataCon)
286 mk_tuple boxity arity = (tycon, tuple_con)
287   where
288         tycon   = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con boxity gen_info 
289         modu    = mkTupleModule boxity arity
290         tc_name = mkWiredInName modu (mkTupleOcc tcName boxity arity) tc_uniq
291                                 (ATyCon tycon) BuiltInSyntax
292         tc_kind = mkArrowKinds (map tyVarKind tyvars) res_kind
293         res_kind | isBoxed boxity = liftedTypeKind
294                  | otherwise      = ubxTupleKind
295
296         tyvars   | isBoxed boxity = take arity alphaTyVars
297                  | otherwise      = take arity openAlphaTyVars
298
299         tuple_con = pcDataCon dc_name tyvars tyvar_tys tycon
300         tyvar_tys = mkTyVarTys tyvars
301         dc_name   = mkWiredInName modu (mkTupleOcc dataName boxity arity) dc_uniq
302                                   (ADataCon tuple_con) BuiltInSyntax
303         tc_uniq   = mkTupleTyConUnique   boxity arity
304         dc_uniq   = mkTupleDataConUnique boxity arity
305         gen_info  = True                -- Tuples all have generics..
306                                         -- hmm: that's a *lot* of code
307
308 unitTyCon :: TyCon
309 unitTyCon     = tupleTyCon Boxed 0
310 unitDataCon :: DataCon
311 unitDataCon   = head (tyConDataCons unitTyCon)
312 unitDataConId :: Id
313 unitDataConId = dataConWorkId unitDataCon
314
315 pairTyCon :: TyCon
316 pairTyCon = tupleTyCon Boxed 2
317
318 unboxedSingletonTyCon :: TyCon
319 unboxedSingletonTyCon   = tupleTyCon Unboxed 1
320 unboxedSingletonDataCon :: DataCon
321 unboxedSingletonDataCon = tupleCon   Unboxed 1
322
323 unboxedPairTyCon :: TyCon
324 unboxedPairTyCon   = tupleTyCon Unboxed 2
325 unboxedPairDataCon :: DataCon
326 unboxedPairDataCon = tupleCon   Unboxed 2
327 \end{code}
328
329
330 %************************************************************************
331 %*                                                                      *
332 \subsection[TysWiredIn-boxed-prim]{The ``boxed primitive'' types (@Char@, @Int@, etc)}
333 %*                                                                      *
334 %************************************************************************
335
336 \begin{code}
337 charTy :: Type
338 charTy = mkTyConTy charTyCon
339
340 charTyCon :: TyCon
341 charTyCon   = pcNonRecDataTyCon charTyConName [] [charDataCon]
342 charDataCon :: DataCon
343 charDataCon = pcDataCon charDataConName [] [charPrimTy] charTyCon
344
345 stringTy :: Type
346 stringTy = mkListTy charTy -- convenience only
347 \end{code}
348
349 \begin{code}
350 intTy :: Type
351 intTy = mkTyConTy intTyCon 
352
353 intTyCon :: TyCon
354 intTyCon = pcNonRecDataTyCon intTyConName [] [intDataCon]
355 intDataCon :: DataCon
356 intDataCon = pcDataCon intDataConName [] [intPrimTy] intTyCon
357 \end{code}
358
359 \begin{code}
360 wordTy :: Type
361 wordTy = mkTyConTy wordTyCon 
362
363 wordTyCon :: TyCon
364 wordTyCon = pcNonRecDataTyCon wordTyConName [] [wordDataCon]
365 wordDataCon :: DataCon
366 wordDataCon = pcDataCon wordDataConName [] [wordPrimTy] wordTyCon
367 \end{code}
368
369 \begin{code}
370 floatTy :: Type
371 floatTy = mkTyConTy floatTyCon
372
373 floatTyCon :: TyCon
374 floatTyCon   = pcNonRecDataTyCon floatTyConName   [] [floatDataCon]
375 floatDataCon :: DataCon
376 floatDataCon = pcDataCon         floatDataConName [] [floatPrimTy] floatTyCon
377 \end{code}
378
379 \begin{code}
380 doubleTy :: Type
381 doubleTy = mkTyConTy doubleTyCon
382
383 doubleTyCon :: TyCon
384 doubleTyCon = pcNonRecDataTyCon doubleTyConName [] [doubleDataCon]
385
386 doubleDataCon :: DataCon
387 doubleDataCon = pcDataCon doubleDataConName [] [doublePrimTy] doubleTyCon
388 \end{code}
389
390
391 %************************************************************************
392 %*                                                                      *
393 \subsection[TysWiredIn-Bool]{The @Bool@ type}
394 %*                                                                      *
395 %************************************************************************
396
397 An ordinary enumeration type, but deeply wired in.  There are no
398 magical operations on @Bool@ (just the regular Prelude code).
399
400 {\em BEGIN IDLE SPECULATION BY SIMON}
401
402 This is not the only way to encode @Bool@.  A more obvious coding makes
403 @Bool@ just a boxed up version of @Bool#@, like this:
404 \begin{verbatim}
405 type Bool# = Int#
406 data Bool = MkBool Bool#
407 \end{verbatim}
408
409 Unfortunately, this doesn't correspond to what the Report says @Bool@
410 looks like!  Furthermore, we get slightly less efficient code (I
411 think) with this coding. @gtInt@ would look like this:
412
413 \begin{verbatim}
414 gtInt :: Int -> Int -> Bool
415 gtInt x y = case x of I# x# ->
416             case y of I# y# ->
417             case (gtIntPrim x# y#) of
418                 b# -> MkBool b#
419 \end{verbatim}
420
421 Notice that the result of the @gtIntPrim@ comparison has to be turned
422 into an integer (here called @b#@), and returned in a @MkBool@ box.
423
424 The @if@ expression would compile to this:
425 \begin{verbatim}
426 case (gtInt x y) of
427   MkBool b# -> case b# of { 1# -> e1; 0# -> e2 }
428 \end{verbatim}
429
430 I think this code is a little less efficient than the previous code,
431 but I'm not certain.  At all events, corresponding with the Report is
432 important.  The interesting thing is that the language is expressive
433 enough to describe more than one alternative; and that a type doesn't
434 necessarily need to be a straightforwardly boxed version of its
435 primitive counterpart.
436
437 {\em END IDLE SPECULATION BY SIMON}
438
439 \begin{code}
440 boolTy :: Type
441 boolTy = mkTyConTy boolTyCon
442
443 boolTyCon :: TyCon
444 boolTyCon = pcTyCon True NonRecursive boolTyConName
445                     [] [falseDataCon, trueDataCon]
446
447 falseDataCon, trueDataCon :: DataCon
448 falseDataCon = pcDataCon falseDataConName [] [] boolTyCon
449 trueDataCon  = pcDataCon trueDataConName  [] [] boolTyCon
450
451 falseDataConId, trueDataConId :: Id
452 falseDataConId = dataConWorkId falseDataCon
453 trueDataConId  = dataConWorkId trueDataCon
454 \end{code}
455
456 %************************************************************************
457 %*                                                                      *
458 \subsection[TysWiredIn-List]{The @List@ type (incl ``build'' magic)}
459 %*                                                                      *
460 %************************************************************************
461
462 Special syntax, deeply wired in, but otherwise an ordinary algebraic
463 data types:
464 \begin{verbatim}
465 data [] a = [] | a : (List a)
466 data () = ()
467 data (,) a b = (,,) a b
468 ...
469 \end{verbatim}
470
471 \begin{code}
472 mkListTy :: Type -> Type
473 mkListTy ty = mkTyConApp listTyCon [ty]
474
475 listTyCon :: TyCon
476 listTyCon = pcRecDataTyCon listTyConName alpha_tyvar [nilDataCon, consDataCon]
477
478 nilDataCon :: DataCon
479 nilDataCon  = pcDataCon nilDataConName alpha_tyvar [] listTyCon
480
481 consDataCon :: DataCon
482 consDataCon = pcDataConWithFixity True {- Declared infix -}
483                consDataConName
484                alpha_tyvar [alphaTy, mkTyConApp listTyCon alpha_ty] listTyCon
485 -- Interesting: polymorphic recursion would help here.
486 -- We can't use (mkListTy alphaTy) in the defn of consDataCon, else mkListTy
487 -- gets the over-specific type (Type -> Type)
488 \end{code}
489
490 %************************************************************************
491 %*                                                                      *
492 \subsection[TysWiredIn-Tuples]{The @Tuple@ types}
493 %*                                                                      *
494 %************************************************************************
495
496 The tuple types are definitely magic, because they form an infinite
497 family.
498
499 \begin{itemize}
500 \item
501 They have a special family of type constructors, of type @TyCon@
502 These contain the tycon arity, but don't require a Unique.
503
504 \item
505 They have a special family of constructors, of type
506 @Id@. Again these contain their arity but don't need a Unique.
507
508 \item
509 There should be a magic way of generating the info tables and
510 entry code for all tuples.
511
512 But at the moment we just compile a Haskell source
513 file\srcloc{lib/prelude/...} containing declarations like:
514 \begin{verbatim}
515 data Tuple0             = Tup0
516 data Tuple2  a b        = Tup2  a b
517 data Tuple3  a b c      = Tup3  a b c
518 data Tuple4  a b c d    = Tup4  a b c d
519 ...
520 \end{verbatim}
521 The print-names associated with the magic @Id@s for tuple constructors
522 ``just happen'' to be the same as those generated by these
523 declarations.
524
525 \item
526 The instance environment should have a magic way to know
527 that each tuple type is an instances of classes @Eq@, @Ix@, @Ord@ and
528 so on. \ToDo{Not implemented yet.}
529
530 \item
531 There should also be a way to generate the appropriate code for each
532 of these instances, but (like the info tables and entry code) it is
533 done by enumeration\srcloc{lib/prelude/InTup?.hs}.
534 \end{itemize}
535
536 \begin{code}
537 mkTupleTy :: Boxity -> Int -> [Type] -> Type
538 mkTupleTy boxity arity tys = mkTyConApp (tupleTyCon boxity arity) tys
539
540 unitTy :: Type
541 unitTy = mkTupleTy Boxed 0 []
542 \end{code}
543
544 %************************************************************************
545 %*                                                                      *
546 \subsection[TysWiredIn-PArr]{The @[::]@ type}
547 %*                                                                      *
548 %************************************************************************
549
550 Special syntax for parallel arrays needs some wired in definitions.
551
552 \begin{code}
553 -- | Construct a type representing the application of the parallel array constructor 
554 mkPArrTy    :: Type -> Type
555 mkPArrTy ty  = mkTyConApp parrTyCon [ty]
556
557 -- | Represents the type constructor of parallel arrays
558 --
559 --  * This must match the definition in @PrelPArr@
560 --
561 -- NB: Although the constructor is given here, it will not be accessible in
562 --     user code as it is not in the environment of any compiled module except
563 --     @PrelPArr@.
564 --
565 parrTyCon :: TyCon
566 parrTyCon  = pcNonRecDataTyCon parrTyConName alpha_tyvar [parrDataCon]
567
568 parrDataCon :: DataCon
569 parrDataCon  = pcDataCon 
570                  parrDataConName 
571                  alpha_tyvar            -- forall'ed type variables
572                  [intPrimTy,            -- 1st argument: Int#
573                   mkTyConApp            -- 2nd argument: Array# a
574                     arrayPrimTyCon 
575                     alpha_ty] 
576                  parrTyCon
577
578 -- | Check whether a type constructor is the constructor for parallel arrays
579 isPArrTyCon    :: TyCon -> Bool
580 isPArrTyCon tc  = tyConName tc == parrTyConName
581
582 -- | Fake array constructors
583 --
584 -- * These constructors are never really used to represent array values;
585 --   however, they are very convenient during desugaring (and, in particular,
586 --   in the pattern matching compiler) to treat array pattern just like
587 --   yet another constructor pattern
588 --
589 parrFakeCon                        :: Arity -> DataCon
590 parrFakeCon i | i > mAX_TUPLE_SIZE  = mkPArrFakeCon  i  -- build one specially
591 parrFakeCon i                       = parrFakeConArr!i
592
593 -- pre-defined set of constructors
594 --
595 parrFakeConArr :: Array Int DataCon
596 parrFakeConArr  = array (0, mAX_TUPLE_SIZE) [(i, mkPArrFakeCon i)   
597                                             | i <- [0..mAX_TUPLE_SIZE]]
598
599 -- build a fake parallel array constructor for the given arity
600 --
601 mkPArrFakeCon       :: Int -> DataCon
602 mkPArrFakeCon arity  = data_con
603   where
604         data_con  = pcDataCon name [tyvar] tyvarTys parrTyCon
605         tyvar     = head alphaTyVars
606         tyvarTys  = replicate arity $ mkTyVarTy tyvar
607         nameStr   = mkFastString ("MkPArr" ++ show arity)
608         name      = mkWiredInName gHC_PARR (mkDataOccFS nameStr) unique
609                                   (ADataCon data_con) UserSyntax
610         unique      = mkPArrDataConUnique arity
611
612 -- | Checks whether a data constructor is a fake constructor for parallel arrays
613 isPArrFakeCon      :: DataCon -> Bool
614 isPArrFakeCon dcon  = dcon == parrFakeCon (dataConSourceArity dcon)
615 \end{code}
616
617