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 -> [Type] -> Type
 538 -- Special case for *boxed* 1-tuples, which are represented by the type itself
 539 mkTupleTy boxity [ty] | Boxed <- boxity = ty
 540 mkTupleTy boxity tys = mkTyConApp (tupleTyCon boxity (length tys)) tys
 541
 542 unitTy :: Type
 543 unitTy = mkTupleTy Boxed []
 544 \end{code}
 545
 546 %************************************************************************
 547 %*                                                                      *
 548 \subsection[TysWiredIn-PArr]{The @[::]@ type}
 549 %*                                                                      *
 550 %************************************************************************
 551
 552 Special syntax for parallel arrays needs some wired in definitions.
 553
 554 \begin{code}
 555 -- | Construct a type representing the application of the parallel array constructor
 556 mkPArrTy    :: Type -> Type
 557 mkPArrTy ty  = mkTyConApp parrTyCon [ty]
 558
 559 -- | Represents the type constructor of parallel arrays
 560 --
 561 --  * This must match the definition in @PrelPArr@
 562 --
 563 -- NB: Although the constructor is given here, it will not be accessible in
 564 --     user code as it is not in the environment of any compiled module except
 565 --     @PrelPArr@.
 566 --
 567 parrTyCon :: TyCon
 568 parrTyCon  = pcNonRecDataTyCon parrTyConName alpha_tyvar [parrDataCon]
 569
 570 parrDataCon :: DataCon
 571 parrDataCon  = pcDataCon
 572                  parrDataConName
 573                  alpha_tyvar            -- forall'ed type variables
 574                  [intPrimTy,            -- 1st argument: Int#
 575                   mkTyConApp            -- 2nd argument: Array# a
 576                     arrayPrimTyCon
 577                     alpha_ty]
 578                  parrTyCon
 579
 580 -- | Check whether a type constructor is the constructor for parallel arrays
 581 isPArrTyCon    :: TyCon -> Bool
 582 isPArrTyCon tc  = tyConName tc == parrTyConName
 583
 584 -- | Fake array constructors
 585 --
 586 -- * These constructors are never really used to represent array values;
 587 --   however, they are very convenient during desugaring (and, in particular,
 588 --   in the pattern matching compiler) to treat array pattern just like
 589 --   yet another constructor pattern
 590 --
 591 parrFakeCon                        :: Arity -> DataCon
 592 parrFakeCon i | i > mAX_TUPLE_SIZE  = mkPArrFakeCon  i  -- build one specially
 593 parrFakeCon i                       = parrFakeConArr!i
 594
 595 -- pre-defined set of constructors
 596 --
 597 parrFakeConArr :: Array Int DataCon
 598 parrFakeConArr  = array (0, mAX_TUPLE_SIZE) [(i, mkPArrFakeCon i)
 599                                             | i <- [0..mAX_TUPLE_SIZE]]
 600
 601 -- build a fake parallel array constructor for the given arity
 602 --
 603 mkPArrFakeCon       :: Int -> DataCon
 604 mkPArrFakeCon arity  = data_con
 605   where
 606         data_con  = pcDataCon name [tyvar] tyvarTys parrTyCon
 607         tyvar     = head alphaTyVars
 608         tyvarTys  = replicate arity $ mkTyVarTy tyvar
 609         nameStr   = mkFastString ("MkPArr" ++ show arity)
 610         name      = mkWiredInName gHC_PARR (mkDataOccFS nameStr) unique
 611                                   (ADataCon data_con) UserSyntax
 612         unique      = mkPArrDataConUnique arity
 613
 614 -- | Checks whether a data constructor is a fake constructor for parallel arrays
 615 isPArrFakeCon      :: DataCon -> Bool
 616 isPArrFakeCon dcon  = dcon == parrFakeCon (dataConSourceArity dcon)
 617 \end{code}
 618
 619