compiler/prelude/TysPrim.lhs

   1 %
   2 % (c) The AQUA Project, Glasgow University, 1994-1998
   3 %
   4 \section[TysPrim]{Wired-in knowledge about primitive types}
   5
   6 \begin{code}
   7 module TysPrim(
   8         alphaTyVars, betaTyVars, alphaTyVar, betaTyVar, gammaTyVar, deltaTyVar,
   9         alphaTy, betaTy, gammaTy, deltaTy,
  10         openAlphaTy, openAlphaTyVar, openAlphaTyVars,
  11
  12         primTyCons,
  13
  14         charPrimTyCon,          charPrimTy,
  15         intPrimTyCon,           intPrimTy,
  16         wordPrimTyCon,          wordPrimTy,
  17         addrPrimTyCon,          addrPrimTy,
  18         floatPrimTyCon,         floatPrimTy,
  19         doublePrimTyCon,        doublePrimTy,
  20
  21         statePrimTyCon,         mkStatePrimTy,
  22         realWorldTyCon,         realWorldTy, realWorldStatePrimTy,
  23
  24         arrayPrimTyCon,                 mkArrayPrimTy,
  25         byteArrayPrimTyCon,             byteArrayPrimTy,
  26         mutableArrayPrimTyCon,          mkMutableArrayPrimTy,
  27         mutableByteArrayPrimTyCon,      mkMutableByteArrayPrimTy,
  28         mutVarPrimTyCon,                mkMutVarPrimTy,
  29
  30         mVarPrimTyCon,                  mkMVarPrimTy,
  31         tVarPrimTyCon,                  mkTVarPrimTy,
  32         stablePtrPrimTyCon,             mkStablePtrPrimTy,
  33         stableNamePrimTyCon,            mkStableNamePrimTy,
  34         bcoPrimTyCon,                   bcoPrimTy,
  35         weakPrimTyCon,                  mkWeakPrimTy,
  36         threadIdPrimTyCon,              threadIdPrimTy,
  37
  38         int32PrimTyCon,         int32PrimTy,
  39         word32PrimTyCon,        word32PrimTy,
  40
  41         int64PrimTyCon,         int64PrimTy,
  42         word64PrimTyCon,        word64PrimTy
  43   ) where
  44
  45 #include "HsVersions.h"
  46
  47 import Var              ( TyVar, mkTyVar )
  48 import Name             ( Name, BuiltInSyntax(..), mkInternalName, mkWiredInName )
  49 import OccName          ( mkOccNameFS, tcName, mkTyVarOcc )
  50 import TyCon            ( TyCon, ArgVrcs, mkPrimTyCon, mkLiftedPrimTyCon,
  51                           PrimRep(..) )
  52 import Type             ( mkTyConApp, mkTyConTy, mkTyVarTys, mkTyVarTy,
  53                           unliftedTypeKind, liftedTypeKind, openTypeKind,
  54                           Kind, mkArrowKinds,
  55                           TyThing(..)
  56                         )
  57 import SrcLoc           ( noSrcLoc )
  58 import Unique           ( mkAlphaTyVarUnique )
  59 import PrelNames
  60 import FastString       ( FastString, mkFastString )
  61 import Outputable
  62
  63 import Char             ( ord, chr )
  64 \end{code}
  65
  66 %************************************************************************
  67 %*                                                                      *
  68 \subsection{Primitive type constructors}
  69 %*                                                                      *
  70 %************************************************************************
  71
  72 \begin{code}
  73 primTyCons :: [TyCon]
  74 primTyCons
  75   = [ addrPrimTyCon
  76     , arrayPrimTyCon
  77     , byteArrayPrimTyCon
  78     , charPrimTyCon
  79     , doublePrimTyCon
  80     , floatPrimTyCon
  81     , intPrimTyCon
  82     , int32PrimTyCon
  83     , int64PrimTyCon
  84     , bcoPrimTyCon
  85     , weakPrimTyCon
  86     , mutableArrayPrimTyCon
  87     , mutableByteArrayPrimTyCon
  88     , mVarPrimTyCon
  89     , tVarPrimTyCon
  90     , mutVarPrimTyCon
  91     , realWorldTyCon
  92     , stablePtrPrimTyCon
  93     , stableNamePrimTyCon
  94     , statePrimTyCon
  95     , threadIdPrimTyCon
  96     , wordPrimTyCon
  97     , word32PrimTyCon
  98     , word64PrimTyCon
  99     ]
 100
 101 mkPrimTc :: FastString -> Unique -> TyCon -> Name
 102 mkPrimTc fs uniq tycon
 103   = mkWiredInName gHC_PRIM (mkOccNameFS tcName fs)
 104                   uniq
 105                   Nothing               -- No parent object
 106                   (ATyCon tycon)        -- Relevant TyCon
 107                   UserSyntax            -- None are built-in syntax
 108
 109 charPrimTyConName             = mkPrimTc FSLIT("Char#") charPrimTyConKey charPrimTyCon
 110 intPrimTyConName              = mkPrimTc FSLIT("Int#") intPrimTyConKey  intPrimTyCon
 111 int32PrimTyConName            = mkPrimTc FSLIT("Int32#") int32PrimTyConKey int32PrimTyCon
 112 int64PrimTyConName            = mkPrimTc FSLIT("Int64#") int64PrimTyConKey int64PrimTyCon
 113 wordPrimTyConName             = mkPrimTc FSLIT("Word#") wordPrimTyConKey wordPrimTyCon
 114 word32PrimTyConName           = mkPrimTc FSLIT("Word32#") word32PrimTyConKey word32PrimTyCon
 115 word64PrimTyConName           = mkPrimTc FSLIT("Word64#") word64PrimTyConKey word64PrimTyCon
 116 addrPrimTyConName             = mkPrimTc FSLIT("Addr#") addrPrimTyConKey addrPrimTyCon
 117 floatPrimTyConName            = mkPrimTc FSLIT("Float#") floatPrimTyConKey floatPrimTyCon
 118 doublePrimTyConName           = mkPrimTc FSLIT("Double#") doublePrimTyConKey doublePrimTyCon
 119 statePrimTyConName            = mkPrimTc FSLIT("State#") statePrimTyConKey statePrimTyCon
 120 realWorldTyConName            = mkPrimTc FSLIT("RealWorld") realWorldTyConKey realWorldTyCon
 121 arrayPrimTyConName            = mkPrimTc FSLIT("Array#") arrayPrimTyConKey arrayPrimTyCon
 122 byteArrayPrimTyConName        = mkPrimTc FSLIT("ByteArray#") byteArrayPrimTyConKey byteArrayPrimTyCon
 123 mutableArrayPrimTyConName     = mkPrimTc FSLIT("MutableArray#") mutableArrayPrimTyConKey mutableArrayPrimTyCon
 124 mutableByteArrayPrimTyConName = mkPrimTc FSLIT("MutableByteArray#") mutableByteArrayPrimTyConKey mutableByteArrayPrimTyCon
 125 mutVarPrimTyConName           = mkPrimTc FSLIT("MutVar#") mutVarPrimTyConKey mutVarPrimTyCon
 126 mVarPrimTyConName             = mkPrimTc FSLIT("MVar#") mVarPrimTyConKey mVarPrimTyCon
 127 tVarPrimTyConName             = mkPrimTc FSLIT("TVar#") tVarPrimTyConKey tVarPrimTyCon
 128 stablePtrPrimTyConName        = mkPrimTc FSLIT("StablePtr#") stablePtrPrimTyConKey stablePtrPrimTyCon
 129 stableNamePrimTyConName       = mkPrimTc FSLIT("StableName#") stableNamePrimTyConKey stableNamePrimTyCon
 130 bcoPrimTyConName              = mkPrimTc FSLIT("BCO#") bcoPrimTyConKey bcoPrimTyCon
 131 weakPrimTyConName             = mkPrimTc FSLIT("Weak#") weakPrimTyConKey weakPrimTyCon
 132 threadIdPrimTyConName         = mkPrimTc FSLIT("ThreadId#") threadIdPrimTyConKey threadIdPrimTyCon
 133 \end{code}
 134
 135 %************************************************************************
 136 %*                                                                      *
 137 \subsection{Support code}
 138 %*                                                                      *
 139 %************************************************************************
 140
 141 alphaTyVars is a list of type variables for use in templates:
 142         ["a", "b", ..., "z", "t1", "t2", ... ]
 143
 144 \begin{code}
 145 tyVarList :: Kind -> [TyVar]
 146 tyVarList kind = [ mkTyVar (mkInternalName (mkAlphaTyVarUnique u)
 147                                 (mkTyVarOcc (mkFastString name))
 148                                 noSrcLoc) kind
 149                  | u <- [2..],
 150                    let name | c <= 'z'  = [c]
 151                             | otherwise = 't':show u
 152                             where c = chr (u-2 + ord 'a')
 153                  ]
 154
 155 alphaTyVars :: [TyVar]
 156 alphaTyVars = tyVarList liftedTypeKind
 157
 158 betaTyVars = tail alphaTyVars
 159
 160 alphaTyVar, betaTyVar, gammaTyVar :: TyVar
 161 (alphaTyVar:betaTyVar:gammaTyVar:deltaTyVar:_) = alphaTyVars
 162
 163 alphaTys = mkTyVarTys alphaTyVars
 164 (alphaTy:betaTy:gammaTy:deltaTy:_) = alphaTys
 165
 166         -- openAlphaTyVar is prepared to be instantiated
 167         -- to a lifted or unlifted type variable.  It's used for the
 168         -- result type for "error", so that we can have (error Int# "Help")
 169 openAlphaTyVars :: [TyVar]
 170 openAlphaTyVars@(openAlphaTyVar:_) = tyVarList openTypeKind
 171
 172 openAlphaTy = mkTyVarTy openAlphaTyVar
 173
 174 vrcPos,vrcZero :: (Bool,Bool)
 175 vrcPos  = (True,False)
 176 vrcZero = (False,False)
 177
 178 vrcsP,vrcsZ,vrcsZP :: ArgVrcs
 179 vrcsP  = [vrcPos]
 180 vrcsZ  = [vrcZero]
 181 vrcsZP = [vrcZero,vrcPos]
 182 \end{code}
 183
 184
 185 %************************************************************************
 186 %*                                                                      *
 187 \subsection[TysPrim-basic]{Basic primitive types (@Char#@, @Int#@, etc.)}
 188 %*                                                                      *
 189 %************************************************************************
 190
 191 \begin{code}
 192 -- only used herein
 193 pcPrimTyCon :: Name -> ArgVrcs -> PrimRep -> TyCon
 194 pcPrimTyCon name arg_vrcs rep
 195   = mkPrimTyCon name kind arity arg_vrcs rep
 196   where
 197     arity       = length arg_vrcs
 198     kind        = mkArrowKinds (replicate arity liftedTypeKind) result_kind
 199     result_kind = unliftedTypeKind -- all primitive types are unlifted
 200
 201 pcPrimTyCon0 :: Name -> PrimRep -> TyCon
 202 pcPrimTyCon0 name rep
 203   = mkPrimTyCon name result_kind 0 [] rep
 204   where
 205     result_kind = unliftedTypeKind -- all primitive types are unlifted
 206
 207 charPrimTy      = mkTyConTy charPrimTyCon
 208 charPrimTyCon   = pcPrimTyCon0 charPrimTyConName WordRep
 209
 210 intPrimTy       = mkTyConTy intPrimTyCon
 211 intPrimTyCon    = pcPrimTyCon0 intPrimTyConName IntRep
 212
 213 int32PrimTy     = mkTyConTy int32PrimTyCon
 214 int32PrimTyCon  = pcPrimTyCon0 int32PrimTyConName IntRep
 215
 216 int64PrimTy     = mkTyConTy int64PrimTyCon
 217 int64PrimTyCon  = pcPrimTyCon0 int64PrimTyConName Int64Rep
 218
 219 wordPrimTy      = mkTyConTy wordPrimTyCon
 220 wordPrimTyCon   = pcPrimTyCon0 wordPrimTyConName WordRep
 221
 222 word32PrimTy    = mkTyConTy word32PrimTyCon
 223 word32PrimTyCon = pcPrimTyCon0 word32PrimTyConName WordRep
 224
 225 word64PrimTy    = mkTyConTy word64PrimTyCon
 226 word64PrimTyCon = pcPrimTyCon0 word64PrimTyConName Word64Rep
 227
 228 addrPrimTy      = mkTyConTy addrPrimTyCon
 229 addrPrimTyCon   = pcPrimTyCon0 addrPrimTyConName AddrRep
 230
 231 floatPrimTy     = mkTyConTy floatPrimTyCon
 232 floatPrimTyCon  = pcPrimTyCon0 floatPrimTyConName FloatRep
 233
 234 doublePrimTy    = mkTyConTy doublePrimTyCon
 235 doublePrimTyCon = pcPrimTyCon0 doublePrimTyConName DoubleRep
 236 \end{code}
 237
 238
 239 %************************************************************************
 240 %*                                                                      *
 241 \subsection[TysPrim-state]{The @State#@ type (and @_RealWorld@ types)}
 242 %*                                                                      *
 243 %************************************************************************
 244
 245 State# is the primitive, unlifted type of states.  It has one type parameter,
 246 thus
 247         State# RealWorld
 248 or
 249         State# s
 250
 251 where s is a type variable. The only purpose of the type parameter is to
 252 keep different state threads separate.  It is represented by nothing at all.
 253
 254 \begin{code}
 255 mkStatePrimTy ty = mkTyConApp statePrimTyCon [ty]
 256 statePrimTyCon   = pcPrimTyCon statePrimTyConName vrcsZ VoidRep
 257 \end{code}
 258
 259 RealWorld is deeply magical.  It is *primitive*, but it is not
 260 *unlifted* (hence ptrArg).  We never manipulate values of type
 261 RealWorld; it's only used in the type system, to parameterise State#.
 262
 263 \begin{code}
 264 realWorldTyCon = mkLiftedPrimTyCon realWorldTyConName liftedTypeKind 0 [] PtrRep
 265 realWorldTy          = mkTyConTy realWorldTyCon
 266 realWorldStatePrimTy = mkStatePrimTy realWorldTy        -- State# RealWorld
 267 \end{code}
 268
 269 Note: the ``state-pairing'' types are not truly primitive, so they are
 270 defined in \tr{TysWiredIn.lhs}, not here.
 271
 272
 273 %************************************************************************
 274 %*                                                                      *
 275 \subsection[TysPrim-arrays]{The primitive array types}
 276 %*                                                                      *
 277 %************************************************************************
 278
 279 \begin{code}
 280 arrayPrimTyCon            = pcPrimTyCon  arrayPrimTyConName            vrcsP  PtrRep
 281 mutableArrayPrimTyCon     = pcPrimTyCon  mutableArrayPrimTyConName     vrcsZP PtrRep
 282 mutableByteArrayPrimTyCon = pcPrimTyCon  mutableByteArrayPrimTyConName vrcsZ  PtrRep
 283 byteArrayPrimTyCon        = pcPrimTyCon0 byteArrayPrimTyConName               PtrRep
 284
 285 mkArrayPrimTy elt           = mkTyConApp arrayPrimTyCon [elt]
 286 byteArrayPrimTy             = mkTyConTy byteArrayPrimTyCon
 287 mkMutableArrayPrimTy s elt  = mkTyConApp mutableArrayPrimTyCon [s, elt]
 288 mkMutableByteArrayPrimTy s  = mkTyConApp mutableByteArrayPrimTyCon [s]
 289 \end{code}
 290
 291 %************************************************************************
 292 %*                                                                      *
 293 \subsection[TysPrim-mut-var]{The mutable variable type}
 294 %*                                                                      *
 295 %************************************************************************
 296
 297 \begin{code}
 298 mutVarPrimTyCon = pcPrimTyCon mutVarPrimTyConName vrcsZP PtrRep
 299
 300 mkMutVarPrimTy s elt        = mkTyConApp mutVarPrimTyCon [s, elt]
 301 \end{code}
 302
 303 %************************************************************************
 304 %*                                                                      *
 305 \subsection[TysPrim-synch-var]{The synchronizing variable type}
 306 %*                                                                      *
 307 %************************************************************************
 308
 309 \begin{code}
 310 mVarPrimTyCon = pcPrimTyCon mVarPrimTyConName vrcsZP PtrRep
 311
 312 mkMVarPrimTy s elt          = mkTyConApp mVarPrimTyCon [s, elt]
 313 \end{code}
 314
 315 %************************************************************************
 316 %*                                                                      *
 317 \subsection[TysPrim-stm-var]{The transactional variable type}
 318 %*                                                                      *
 319 %************************************************************************
 320
 321 \begin{code}
 322 tVarPrimTyCon = pcPrimTyCon tVarPrimTyConName vrcsZP PtrRep
 323
 324 mkTVarPrimTy s elt          = mkTyConApp tVarPrimTyCon [s, elt]
 325 \end{code}
 326
 327 %************************************************************************
 328 %*                                                                      *
 329 \subsection[TysPrim-stable-ptrs]{The stable-pointer type}
 330 %*                                                                      *
 331 %************************************************************************
 332
 333 \begin{code}
 334 stablePtrPrimTyCon = pcPrimTyCon stablePtrPrimTyConName vrcsP AddrRep
 335
 336 mkStablePtrPrimTy ty = mkTyConApp stablePtrPrimTyCon [ty]
 337 \end{code}
 338
 339 %************************************************************************
 340 %*                                                                      *
 341 \subsection[TysPrim-stable-names]{The stable-name type}
 342 %*                                                                      *
 343 %************************************************************************
 344
 345 \begin{code}
 346 stableNamePrimTyCon = pcPrimTyCon stableNamePrimTyConName vrcsP PtrRep
 347
 348 mkStableNamePrimTy ty = mkTyConApp stableNamePrimTyCon [ty]
 349 \end{code}
 350
 351 %************************************************************************
 352 %*                                                                      *
 353 \subsection[TysPrim-BCOs]{The ``bytecode object'' type}
 354 %*                                                                      *
 355 %************************************************************************
 356
 357 \begin{code}
 358 bcoPrimTy    = mkTyConTy bcoPrimTyCon
 359 bcoPrimTyCon = pcPrimTyCon0 bcoPrimTyConName PtrRep
 360 \end{code}
 361
 362 %************************************************************************
 363 %*                                                                      *
 364 \subsection[TysPrim-Weak]{The ``weak pointer'' type}
 365 %*                                                                      *
 366 %************************************************************************
 367
 368 \begin{code}
 369 weakPrimTyCon = pcPrimTyCon weakPrimTyConName vrcsP PtrRep
 370
 371 mkWeakPrimTy v = mkTyConApp weakPrimTyCon [v]
 372 \end{code}
 373
 374 %************************************************************************
 375 %*                                                                      *
 376 \subsection[TysPrim-thread-ids]{The ``thread id'' type}
 377 %*                                                                      *
 378 %************************************************************************
 379
 380 A thread id is represented by a pointer to the TSO itself, to ensure
 381 that they are always unique and we can always find the TSO for a given
 382 thread id.  However, this has the unfortunate consequence that a
 383 ThreadId# for a given thread is treated as a root by the garbage
 384 collector and can keep TSOs around for too long.
 385
 386 Hence the programmer API for thread manipulation uses a weak pointer
 387 to the thread id internally.
 388
 389 \begin{code}
 390 threadIdPrimTy    = mkTyConTy threadIdPrimTyCon
 391 threadIdPrimTyCon = pcPrimTyCon0 threadIdPrimTyConName PtrRep
 392 \end{code}