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