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         wiredInTyCons, genericTyCons,
  15
  16         addrDataCon,
  17         addrTy,
  18         addrTyCon,
  19         boolTy,
  20         boolTyCon,
  21         charDataCon,
  22         charTy,
  23         charTyCon,
  24         consDataCon,
  25         doubleDataCon,
  26         doubleTy,
  27         isDoubleTy,
  28         doubleTyCon,
  29         falseDataCon, falseDataConId,
  30         floatDataCon,
  31         floatTy,
  32         isFloatTy,
  33         floatTyCon,
  34
  35         intDataCon,
  36         intTy,
  37         intTyCon,
  38         isIntTy,
  39
  40         integerTy,
  41         integerTyCon,
  42         smallIntegerDataCon,
  43         largeIntegerDataCon,
  44         isIntegerTy,
  45
  46         listTyCon,
  47
  48         mkListTy,
  49         nilDataCon,
  50
  51         -- tuples
  52         mkTupleTy,
  53         tupleTyCon, tupleCon,
  54         unitTyCon, unitDataConId, pairTyCon,
  55         unboxedSingletonTyCon, unboxedSingletonDataCon,
  56         unboxedPairTyCon, unboxedPairDataCon,
  57
  58         -- Generics
  59         genUnitTyCon, genUnitDataCon,
  60         plusTyCon, inrDataCon, inlDataCon,
  61         crossTyCon, crossDataCon,
  62
  63         stablePtrTyCon,
  64         stringTy,
  65         trueDataCon, trueDataConId,
  66         unitTy,
  67         voidTy,
  68         wordDataCon,
  69         wordTy,
  70         wordTyCon,
  71
  72         isFFIArgumentTy,    -- :: Bool -> Type -> Bool
  73         isFFIResultTy,      -- :: Type -> Bool
  74         isFFIExternalTy,    -- :: Type -> Bool
  75         isFFIDynArgumentTy, -- :: Type -> Bool
  76         isFFIDynResultTy,   -- :: Type -> Bool
  77         isFFILabelTy,       -- :: Type -> Bool
  78         isAddrTy,           -- :: Type -> Bool
  79         isForeignObjTy      -- :: Type -> Bool
  80
  81     ) where
  82
  83 #include "HsVersions.h"
  84
  85 import {-# SOURCE #-} MkId( mkDataConId, mkDataConWrapId )
  86 import {-# SOURCE #-} Generics( mkTyConGenInfo )
  87
  88 -- friends:
  89 import PrelNames
  90 import TysPrim
  91
  92 -- others:
  93 import Constants        ( mAX_TUPLE_SIZE )
  94 import Module           ( mkPrelModule )
  95 import Name             ( Name, nameRdrName, nameUnique, nameOccName,
  96                           nameModule, mkWiredInName )
  97 import OccName          ( mkOccFS, tcName, dataName, mkWorkerOcc, mkGenOcc1, mkGenOcc2 )
  98 import RdrName          ( rdrNameOcc )
  99 import DataCon          ( DataCon, StrictnessMark(..),  mkDataCon, dataConId )
 100 import Var              ( TyVar, tyVarKind )
 101 import TyCon            ( TyCon, AlgTyConFlavour(..), tyConDataCons,
 102                           mkTupleTyCon, isUnLiftedTyCon, mkAlgTyConRep
 103                         )
 104
 105 import BasicTypes       ( Arity, RecFlag(..), Boxity(..), isBoxed )
 106
 107 import Type             ( Type, mkTyConTy, mkTyConApp, mkTyVarTys,
 108                           mkArrowKinds, boxedTypeKind, unboxedTypeKind,
 109                           splitTyConApp_maybe, repType,
 110                           TauType, ClassContext )
 111 import Unique           ( incrUnique, mkTupleTyConUnique, mkTupleDataConUnique )
 112 import PrelNames
 113 import CmdLineOpts
 114 import Array
 115
 116 alpha_tyvar       = [alphaTyVar]
 117 alpha_ty          = [alphaTy]
 118 alpha_beta_tyvars = [alphaTyVar, betaTyVar]
 119 \end{code}
 120
 121
 122 %************************************************************************
 123 %*                                                                      *
 124 \subsection{Wired in type constructors}
 125 %*                                                                      *
 126 %************************************************************************
 127
 128 \begin{code}
 129 wiredInTyCons :: [TyCon]
 130 wiredInTyCons = data_tycons ++ tuple_tycons ++ unboxed_tuple_tycons
 131
 132 data_tycons = genericTyCons ++
 133               [ addrTyCon
 134               , boolTyCon
 135               , charTyCon
 136               , doubleTyCon
 137               , floatTyCon
 138               , intTyCon
 139               , integerTyCon
 140               , listTyCon
 141               , wordTyCon
 142               ]
 143
 144 genericTyCons :: [TyCon]
 145 genericTyCons = [ plusTyCon, crossTyCon, genUnitTyCon ]
 146
 147
 148 tuple_tycons = unitTyCon : [tupleTyCon Boxed i | i <- [2..37] ]
 149 unboxed_tuple_tycons = [tupleTyCon Unboxed i | i <- [1..37] ]
 150 \end{code}
 151
 152
 153 %************************************************************************
 154 %*                                                                      *
 155 \subsection{mkWiredInTyCon}
 156 %*                                                                      *
 157 %************************************************************************
 158
 159 \begin{code}
 160 pcNonRecDataTyCon = pcTyCon DataTyCon NonRecursive
 161 pcRecDataTyCon = pcTyCon DataTyCon Recursive
 162
 163 pcTyCon new_or_data is_rec name tyvars argvrcs cons
 164   = tycon
 165   where
 166     tycon = mkAlgTyConRep name kind
 167                 tyvars
 168                 []              -- No context
 169                 argvrcs
 170                 cons
 171                 (length cons)
 172                 new_or_data
 173                 is_rec
 174                 gen_info
 175
 176     mod      = nameModule name
 177     kind     = mkArrowKinds (map tyVarKind tyvars) boxedTypeKind
 178     gen_info = mk_tc_gen_info mod (nameUnique name) name tycon
 179
 180 pcDataCon :: Name -> [TyVar] -> ClassContext -> [TauType] -> TyCon -> DataCon
 181 -- The unique is the first of two free uniques;
 182 -- the first is used for the datacon itself and the worker;
 183 -- the second is used for the wrapper.
 184
 185 pcDataCon name tyvars context arg_tys tycon
 186   = data_con
 187   where
 188     data_con = mkDataCon name
 189                 [ NotMarkedStrict | a <- arg_tys ]
 190                 [ {- no labelled fields -} ]
 191                 tyvars context [] [] arg_tys tycon work_id wrap_id
 192
 193     wrap_rdr  = nameRdrName name
 194     wrap_occ  = rdrNameOcc wrap_rdr
 195
 196     mod       = nameModule name
 197     wrap_id   = mkDataConWrapId data_con
 198
 199     work_occ  = mkWorkerOcc wrap_occ
 200     work_key  = incrUnique (nameUnique name)
 201     work_name = mkWiredInName mod work_occ work_key
 202     work_id   = mkDataConId work_name data_con
 203 \end{code}
 204
 205
 206 %************************************************************************
 207 %*                                                                      *
 208 \subsection[TysWiredIn-tuples]{The tuple types}
 209 %*                                                                      *
 210 %************************************************************************
 211
 212 \begin{code}
 213 tupleTyCon :: Boxity -> Arity -> TyCon
 214 tupleTyCon boxity i | i > mAX_TUPLE_SIZE = fst (mk_tuple boxity i)      -- Build one specially
 215 tupleTyCon Boxed   i = fst (boxedTupleArr   ! i)
 216 tupleTyCon Unboxed i = fst (unboxedTupleArr ! i)
 217
 218 tupleCon :: Boxity -> Arity -> DataCon
 219 tupleCon boxity i | i > mAX_TUPLE_SIZE = snd (mk_tuple boxity i)        -- Build one specially
 220 tupleCon Boxed   i = snd (boxedTupleArr   ! i)
 221 tupleCon Unboxed i = snd (unboxedTupleArr ! i)
 222
 223 boxedTupleArr, unboxedTupleArr :: Array Int (TyCon,DataCon)
 224 boxedTupleArr   = array (0,mAX_TUPLE_SIZE) [(i,mk_tuple Boxed i)   | i <- [0..mAX_TUPLE_SIZE]]
 225 unboxedTupleArr = array (0,mAX_TUPLE_SIZE) [(i,mk_tuple Unboxed i) | i <- [0..mAX_TUPLE_SIZE]]
 226
 227 mk_tuple :: Boxity -> Int -> (TyCon,DataCon)
 228 mk_tuple boxity arity = (tycon, tuple_con)
 229   where
 230         tycon   = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con boxity gen_info
 231         tc_name = mkWiredInName mod (mkOccFS tcName name_str) tc_uniq
 232         tc_kind = mkArrowKinds (map tyVarKind tyvars) res_kind
 233         res_kind | isBoxed boxity = boxedTypeKind
 234                  | otherwise      = unboxedTypeKind
 235
 236         tyvars   | isBoxed boxity = take arity alphaTyVars
 237                  | otherwise      = take arity openAlphaTyVars
 238
 239         tuple_con = pcDataCon name tyvars [] tyvar_tys tycon
 240         tyvar_tys = mkTyVarTys tyvars
 241         (mod_name, name_str) = mkTupNameStr boxity arity
 242         name      = mkWiredInName mod (mkOccFS dataName name_str) dc_uniq
 243         tc_uniq   = mkTupleTyConUnique   boxity arity
 244         dc_uniq   = mkTupleDataConUnique boxity arity
 245         mod       = mkPrelModule mod_name
 246         gen_info  = mk_tc_gen_info mod tc_uniq tc_name tycon
 247
 248 mk_tc_gen_info mod tc_uniq tc_name tycon
 249   = gen_info
 250   where
 251         tc_occ_name = nameOccName tc_name
 252         occ_name1   = mkGenOcc1 tc_occ_name
 253         occ_name2   = mkGenOcc2 tc_occ_name
 254         fn1_key     = incrUnique tc_uniq
 255         fn2_key     = incrUnique fn1_key
 256         name1       = mkWiredInName  mod occ_name1 fn1_key
 257         name2       = mkWiredInName  mod occ_name2 fn2_key
 258         gen_info    = mkTyConGenInfo tycon name1 name2
 259
 260 unitTyCon     = tupleTyCon Boxed 0
 261 unitDataConId = dataConId (head (tyConDataCons unitTyCon))
 262
 263 pairTyCon = tupleTyCon Boxed 2
 264
 265 unboxedSingletonTyCon   = tupleTyCon Unboxed 1
 266 unboxedSingletonDataCon = tupleCon   Unboxed 1
 267
 268 unboxedPairTyCon   = tupleTyCon Unboxed 2
 269 unboxedPairDataCon = tupleCon   Unboxed 2
 270 \end{code}
 271
 272 %************************************************************************
 273 %*                                                                      *
 274 \subsection[TysWiredIn-boxed-prim]{The ``boxed primitive'' types (@Char@, @Int@, etc)}
 275 %*                                                                      *
 276 %************************************************************************
 277
 278 \begin{code}
 279 -- The Void type is represented as a data type with no constructors
 280 -- It's a built in type (i.e. there's no way to define it in Haskell;
 281 --      the nearest would be
 282 --
 283 --              data Void =             -- No constructors!
 284 --
 285 -- ) It's boxed; there is only one value of this
 286 -- type, namely "void", whose semantics is just bottom.
 287 --
 288 -- Haskell 98 drops the definition of a Void type, so we just 'simulate'
 289 -- voidTy using ().
 290 voidTy = unitTy
 291 \end{code}
 292
 293
 294 \begin{code}
 295 charTy = mkTyConTy charTyCon
 296
 297 charTyCon   = pcNonRecDataTyCon charTyConName [] [] [charDataCon]
 298 charDataCon = pcDataCon charDataConName [] [] [charPrimTy] charTyCon
 299
 300 stringTy = mkListTy charTy -- convenience only
 301 \end{code}
 302
 303 \begin{code}
 304 intTy = mkTyConTy intTyCon
 305
 306 intTyCon = pcNonRecDataTyCon intTyConName [] [] [intDataCon]
 307 intDataCon = pcDataCon intDataConName [] [] [intPrimTy] intTyCon
 308
 309 isIntTy :: Type -> Bool
 310 isIntTy = isTyCon intTyConKey
 311 \end{code}
 312
 313 \begin{code}
 314
 315 wordTy = mkTyConTy wordTyCon
 316
 317 wordTyCon = pcNonRecDataTyCon wordTyConName [] [] [wordDataCon]
 318 wordDataCon = pcDataCon wordDataConName [] [] [wordPrimTy] wordTyCon
 319 \end{code}
 320
 321 \begin{code}
 322 addrTy = mkTyConTy addrTyCon
 323
 324 addrTyCon = pcNonRecDataTyCon addrTyConName [] [] [addrDataCon]
 325 addrDataCon = pcDataCon addrDataConName [] [] [addrPrimTy] addrTyCon
 326
 327 isAddrTy :: Type -> Bool
 328 isAddrTy = isTyCon addrTyConKey
 329 \end{code}
 330
 331 \begin{code}
 332 floatTy = mkTyConTy floatTyCon
 333
 334 floatTyCon   = pcNonRecDataTyCon floatTyConName   [] [] [floatDataCon]
 335 floatDataCon = pcDataCon         floatDataConName [] [] [floatPrimTy] floatTyCon
 336
 337 isFloatTy :: Type -> Bool
 338 isFloatTy = isTyCon floatTyConKey
 339 \end{code}
 340
 341 \begin{code}
 342 doubleTy = mkTyConTy doubleTyCon
 343
 344 isDoubleTy :: Type -> Bool
 345 isDoubleTy = isTyCon doubleTyConKey
 346
 347 doubleTyCon   = pcNonRecDataTyCon doubleTyConName     [] [] [doubleDataCon]
 348 doubleDataCon = pcDataCon         doubleDataConName [] [] [doublePrimTy] doubleTyCon
 349 \end{code}
 350
 351 \begin{code}
 352 stablePtrTyCon
 353   = pcNonRecDataTyCon stablePtrTyConName
 354         alpha_tyvar [(True,False)] [stablePtrDataCon]
 355   where
 356     stablePtrDataCon
 357       = pcDataCon stablePtrDataConName
 358             alpha_tyvar [] [mkStablePtrPrimTy alphaTy] stablePtrTyCon
 359 \end{code}
 360
 361 \begin{code}
 362 foreignObjTyCon
 363   = pcNonRecDataTyCon foreignObjTyConName
 364         [] [] [foreignObjDataCon]
 365   where
 366     foreignObjDataCon
 367       = pcDataCon foreignObjDataConName
 368             [] [] [foreignObjPrimTy] foreignObjTyCon
 369
 370 isForeignObjTy :: Type -> Bool
 371 isForeignObjTy = isTyCon foreignObjTyConKey
 372 \end{code}
 373
 374 %************************************************************************
 375 %*                                                                      *
 376 \subsection[TysWiredIn-Integer]{@Integer@ and its related ``pairing'' types}
 377 %*                                                                      *
 378 %************************************************************************
 379
 380 @Integer@ and its pals are not really primitive.  @Integer@ itself, first:
 381 \begin{code}
 382 integerTy :: Type
 383 integerTy = mkTyConTy integerTyCon
 384
 385 integerTyCon = pcNonRecDataTyCon integerTyConName
 386                    [] [] [smallIntegerDataCon, largeIntegerDataCon]
 387
 388 smallIntegerDataCon = pcDataCon smallIntegerDataConName
 389                 [] [] [intPrimTy] integerTyCon
 390 largeIntegerDataCon = pcDataCon largeIntegerDataConName
 391                 [] [] [intPrimTy, byteArrayPrimTy] integerTyCon
 392
 393
 394 isIntegerTy :: Type -> Bool
 395 isIntegerTy = isTyCon integerTyConKey
 396 \end{code}
 397
 398
 399 %************************************************************************
 400 %*                                                                      *
 401 \subsection[TysWiredIn-ext-type]{External types}
 402 %*                                                                      *
 403 %************************************************************************
 404
 405 The compiler's foreign function interface supports the passing of a
 406 restricted set of types as arguments and results (the restricting factor
 407 being the )
 408
 409 \begin{code}
 410 isFFIArgumentTy :: DynFlags -> Bool -> Type -> Bool
 411 -- Checks for valid argument type for a 'foreign import'
 412 isFFIArgumentTy dflags is_safe ty
 413    = checkRepTyCon (legalOutgoingTyCon dflags is_safe) ty
 414
 415 isFFIExternalTy :: Type -> Bool
 416 -- Types that are allowed as arguments of a 'foreign export'
 417 isFFIExternalTy ty = checkRepTyCon legalIncomingTyCon ty
 418
 419 isFFIResultTy :: Type -> Bool
 420 -- Types that are allowed as a result of a 'foreign import' or of a 'foreign export'
 421 -- Maybe we should distinguish between import and export, but
 422 -- here we just choose the more restrictive 'incoming' predicate
 423 -- But we allow () as well
 424 isFFIResultTy ty = checkRepTyCon (\tc -> tc == unitTyCon || legalIncomingTyCon tc) ty
 425
 426 isFFIDynArgumentTy :: Type -> Bool
 427 -- The argument type of a foreign import dynamic must be either Addr, or
 428 -- a newtype of Addr.
 429 isFFIDynArgumentTy = checkRepTyCon (== addrTyCon)
 430
 431 isFFIDynResultTy :: Type -> Bool
 432 -- The result type of a foreign export dynamic must be either Addr, or
 433 -- a newtype of Addr.
 434 isFFIDynResultTy = checkRepTyCon (== addrTyCon)
 435
 436 isFFILabelTy :: Type -> Bool
 437 -- The type of a foreign label must be either Addr, or
 438 -- a newtype of Addr.
 439 isFFILabelTy = checkRepTyCon (== addrTyCon)
 440
 441 checkRepTyCon :: (TyCon -> Bool) -> Type -> Bool
 442         -- look through newtypes
 443 checkRepTyCon check_tc ty = checkTyCon check_tc (repType ty)
 444
 445 checkTyCon :: (TyCon -> Bool) -> Type -> Bool
 446 checkTyCon check_tc ty = case splitTyConApp_maybe ty of
 447                                 Just (tycon, _) -> check_tc tycon
 448                                 Nothing         -> False
 449
 450 isTyCon :: Unique -> Type -> Bool
 451 isTyCon uniq ty = checkTyCon (\tc -> uniq == getUnique tc) ty
 452 \end{code}
 453
 454 ----------------------------------------------
 455 These chaps do the work; they are not exported
 456 ----------------------------------------------
 457
 458 \begin{code}
 459 legalIncomingTyCon :: TyCon -> Bool
 460 -- It's illegal to return foreign objects and (mutable)
 461 -- bytearrays from a _ccall_ / foreign declaration
 462 -- (or be passed them as arguments in foreign exported functions).
 463 legalIncomingTyCon tc
 464   | getUnique tc `elem` [ foreignObjTyConKey, byteArrayTyConKey,
 465                                               mutableByteArrayTyConKey ]
 466   = False
 467   -- It's also illegal to make foreign exports that take unboxed
 468   -- arguments.  The RTS API currently can't invoke such things.  --SDM 7/2000
 469   | otherwise
 470   = boxedMarshalableTyCon tc
 471
 472 legalOutgoingTyCon :: DynFlags -> Bool -> TyCon -> Bool
 473 -- Checks validity of types going from Haskell -> external world
 474 -- The boolean is true for a 'safe' call (when we don't want to
 475 -- pass Haskell pointers to the world)
 476 legalOutgoingTyCon dflags be_safe tc
 477   | be_safe && getUnique tc `elem` [byteArrayTyConKey, mutableByteArrayTyConKey]
 478   = False
 479   | otherwise
 480   = marshalableTyCon dflags tc
 481
 482 marshalableTyCon dflags tc
 483   =  (dopt Opt_GlasgowExts dflags && isUnLiftedTyCon tc)
 484   || boxedMarshalableTyCon tc
 485
 486 boxedMarshalableTyCon tc
 487    = getUnique tc `elem` [ intTyConKey, int8TyConKey, int16TyConKey, int32TyConKey, int64TyConKey
 488                          , wordTyConKey, word8TyConKey, word16TyConKey, word32TyConKey, word64TyConKey
 489                          , floatTyConKey, doubleTyConKey
 490                          , addrTyConKey, charTyConKey, foreignObjTyConKey
 491                          , stablePtrTyConKey
 492                          , byteArrayTyConKey, mutableByteArrayTyConKey
 493                          , boolTyConKey
 494                          ]
 495 \end{code}
 496
 497
 498 %************************************************************************
 499 %*                                                                      *
 500 \subsection[TysWiredIn-Bool]{The @Bool@ type}
 501 %*                                                                      *
 502 %************************************************************************
 503
 504 An ordinary enumeration type, but deeply wired in.  There are no
 505 magical operations on @Bool@ (just the regular Prelude code).
 506
 507 {\em BEGIN IDLE SPECULATION BY SIMON}
 508
 509 This is not the only way to encode @Bool@.  A more obvious coding makes
 510 @Bool@ just a boxed up version of @Bool#@, like this:
 511 \begin{verbatim}
 512 type Bool# = Int#
 513 data Bool = MkBool Bool#
 514 \end{verbatim}
 515
 516 Unfortunately, this doesn't correspond to what the Report says @Bool@
 517 looks like!  Furthermore, we get slightly less efficient code (I
 518 think) with this coding. @gtInt@ would look like this:
 519
 520 \begin{verbatim}
 521 gtInt :: Int -> Int -> Bool
 522 gtInt x y = case x of I# x# ->
 523             case y of I# y# ->
 524             case (gtIntPrim x# y#) of
 525                 b# -> MkBool b#
 526 \end{verbatim}
 527
 528 Notice that the result of the @gtIntPrim@ comparison has to be turned
 529 into an integer (here called @b#@), and returned in a @MkBool@ box.
 530
 531 The @if@ expression would compile to this:
 532 \begin{verbatim}
 533 case (gtInt x y) of
 534   MkBool b# -> case b# of { 1# -> e1; 0# -> e2 }
 535 \end{verbatim}
 536
 537 I think this code is a little less efficient than the previous code,
 538 but I'm not certain.  At all events, corresponding with the Report is
 539 important.  The interesting thing is that the language is expressive
 540 enough to describe more than one alternative; and that a type doesn't
 541 necessarily need to be a straightforwardly boxed version of its
 542 primitive counterpart.
 543
 544 {\em END IDLE SPECULATION BY SIMON}
 545
 546 \begin{code}
 547 boolTy = mkTyConTy boolTyCon
 548
 549 boolTyCon = pcTyCon EnumTyCon NonRecursive boolTyConName
 550                     [] [] [falseDataCon, trueDataCon]
 551
 552 falseDataCon = pcDataCon falseDataConName [] [] [] boolTyCon
 553 trueDataCon  = pcDataCon trueDataConName  [] [] [] boolTyCon
 554
 555 falseDataConId = dataConId falseDataCon
 556 trueDataConId  = dataConId trueDataCon
 557 \end{code}
 558
 559 %************************************************************************
 560 %*                                                                      *
 561 \subsection[TysWiredIn-List]{The @List@ type (incl ``build'' magic)}
 562 %*                                                                      *
 563 %************************************************************************
 564
 565 Special syntax, deeply wired in, but otherwise an ordinary algebraic
 566 data types:
 567 \begin{verbatim}
 568 data [] a = [] | a : (List a)
 569 data () = ()
 570 data (,) a b = (,,) a b
 571 ...
 572 \end{verbatim}
 573
 574 \begin{code}
 575 mkListTy :: Type -> Type
 576 mkListTy ty = mkTyConApp listTyCon [ty]
 577
 578 listTyCon = pcRecDataTyCon listTyConName
 579                         alpha_tyvar [(True,False)] [nilDataCon, consDataCon]
 580
 581 nilDataCon  = pcDataCon nilDataConName alpha_tyvar [] [] listTyCon
 582 consDataCon = pcDataCon consDataConName
 583                alpha_tyvar [] [alphaTy, mkTyConApp listTyCon alpha_ty] listTyCon
 584 -- Interesting: polymorphic recursion would help here.
 585 -- We can't use (mkListTy alphaTy) in the defn of consDataCon, else mkListTy
 586 -- gets the over-specific type (Type -> Type)
 587 \end{code}
 588
 589 %************************************************************************
 590 %*                                                                      *
 591 \subsection[TysWiredIn-Tuples]{The @Tuple@ types}
 592 %*                                                                      *
 593 %************************************************************************
 594
 595 The tuple types are definitely magic, because they form an infinite
 596 family.
 597
 598 \begin{itemize}
 599 \item
 600 They have a special family of type constructors, of type @TyCon@
 601 These contain the tycon arity, but don't require a Unique.
 602
 603 \item
 604 They have a special family of constructors, of type
 605 @Id@. Again these contain their arity but don't need a Unique.
 606
 607 \item
 608 There should be a magic way of generating the info tables and
 609 entry code for all tuples.
 610
 611 But at the moment we just compile a Haskell source
 612 file\srcloc{lib/prelude/...} containing declarations like:
 613 \begin{verbatim}
 614 data Tuple0             = Tup0
 615 data Tuple2  a b        = Tup2  a b
 616 data Tuple3  a b c      = Tup3  a b c
 617 data Tuple4  a b c d    = Tup4  a b c d
 618 ...
 619 \end{verbatim}
 620 The print-names associated with the magic @Id@s for tuple constructors
 621 ``just happen'' to be the same as those generated by these
 622 declarations.
 623
 624 \item
 625 The instance environment should have a magic way to know
 626 that each tuple type is an instances of classes @Eq@, @Ix@, @Ord@ and
 627 so on. \ToDo{Not implemented yet.}
 628
 629 \item
 630 There should also be a way to generate the appropriate code for each
 631 of these instances, but (like the info tables and entry code) it is
 632 done by enumeration\srcloc{lib/prelude/InTup?.hs}.
 633 \end{itemize}
 634
 635 \begin{code}
 636 mkTupleTy :: Boxity -> Int -> [Type] -> Type
 637 mkTupleTy boxity arity tys = mkTyConApp (tupleTyCon boxity arity) tys
 638
 639 unitTy    = mkTupleTy Boxed 0 []
 640 \end{code}
 641
 642 %************************************************************************
 643 %*                                                                      *
 644 \subsection{Wired In Type Constructors for Representation Types}
 645 %*                                                                      *
 646 %************************************************************************
 647
 648 The following code defines the wired in datatypes cross, plus, unit
 649 and c_of needed for the generic methods.
 650
 651 Ok, so the basic story is that for each type constructor I need to
 652 create 2 things - a TyCon and a DataCon and then we are basically
 653 ok. There are going to be no arguments passed to these functions
 654 because -well- there is nothing to pass to these functions.
 655
 656 \begin{code}
 657 crossTyCon :: TyCon
 658 crossTyCon = pcNonRecDataTyCon crossTyConName alpha_beta_tyvars [] [crossDataCon]
 659
 660 crossDataCon :: DataCon
 661 crossDataCon = pcDataCon crossDataConName alpha_beta_tyvars [] [alphaTy, betaTy] crossTyCon
 662
 663 plusTyCon :: TyCon
 664 plusTyCon = pcNonRecDataTyCon plusTyConName alpha_beta_tyvars [] [inlDataCon, inrDataCon]
 665
 666 inlDataCon, inrDataCon :: DataCon
 667 inlDataCon = pcDataCon inlDataConName alpha_beta_tyvars [] [alphaTy] plusTyCon
 668 inrDataCon = pcDataCon inrDataConName alpha_beta_tyvars [] [betaTy]  plusTyCon
 669
 670 genUnitTyCon :: TyCon   -- The "1" type constructor for generics
 671 genUnitTyCon = pcNonRecDataTyCon genUnitTyConName [] [] [genUnitDataCon]
 672
 673 genUnitDataCon :: DataCon
 674 genUnitDataCon = pcDataCon genUnitDataConName [] [] [] genUnitTyCon
 675 \end{code}
 676
 677
 678
 679
 680