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