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