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