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