ghc/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         addrDataCon,
  15         addrTy,
  16         addrTyCon,
  17         boolTy,
  18         boolTyCon,
  19         charDataCon,
  20         charTy,
  21         charTyCon,
  22         consDataCon,
  23         doubleDataCon,
  24         doubleTy,
  25         isDoubleTy,
  26         doubleTyCon,
  27         falseDataCon,
  28         floatDataCon,
  29         floatTy,
  30         isFloatTy,
  31         floatTyCon,
  32
  33         intDataCon,
  34         intTy,
  35         intTyCon,
  36         isIntTy,
  37         inIntRange,
  38
  39         integerTy,
  40         integerTyCon,
  41         smallIntegerDataCon,
  42         largeIntegerDataCon,
  43         isIntegerTy,
  44
  45         listTyCon,
  46
  47         mkListTy,
  48         nilDataCon,
  49
  50         -- tuples
  51         mkTupleTy,
  52         tupleTyCon, tupleCon, unitTyCon, unitDataCon, pairTyCon, pairDataCon,
  53
  54         -- unboxed tuples
  55         mkUnboxedTupleTy,
  56         unboxedTupleTyCon, unboxedTupleCon,
  57         unboxedPairTyCon, unboxedPairDataCon,
  58
  59         stablePtrTyCon,
  60         stringTy,
  61         trueDataCon,
  62         unitTy,
  63         voidTy,
  64         wordDataCon,
  65         wordTy,
  66         wordTyCon,
  67
  68         isFFIArgumentTy,  -- :: Bool -> Type -> Bool
  69         isFFIResultTy,    -- :: Type -> Bool
  70         isFFIExternalTy,  -- :: Type -> Bool
  71         isAddrTy,         -- :: Type -> Bool
  72         isForeignObjTy    -- :: Type -> Bool
  73
  74     ) where
  75
  76 #include "HsVersions.h"
  77
  78 import {-# SOURCE #-} MkId( mkDataConId )
  79
  80 -- friends:
  81 import PrelMods
  82 import TysPrim
  83
  84 -- others:
  85 import Constants        ( mAX_TUPLE_SIZE )
  86 import Module           ( Module, mkPrelModule )
  87 import Name             ( mkWiredInTyConName, mkWiredInIdName, mkSrcOccFS, dataName )
  88 import DataCon          ( DataCon, StrictnessMark(..),  mkDataCon )
  89 import Var              ( TyVar, tyVarKind )
  90 import TyCon            ( TyCon, ArgVrcs, mkAlgTyCon, mkSynTyCon, mkTupleTyCon )
  91 import BasicTypes       ( Arity, NewOrData(..), RecFlag(..) )
  92 import Type             ( Type, mkTyConTy, mkTyConApp, mkSigmaTy, mkTyVarTys,
  93                           mkArrowKinds, boxedTypeKind, unboxedTypeKind,
  94                           mkFunTy, mkFunTys, isUnLiftedType,
  95                           splitTyConApp_maybe, splitAlgTyConApp_maybe,
  96                           ThetaType, TauType )
  97 import PrimRep          ( PrimRep(..) )
  98 import Unique
  99 import CmdLineOpts      ( opt_GlasgowExts )
 100 import Util             ( assoc )
 101 import Panic            ( panic )
 102 import Array
 103
 104 alpha_tyvar       = [alphaTyVar]
 105 alpha_ty          = [alphaTy]
 106 alpha_beta_tyvars = [alphaTyVar, betaTyVar]
 107
 108 pcRecDataTyCon, pcNonRecDataTyCon, pcNonRecNewTyCon
 109         :: Unique{-TyConKey-} -> Module -> FAST_STRING
 110         -> [TyVar] -> ArgVrcs -> [DataCon] -> TyCon
 111
 112 pcRecDataTyCon    = pcTyCon DataType Recursive
 113 pcNonRecDataTyCon = pcTyCon DataType NonRecursive
 114 pcNonRecNewTyCon  = pcTyCon NewType  NonRecursive
 115
 116 pcTyCon new_or_data is_rec key mod str tyvars argvrcs cons
 117   = tycon
 118   where
 119     tycon = mkAlgTyCon name kind
 120                 tyvars
 121                 []              -- No context
 122                 argvrcs
 123                 cons
 124                 []              -- No derivings
 125                 Nothing         -- Not a dictionary
 126                 new_or_data
 127                 is_rec
 128
 129     name = mkWiredInTyConName key mod str tycon
 130     kind = mkArrowKinds (map tyVarKind tyvars) boxedTypeKind
 131
 132 pcSynTyCon key mod str kind arity tyvars expansion argvrcs  -- this fun never used!
 133   = tycon
 134   where
 135     tycon = mkSynTyCon name kind arity tyvars expansion argvrcs
 136     name  = mkWiredInTyConName key mod str tycon
 137
 138 pcDataCon :: Unique{-DataConKey-} -> Module -> FAST_STRING
 139           -> [TyVar] -> ThetaType -> [TauType] -> TyCon -> DataCon
 140 pcDataCon key mod str tyvars context arg_tys tycon
 141   = data_con
 142   where
 143     data_con = mkDataCon name
 144                 [ NotMarkedStrict | a <- arg_tys ]
 145                 [ {- no labelled fields -} ]
 146                 tyvars context [] [] arg_tys tycon id
 147     name = mkWiredInIdName key mod (mkSrcOccFS dataName str) id
 148     id   = mkDataConId data_con
 149 \end{code}
 150
 151 %************************************************************************
 152 %*                                                                      *
 153 \subsection[TysWiredIn-tuples]{The tuple types}
 154 %*                                                                      *
 155 %************************************************************************
 156
 157 \begin{code}
 158 tupleTyCon :: Arity -> TyCon
 159 tupleTyCon i | i > mAX_TUPLE_SIZE = fst (mk_tuple i)    -- Build one specially
 160              | otherwise          = tupleTyConArr!i
 161
 162 tupleCon :: Arity -> DataCon
 163 tupleCon i | i > mAX_TUPLE_SIZE = snd (mk_tuple i)      -- Build one specially
 164            | otherwise          = tupleConArr!i
 165
 166 tupleTyCons :: [TyCon]
 167 tupleTyCons = elems tupleTyConArr
 168
 169 tupleTyConArr :: Array Int TyCon
 170 tupleTyConArr = array (0,mAX_TUPLE_SIZE) ([0..] `zip` map fst tuples)
 171
 172 tupleConArr :: Array Int DataCon
 173 tupleConArr = array (0,mAX_TUPLE_SIZE) ([0..] `zip` map snd tuples)
 174
 175 tuples :: [(TyCon,DataCon)]
 176 tuples = [mk_tuple i | i <- [0..mAX_TUPLE_SIZE]]
 177
 178 mk_tuple :: Int -> (TyCon,DataCon)
 179 mk_tuple arity = (tycon, tuple_con)
 180   where
 181         tycon   = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con True
 182         tc_name = mkWiredInTyConName tc_uniq mod name_str tycon
 183         tc_kind = mkArrowKinds (map tyVarKind tyvars) boxedTypeKind
 184
 185         tuple_con = pcDataCon dc_uniq mod name_str tyvars [] tyvar_tys tycon
 186         tyvars    = take arity alphaTyVars
 187         tyvar_tys = mkTyVarTys tyvars
 188         (mod_name, name_str) = mkTupNameStr arity
 189         tc_uniq   = mkTupleTyConUnique   arity
 190         dc_uniq   = mkTupleDataConUnique arity
 191         mod       = mkPrelModule mod_name
 192
 193 unitTyCon = tupleTyCon 0
 194 pairTyCon = tupleTyCon 2
 195
 196 unitDataCon = tupleCon 0
 197 pairDataCon = tupleCon 2
 198 \end{code}
 199
 200 %************************************************************************
 201 %*                                                                      *
 202 \subsection[TysWiredIn-ubx-tuples]{Unboxed Tuple Types}
 203 %*                                                                      *
 204 %************************************************************************
 205
 206 \begin{code}
 207 unboxedTupleTyCon :: Arity -> TyCon
 208 unboxedTupleTyCon i | i > mAX_TUPLE_SIZE = fst (mk_unboxed_tuple i)
 209                     | otherwise          = unboxedTupleTyConArr!i
 210
 211 unboxedTupleCon :: Arity -> DataCon
 212 unboxedTupleCon i | i > mAX_TUPLE_SIZE = snd (mk_unboxed_tuple i)
 213                   | otherwise          = unboxedTupleConArr!i
 214
 215 unboxedTupleTyConArr :: Array Int TyCon
 216 unboxedTupleTyConArr = array (0,mAX_TUPLE_SIZE) ([0..] `zip` map fst ubx_tuples)
 217
 218 unboxedTupleConArr :: Array Int DataCon
 219 unboxedTupleConArr = array (0,mAX_TUPLE_SIZE) ([0..] `zip` map snd ubx_tuples)
 220
 221 ubx_tuples :: [(TyCon,DataCon)]
 222 ubx_tuples = [mk_unboxed_tuple i | i <- [0..mAX_TUPLE_SIZE]]
 223
 224 mk_unboxed_tuple :: Int -> (TyCon,DataCon)
 225 mk_unboxed_tuple arity = (tycon, tuple_con)
 226   where
 227         tycon   = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con False
 228         tc_name = mkWiredInTyConName tc_uniq mod name_str tycon
 229         tc_kind = mkArrowKinds (map tyVarKind tyvars) unboxedTypeKind
 230
 231         tuple_con = pcDataCon dc_uniq mod name_str tyvars [] tyvar_tys tycon
 232         tyvars    = take arity openAlphaTyVars
 233         tyvar_tys = mkTyVarTys tyvars
 234         (mod_name, name_str) = mkUbxTupNameStr arity
 235         tc_uniq   = mkUbxTupleTyConUnique   arity
 236         dc_uniq   = mkUbxTupleDataConUnique arity
 237         mod       = mkPrelModule mod_name
 238
 239 unboxedPairTyCon   = unboxedTupleTyCon 2
 240 unboxedPairDataCon = unboxedTupleCon 2
 241 \end{code}
 242
 243 %************************************************************************
 244 %*                                                                      *
 245 \subsection[TysWiredIn-boxed-prim]{The ``boxed primitive'' types (@Char@, @Int@, etc)}
 246 %*                                                                      *
 247 %************************************************************************
 248
 249 \begin{code}
 250 -- The Void type is represented as a data type with no constructors
 251 -- It's a built in type (i.e. there's no way to define it in Haskell;
 252 --      the nearest would be
 253 --
 254 --              data Void =             -- No constructors!
 255 --
 256 -- ) It's boxed; there is only one value of this
 257 -- type, namely "void", whose semantics is just bottom.
 258 --
 259 -- Haskell 98 drops the definition of a Void type, so we just 'simulate'
 260 -- voidTy using ().
 261 voidTy = unitTy
 262 \end{code}
 263
 264
 265 \begin{code}
 266 charTy = mkTyConTy charTyCon
 267
 268 charTyCon = pcNonRecDataTyCon charTyConKey  pREL_BASE  SLIT("Char") [] [] [charDataCon]
 269 charDataCon = pcDataCon charDataConKey pREL_BASE SLIT("C#") [] [] [charPrimTy] charTyCon
 270
 271 stringTy = mkListTy charTy -- convenience only
 272 \end{code}
 273
 274 \begin{code}
 275 intTy = mkTyConTy intTyCon
 276
 277 intTyCon = pcNonRecDataTyCon intTyConKey pREL_BASE SLIT("Int") [] [] [intDataCon]
 278 intDataCon = pcDataCon intDataConKey pREL_BASE SLIT("I#") [] [] [intPrimTy] intTyCon
 279
 280 isIntTy :: Type -> Bool
 281 isIntTy ty
 282   = case (splitAlgTyConApp_maybe ty) of
 283         Just (tycon, [], _) -> getUnique tycon == intTyConKey
 284         _                   -> False
 285
 286 inIntRange :: Integer -> Bool   -- Tells if an integer lies in the legal range of Ints
 287 inIntRange i = (min_int <= i) && (i <= max_int)
 288
 289 max_int, min_int :: Integer
 290 max_int = toInteger maxInt
 291 min_int = toInteger minInt
 292
 293 \end{code}
 294
 295 \begin{code}
 296
 297 wordTy = mkTyConTy wordTyCon
 298
 299 wordTyCon = pcNonRecDataTyCon wordTyConKey   pREL_ADDR SLIT("Word") [] [] [wordDataCon]
 300 wordDataCon = pcDataCon wordDataConKey pREL_ADDR SLIT("W#") [] [] [wordPrimTy] wordTyCon
 301 \end{code}
 302
 303 \begin{code}
 304 addrTy = mkTyConTy addrTyCon
 305
 306 addrTyCon = pcNonRecDataTyCon addrTyConKey   pREL_ADDR SLIT("Addr") [] [] [addrDataCon]
 307 addrDataCon = pcDataCon addrDataConKey pREL_ADDR SLIT("A#") [] [] [addrPrimTy] addrTyCon
 308
 309 isAddrTy :: Type -> Bool
 310 isAddrTy ty
 311   = case (splitAlgTyConApp_maybe ty) of
 312         Just (tycon, [], _) -> getUnique tycon == addrTyConKey
 313         _                   -> False
 314
 315 \end{code}
 316
 317 \begin{code}
 318 floatTy = mkTyConTy floatTyCon
 319
 320 floatTyCon = pcNonRecDataTyCon floatTyConKey pREL_FLOAT SLIT("Float") [] [] [floatDataCon]
 321 floatDataCon = pcDataCon floatDataConKey pREL_FLOAT SLIT("F#") [] [] [floatPrimTy] floatTyCon
 322
 323 isFloatTy :: Type -> Bool
 324 isFloatTy ty
 325   = case (splitAlgTyConApp_maybe ty) of
 326         Just (tycon, [], _) -> getUnique tycon == floatTyConKey
 327         _                   -> False
 328
 329 \end{code}
 330
 331 \begin{code}
 332 doubleTy = mkTyConTy doubleTyCon
 333
 334 isDoubleTy :: Type -> Bool
 335 isDoubleTy ty
 336   = case (splitAlgTyConApp_maybe ty) of
 337         Just (tycon, [], _) -> getUnique tycon == doubleTyConKey
 338         _                   -> False
 339
 340 doubleTyCon = pcNonRecDataTyCon doubleTyConKey pREL_FLOAT SLIT("Double") [] [] [doubleDataCon]
 341 doubleDataCon = pcDataCon doubleDataConKey pREL_FLOAT SLIT("D#") [] [] [doublePrimTy] doubleTyCon
 342 \end{code}
 343
 344 \begin{code}
 345 stablePtrTyCon
 346   = pcNonRecDataTyCon stablePtrTyConKey pREL_STABLE SLIT("StablePtr")
 347         alpha_tyvar [(True,False)] [stablePtrDataCon]
 348   where
 349     stablePtrDataCon
 350       = pcDataCon stablePtrDataConKey pREL_STABLE SLIT("StablePtr")
 351             alpha_tyvar [] [mkStablePtrPrimTy alphaTy] stablePtrTyCon
 352 \end{code}
 353
 354 \begin{code}
 355 foreignObjTyCon
 356   = pcNonRecDataTyCon foreignObjTyConKey pREL_IO_BASE SLIT("ForeignObj")
 357         [] [] [foreignObjDataCon]
 358   where
 359     foreignObjDataCon
 360       = pcDataCon foreignObjDataConKey pREL_IO_BASE SLIT("ForeignObj")
 361             [] [] [foreignObjPrimTy] foreignObjTyCon
 362 \end{code}
 363
 364 %************************************************************************
 365 %*                                                                      *
 366 \subsection[TysWiredIn-Integer]{@Integer@ and its related ``pairing'' types}
 367 %*                                                                      *
 368 %************************************************************************
 369
 370 @Integer@ and its pals are not really primitive.  @Integer@ itself, first:
 371 \begin{code}
 372 integerTy :: Type
 373 integerTy = mkTyConTy integerTyCon
 374
 375 integerTyCon = pcNonRecDataTyCon integerTyConKey pREL_NUM SLIT("Integer")
 376                    [] [] [smallIntegerDataCon, largeIntegerDataCon]
 377
 378 smallIntegerDataCon = pcDataCon smallIntegerDataConKey pREL_NUM SLIT("S#")
 379                 [] [] [intPrimTy] integerTyCon
 380 largeIntegerDataCon = pcDataCon largeIntegerDataConKey pREL_NUM SLIT("J#")
 381                 [] [] [intPrimTy, byteArrayPrimTy] integerTyCon
 382
 383
 384 isIntegerTy :: Type -> Bool
 385 isIntegerTy ty
 386   = case (splitAlgTyConApp_maybe ty) of
 387         Just (tycon, [], _) -> getUnique tycon == integerTyConKey
 388         _                   -> False
 389 \end{code}
 390
 391
 392 %************************************************************************
 393 %*                                                                      *
 394 \subsection[TysWiredIn-ext-type]{External types}
 395 %*                                                                      *
 396 %************************************************************************
 397
 398 The compiler's foreign function interface supports the passing of a
 399 restricted set of types as arguments and results (the restricting factor
 400 being the )
 401
 402 \begin{code}
 403 isFFIArgumentTy :: Bool -> Type -> Bool
 404 isFFIArgumentTy forASafeCall ty =
 405   (opt_GlasgowExts && isUnLiftedType ty) ||
 406   case (splitAlgTyConApp_maybe ty) of
 407     Just (tycon, _, _) ->
 408                 let
 409                  u = getUnique tycon
 410                 in
 411                 u `elem` primArgTyConKeys &&   -- it has a suitable prim type, and
 412                 (not forASafeCall || not ( u `elem` notSafeExternalTyCons)) -- it is safe to pass out.
 413     _                  -> False
 414
 415 -- types that can be passed as arguments to "foreign" functions
 416 primArgTyConKeys
 417   = [ intTyConKey, int8TyConKey, int16TyConKey, int32TyConKey, int64TyConKey
 418     , wordTyConKey, word8TyConKey, word16TyConKey, word32TyConKey, word64TyConKey
 419     , floatTyConKey, doubleTyConKey
 420     , addrTyConKey, charTyConKey, foreignObjTyConKey
 421     , stablePtrTyConKey
 422     , byteArrayTyConKey, mutableByteArrayTyConKey
 423     ]
 424
 425 -- types that can be passed from the outside world into Haskell.
 426 -- excludes (mutable) byteArrays.
 427 isFFIExternalTy :: Type -> Bool
 428 isFFIExternalTy ty =
 429   (opt_GlasgowExts && isUnLiftedType ty) || --leave out for now: maybeToBool (maybeBoxedPrimType ty))) ||
 430   case (splitAlgTyConApp_maybe ty) of
 431     Just (tycon, _, _) ->
 432        let
 433         u_tycon = getUnique tycon
 434        in
 435        (u_tycon `elem` primArgTyConKeys) &&
 436        not (u_tycon `elem` notLegalExternalTyCons)
 437     _                  -> False
 438
 439
 440 isFFIResultTy :: Type -> Bool
 441 isFFIResultTy ty =
 442    not (isUnLiftedType ty) &&
 443    case (splitAlgTyConApp_maybe ty) of
 444     Just (tycon, _, _) ->
 445         let
 446          u_tycon = getUnique tycon
 447         in
 448         (u_tycon == getUnique unitTyCon) ||
 449         ((u_tycon `elem` primArgTyConKeys) &&
 450          not (u_tycon `elem` notLegalExternalTyCons))
 451     _                  -> False
 452
 453 -- it's illegal to return foreign objects and (mutable)
 454 -- bytearrays from a _ccall_ / foreign declaration
 455 -- (or be passed them as arguments in foreign exported functions).
 456 notLegalExternalTyCons =
 457   [ foreignObjTyConKey, byteArrayTyConKey, mutableByteArrayTyConKey ]
 458
 459 -- it's really unsafe to pass out references to objects in the heap,
 460 -- so for safe call-outs we simply disallow it.
 461 notSafeExternalTyCons =
 462   [ byteArrayTyConKey, mutableByteArrayTyConKey ]
 463
 464
 465 isForeignObjTy :: Type -> Bool
 466 isForeignObjTy ty =
 467   case (splitAlgTyConApp_maybe ty) of
 468     Just (tycon, _, _) -> (getUnique tycon) == foreignObjTyConKey
 469     _                  -> False
 470
 471 \end{code}
 472
 473 %************************************************************************
 474 %*                                                                      *
 475 \subsection[TysWiredIn-Bool]{The @Bool@ type}
 476 %*                                                                      *
 477 %************************************************************************
 478
 479 An ordinary enumeration type, but deeply wired in.  There are no
 480 magical operations on @Bool@ (just the regular Prelude code).
 481
 482 {\em BEGIN IDLE SPECULATION BY SIMON}
 483
 484 This is not the only way to encode @Bool@.  A more obvious coding makes
 485 @Bool@ just a boxed up version of @Bool#@, like this:
 486 \begin{verbatim}
 487 type Bool# = Int#
 488 data Bool = MkBool Bool#
 489 \end{verbatim}
 490
 491 Unfortunately, this doesn't correspond to what the Report says @Bool@
 492 looks like!  Furthermore, we get slightly less efficient code (I
 493 think) with this coding. @gtInt@ would look like this:
 494
 495 \begin{verbatim}
 496 gtInt :: Int -> Int -> Bool
 497 gtInt x y = case x of I# x# ->
 498             case y of I# y# ->
 499             case (gtIntPrim x# y#) of
 500                 b# -> MkBool b#
 501 \end{verbatim}
 502
 503 Notice that the result of the @gtIntPrim@ comparison has to be turned
 504 into an integer (here called @b#@), and returned in a @MkBool@ box.
 505
 506 The @if@ expression would compile to this:
 507 \begin{verbatim}
 508 case (gtInt x y) of
 509   MkBool b# -> case b# of { 1# -> e1; 0# -> e2 }
 510 \end{verbatim}
 511
 512 I think this code is a little less efficient than the previous code,
 513 but I'm not certain.  At all events, corresponding with the Report is
 514 important.  The interesting thing is that the language is expressive
 515 enough to describe more than one alternative; and that a type doesn't
 516 necessarily need to be a straightforwardly boxed version of its
 517 primitive counterpart.
 518
 519 {\em END IDLE SPECULATION BY SIMON}
 520
 521 \begin{code}
 522 boolTy = mkTyConTy boolTyCon
 523
 524 boolTyCon = pcTyCon EnumType NonRecursive boolTyConKey
 525                     pREL_BASE SLIT("Bool") [] [] [falseDataCon, trueDataCon]
 526
 527 falseDataCon = pcDataCon falseDataConKey pREL_BASE SLIT("False") [] [] [] boolTyCon
 528 trueDataCon  = pcDataCon trueDataConKey  pREL_BASE SLIT("True")  [] [] [] boolTyCon
 529 \end{code}
 530
 531 %************************************************************************
 532 %*                                                                      *
 533 \subsection[TysWiredIn-List]{The @List@ type (incl ``build'' magic)}
 534 %*                                                                      *
 535 %************************************************************************
 536
 537 Special syntax, deeply wired in, but otherwise an ordinary algebraic
 538 data types:
 539 \begin{verbatim}
 540 data [] a = [] | a : (List a)
 541 data () = ()
 542 data (,) a b = (,,) a b
 543 ...
 544 \end{verbatim}
 545
 546 \begin{code}
 547 mkListTy :: Type -> Type
 548 mkListTy ty = mkTyConApp listTyCon [ty]
 549
 550 alphaListTy = mkSigmaTy alpha_tyvar [] (mkTyConApp listTyCon alpha_ty)
 551
 552 listTyCon = pcRecDataTyCon listTyConKey pREL_BASE SLIT("[]")
 553                         alpha_tyvar [(True,False)] [nilDataCon, consDataCon]
 554
 555 nilDataCon  = pcDataCon nilDataConKey  pREL_BASE SLIT("[]") alpha_tyvar [] [] listTyCon
 556 consDataCon = pcDataCon consDataConKey pREL_BASE SLIT(":")
 557                 alpha_tyvar [] [alphaTy, mkTyConApp listTyCon alpha_ty] listTyCon
 558 -- Interesting: polymorphic recursion would help here.
 559 -- We can't use (mkListTy alphaTy) in the defn of consDataCon, else mkListTy
 560 -- gets the over-specific type (Type -> Type)
 561 \end{code}
 562
 563 %************************************************************************
 564 %*                                                                      *
 565 \subsection[TysWiredIn-Tuples]{The @Tuple@ types}
 566 %*                                                                      *
 567 %************************************************************************
 568
 569 The tuple types are definitely magic, because they form an infinite
 570 family.
 571
 572 \begin{itemize}
 573 \item
 574 They have a special family of type constructors, of type @TyCon@
 575 These contain the tycon arity, but don't require a Unique.
 576
 577 \item
 578 They have a special family of constructors, of type
 579 @Id@. Again these contain their arity but don't need a Unique.
 580
 581 \item
 582 There should be a magic way of generating the info tables and
 583 entry code for all tuples.
 584
 585 But at the moment we just compile a Haskell source
 586 file\srcloc{lib/prelude/...} containing declarations like:
 587 \begin{verbatim}
 588 data Tuple0             = Tup0
 589 data Tuple2  a b        = Tup2  a b
 590 data Tuple3  a b c      = Tup3  a b c
 591 data Tuple4  a b c d    = Tup4  a b c d
 592 ...
 593 \end{verbatim}
 594 The print-names associated with the magic @Id@s for tuple constructors
 595 ``just happen'' to be the same as those generated by these
 596 declarations.
 597
 598 \item
 599 The instance environment should have a magic way to know
 600 that each tuple type is an instances of classes @Eq@, @Ix@, @Ord@ and
 601 so on. \ToDo{Not implemented yet.}
 602
 603 \item
 604 There should also be a way to generate the appropriate code for each
 605 of these instances, but (like the info tables and entry code) it is
 606 done by enumeration\srcloc{lib/prelude/InTup?.hs}.
 607 \end{itemize}
 608
 609 \begin{code}
 610 mkTupleTy :: Int -> [Type] -> Type
 611 mkTupleTy arity tys = mkTyConApp (tupleTyCon arity) tys
 612
 613 mkUnboxedTupleTy :: Int -> [Type] -> Type
 614 mkUnboxedTupleTy arity tys = mkTyConApp (unboxedTupleTyCon arity) tys
 615
 616 unitTy    = mkTupleTy 0 []
 617 \end{code}