2 % (c) The AQUA Project, Glasgow University, 1994-1998
4 \section[TysPrim]{Wired-in knowledge about primitive types}
8 alphaTyVars, betaTyVars, alphaTyVar, betaTyVar, gammaTyVar, deltaTyVar,
9 alphaTy, betaTy, gammaTy, deltaTy,
10 openAlphaTy, openBetaTy, openAlphaTyVar, openBetaTyVar, openAlphaTyVars,
14 charPrimTyCon, charPrimTy,
15 intPrimTyCon, intPrimTy,
16 wordPrimTyCon, wordPrimTy,
17 addrPrimTyCon, addrPrimTy,
18 floatPrimTyCon, floatPrimTy,
19 doublePrimTyCon, doublePrimTy,
21 statePrimTyCon, mkStatePrimTy,
22 realWorldTyCon, realWorldTy, realWorldStatePrimTy,
24 arrayPrimTyCon, mkArrayPrimTy,
25 byteArrayPrimTyCon, byteArrayPrimTy,
26 mutableArrayPrimTyCon, mkMutableArrayPrimTy,
27 mutableByteArrayPrimTyCon, mkMutableByteArrayPrimTy,
28 mutVarPrimTyCon, mkMutVarPrimTy,
30 mVarPrimTyCon, mkMVarPrimTy,
31 tVarPrimTyCon, mkTVarPrimTy,
32 stablePtrPrimTyCon, mkStablePtrPrimTy,
33 stableNamePrimTyCon, mkStableNamePrimTy,
34 bcoPrimTyCon, bcoPrimTy,
35 weakPrimTyCon, mkWeakPrimTy,
36 threadIdPrimTyCon, threadIdPrimTy,
38 int32PrimTyCon, int32PrimTy,
39 word32PrimTyCon, word32PrimTy,
41 int64PrimTyCon, int64PrimTy,
42 word64PrimTyCon, word64PrimTy,
44 anyPrimTyCon, anyPrimTy, anyPrimTyCon1, mkAnyPrimTyCon
47 #include "HsVersions.h"
49 import Var ( TyVar, mkTyVar )
50 import Name ( Name, BuiltInSyntax(..), mkInternalName, mkWiredInName )
51 import OccName ( mkOccNameFS, tcName, mkTyVarOcc )
52 import TyCon ( TyCon, mkPrimTyCon, mkLiftedPrimTyCon,
54 import Type ( mkTyConApp, mkTyConTy, mkTyVarTys, mkTyVarTy,
56 liftedTypeKind, openTypeKind,
57 Kind, mkArrowKinds, mkArrowKind,
60 import SrcLoc ( noSrcLoc )
61 import Unique ( mkAlphaTyVarUnique, pprUnique )
63 import FastString ( FastString, mkFastString )
66 import Char ( ord, chr )
69 %************************************************************************
71 \subsection{Primitive type constructors}
73 %************************************************************************
89 , mutableArrayPrimTyCon
90 , mutableByteArrayPrimTyCon
102 , anyPrimTyCon, anyPrimTyCon1
105 mkPrimTc :: FastString -> Unique -> TyCon -> Name
106 mkPrimTc fs uniq tycon
107 = mkWiredInName gHC_PRIM (mkOccNameFS tcName fs)
109 (ATyCon tycon) -- Relevant TyCon
110 UserSyntax -- None are built-in syntax
112 charPrimTyConName = mkPrimTc FSLIT("Char#") charPrimTyConKey charPrimTyCon
113 intPrimTyConName = mkPrimTc FSLIT("Int#") intPrimTyConKey intPrimTyCon
114 int32PrimTyConName = mkPrimTc FSLIT("Int32#") int32PrimTyConKey int32PrimTyCon
115 int64PrimTyConName = mkPrimTc FSLIT("Int64#") int64PrimTyConKey int64PrimTyCon
116 wordPrimTyConName = mkPrimTc FSLIT("Word#") wordPrimTyConKey wordPrimTyCon
117 word32PrimTyConName = mkPrimTc FSLIT("Word32#") word32PrimTyConKey word32PrimTyCon
118 word64PrimTyConName = mkPrimTc FSLIT("Word64#") word64PrimTyConKey word64PrimTyCon
119 addrPrimTyConName = mkPrimTc FSLIT("Addr#") addrPrimTyConKey addrPrimTyCon
120 floatPrimTyConName = mkPrimTc FSLIT("Float#") floatPrimTyConKey floatPrimTyCon
121 doublePrimTyConName = mkPrimTc FSLIT("Double#") doublePrimTyConKey doublePrimTyCon
122 statePrimTyConName = mkPrimTc FSLIT("State#") statePrimTyConKey statePrimTyCon
123 realWorldTyConName = mkPrimTc FSLIT("RealWorld") realWorldTyConKey realWorldTyCon
124 arrayPrimTyConName = mkPrimTc FSLIT("Array#") arrayPrimTyConKey arrayPrimTyCon
125 byteArrayPrimTyConName = mkPrimTc FSLIT("ByteArray#") byteArrayPrimTyConKey byteArrayPrimTyCon
126 mutableArrayPrimTyConName = mkPrimTc FSLIT("MutableArray#") mutableArrayPrimTyConKey mutableArrayPrimTyCon
127 mutableByteArrayPrimTyConName = mkPrimTc FSLIT("MutableByteArray#") mutableByteArrayPrimTyConKey mutableByteArrayPrimTyCon
128 mutVarPrimTyConName = mkPrimTc FSLIT("MutVar#") mutVarPrimTyConKey mutVarPrimTyCon
129 mVarPrimTyConName = mkPrimTc FSLIT("MVar#") mVarPrimTyConKey mVarPrimTyCon
130 tVarPrimTyConName = mkPrimTc FSLIT("TVar#") tVarPrimTyConKey tVarPrimTyCon
131 stablePtrPrimTyConName = mkPrimTc FSLIT("StablePtr#") stablePtrPrimTyConKey stablePtrPrimTyCon
132 stableNamePrimTyConName = mkPrimTc FSLIT("StableName#") stableNamePrimTyConKey stableNamePrimTyCon
133 bcoPrimTyConName = mkPrimTc FSLIT("BCO#") bcoPrimTyConKey bcoPrimTyCon
134 weakPrimTyConName = mkPrimTc FSLIT("Weak#") weakPrimTyConKey weakPrimTyCon
135 threadIdPrimTyConName = mkPrimTc FSLIT("ThreadId#") threadIdPrimTyConKey threadIdPrimTyCon
136 anyPrimTyConName = mkPrimTc FSLIT("Any") anyPrimTyConKey anyPrimTyCon
137 anyPrimTyCon1Name = mkPrimTc FSLIT("Any1") anyPrimTyCon1Key anyPrimTyCon
140 %************************************************************************
142 \subsection{Support code}
144 %************************************************************************
146 alphaTyVars is a list of type variables for use in templates:
147 ["a", "b", ..., "z", "t1", "t2", ... ]
150 tyVarList :: Kind -> [TyVar]
151 tyVarList kind = [ mkTyVar (mkInternalName (mkAlphaTyVarUnique u)
152 (mkTyVarOcc (mkFastString name))
155 let name | c <= 'z' = [c]
156 | otherwise = 't':show u
157 where c = chr (u-2 + ord 'a')
160 alphaTyVars :: [TyVar]
161 alphaTyVars = tyVarList liftedTypeKind
163 betaTyVars = tail alphaTyVars
165 alphaTyVar, betaTyVar, gammaTyVar :: TyVar
166 (alphaTyVar:betaTyVar:gammaTyVar:deltaTyVar:_) = alphaTyVars
168 alphaTys = mkTyVarTys alphaTyVars
169 (alphaTy:betaTy:gammaTy:deltaTy:_) = alphaTys
171 -- openAlphaTyVar is prepared to be instantiated
172 -- to a lifted or unlifted type variable. It's used for the
173 -- result type for "error", so that we can have (error Int# "Help")
174 openAlphaTyVars :: [TyVar]
175 openAlphaTyVars@(openAlphaTyVar:openBetaTyVar:_) = tyVarList openTypeKind
177 openAlphaTy = mkTyVarTy openAlphaTyVar
178 openBetaTy = mkTyVarTy openBetaTyVar
182 %************************************************************************
184 \subsection[TysPrim-basic]{Basic primitive types (@Char#@, @Int#@, etc.)}
186 %************************************************************************
190 pcPrimTyCon :: Name -> Int -> PrimRep -> TyCon
191 pcPrimTyCon name arity rep
192 = mkPrimTyCon name kind arity rep
194 kind = mkArrowKinds (replicate arity liftedTypeKind) result_kind
195 result_kind = unliftedTypeKind
197 pcPrimTyCon0 :: Name -> PrimRep -> TyCon
198 pcPrimTyCon0 name rep
199 = mkPrimTyCon name result_kind 0 rep
201 result_kind = unliftedTypeKind
203 charPrimTy = mkTyConTy charPrimTyCon
204 charPrimTyCon = pcPrimTyCon0 charPrimTyConName WordRep
206 intPrimTy = mkTyConTy intPrimTyCon
207 intPrimTyCon = pcPrimTyCon0 intPrimTyConName IntRep
209 int32PrimTy = mkTyConTy int32PrimTyCon
210 int32PrimTyCon = pcPrimTyCon0 int32PrimTyConName IntRep
212 int64PrimTy = mkTyConTy int64PrimTyCon
213 int64PrimTyCon = pcPrimTyCon0 int64PrimTyConName Int64Rep
215 wordPrimTy = mkTyConTy wordPrimTyCon
216 wordPrimTyCon = pcPrimTyCon0 wordPrimTyConName WordRep
218 word32PrimTy = mkTyConTy word32PrimTyCon
219 word32PrimTyCon = pcPrimTyCon0 word32PrimTyConName WordRep
221 word64PrimTy = mkTyConTy word64PrimTyCon
222 word64PrimTyCon = pcPrimTyCon0 word64PrimTyConName Word64Rep
224 addrPrimTy = mkTyConTy addrPrimTyCon
225 addrPrimTyCon = pcPrimTyCon0 addrPrimTyConName AddrRep
227 floatPrimTy = mkTyConTy floatPrimTyCon
228 floatPrimTyCon = pcPrimTyCon0 floatPrimTyConName FloatRep
230 doublePrimTy = mkTyConTy doublePrimTyCon
231 doublePrimTyCon = pcPrimTyCon0 doublePrimTyConName DoubleRep
235 %************************************************************************
237 \subsection[TysPrim-state]{The @State#@ type (and @_RealWorld@ types)}
239 %************************************************************************
241 State# is the primitive, unlifted type of states. It has one type parameter,
247 where s is a type variable. The only purpose of the type parameter is to
248 keep different state threads separate. It is represented by nothing at all.
251 mkStatePrimTy ty = mkTyConApp statePrimTyCon [ty]
252 statePrimTyCon = pcPrimTyCon statePrimTyConName 1 VoidRep
255 RealWorld is deeply magical. It is *primitive*, but it is not
256 *unlifted* (hence ptrArg). We never manipulate values of type
257 RealWorld; it's only used in the type system, to parameterise State#.
260 realWorldTyCon = mkLiftedPrimTyCon realWorldTyConName liftedTypeKind 0 PtrRep
261 realWorldTy = mkTyConTy realWorldTyCon
262 realWorldStatePrimTy = mkStatePrimTy realWorldTy -- State# RealWorld
265 Note: the ``state-pairing'' types are not truly primitive, so they are
266 defined in \tr{TysWiredIn.lhs}, not here.
269 %************************************************************************
273 %************************************************************************
275 The type constructor Any is type to which you can unsafely coerce any
276 lifted type, and back.
278 * It is lifted, and hence represented by a pointer
280 * It does not claim to be a *data* type, and that's important for
281 the code generator, because the code gen may *enter* a data value
282 but never enters a function value.
284 It's also used to instantiate un-constrained type variables after type
285 checking. For example
287 Annoyingly, we sometimes need Anys of other kinds, such as (*->*) etc.
288 This is a bit like tuples. We define a couple of useful ones here,
289 and make others up on the fly. If any of these others end up being exported
290 into interface files, we'll get a crash; at least until we add interface-file
291 syntax to support them.
294 anyPrimTy = mkTyConApp anyPrimTyCon []
296 anyPrimTyCon :: TyCon -- Kind *
297 anyPrimTyCon = mkLiftedPrimTyCon anyPrimTyConName liftedTypeKind 0 PtrRep
299 anyPrimTyCon1 :: TyCon -- Kind *->*
300 anyPrimTyCon1 = mkLiftedPrimTyCon anyPrimTyCon1Name kind 0 PtrRep
302 kind = mkArrowKind liftedTypeKind liftedTypeKind
304 mkAnyPrimTyCon :: Unique -> Kind -> TyCon
305 -- Grotesque hack alert: the client gives the unique; so equality won't work
306 mkAnyPrimTyCon uniq kind
307 = pprTrace "Urk! Inventing strangely-kinded Any TyCon:" (ppr uniq <+> ppr kind)
310 name = mkPrimTc (mkFastString ("Any" ++ showSDoc (pprUnique uniq))) uniq tycon
311 tycon = mkLiftedPrimTyCon name kind 0 PtrRep
315 %************************************************************************
317 \subsection[TysPrim-arrays]{The primitive array types}
319 %************************************************************************
322 arrayPrimTyCon = pcPrimTyCon arrayPrimTyConName 1 PtrRep
323 mutableArrayPrimTyCon = pcPrimTyCon mutableArrayPrimTyConName 2 PtrRep
324 mutableByteArrayPrimTyCon = pcPrimTyCon mutableByteArrayPrimTyConName 1 PtrRep
325 byteArrayPrimTyCon = pcPrimTyCon0 byteArrayPrimTyConName PtrRep
327 mkArrayPrimTy elt = mkTyConApp arrayPrimTyCon [elt]
328 byteArrayPrimTy = mkTyConTy byteArrayPrimTyCon
329 mkMutableArrayPrimTy s elt = mkTyConApp mutableArrayPrimTyCon [s, elt]
330 mkMutableByteArrayPrimTy s = mkTyConApp mutableByteArrayPrimTyCon [s]
333 %************************************************************************
335 \subsection[TysPrim-mut-var]{The mutable variable type}
337 %************************************************************************
340 mutVarPrimTyCon = pcPrimTyCon mutVarPrimTyConName 2 PtrRep
342 mkMutVarPrimTy s elt = mkTyConApp mutVarPrimTyCon [s, elt]
345 %************************************************************************
347 \subsection[TysPrim-synch-var]{The synchronizing variable type}
349 %************************************************************************
352 mVarPrimTyCon = pcPrimTyCon mVarPrimTyConName 2 PtrRep
354 mkMVarPrimTy s elt = mkTyConApp mVarPrimTyCon [s, elt]
357 %************************************************************************
359 \subsection[TysPrim-stm-var]{The transactional variable type}
361 %************************************************************************
364 tVarPrimTyCon = pcPrimTyCon tVarPrimTyConName 2 PtrRep
366 mkTVarPrimTy s elt = mkTyConApp tVarPrimTyCon [s, elt]
369 %************************************************************************
371 \subsection[TysPrim-stable-ptrs]{The stable-pointer type}
373 %************************************************************************
376 stablePtrPrimTyCon = pcPrimTyCon stablePtrPrimTyConName 1 AddrRep
378 mkStablePtrPrimTy ty = mkTyConApp stablePtrPrimTyCon [ty]
381 %************************************************************************
383 \subsection[TysPrim-stable-names]{The stable-name type}
385 %************************************************************************
388 stableNamePrimTyCon = pcPrimTyCon stableNamePrimTyConName 1 PtrRep
390 mkStableNamePrimTy ty = mkTyConApp stableNamePrimTyCon [ty]
393 %************************************************************************
395 \subsection[TysPrim-BCOs]{The ``bytecode object'' type}
397 %************************************************************************
400 bcoPrimTy = mkTyConTy bcoPrimTyCon
401 bcoPrimTyCon = pcPrimTyCon0 bcoPrimTyConName PtrRep
404 %************************************************************************
406 \subsection[TysPrim-Weak]{The ``weak pointer'' type}
408 %************************************************************************
411 weakPrimTyCon = pcPrimTyCon weakPrimTyConName 1 PtrRep
413 mkWeakPrimTy v = mkTyConApp weakPrimTyCon [v]
416 %************************************************************************
418 \subsection[TysPrim-thread-ids]{The ``thread id'' type}
420 %************************************************************************
422 A thread id is represented by a pointer to the TSO itself, to ensure
423 that they are always unique and we can always find the TSO for a given
424 thread id. However, this has the unfortunate consequence that a
425 ThreadId# for a given thread is treated as a root by the garbage
426 collector and can keep TSOs around for too long.
428 Hence the programmer API for thread manipulation uses a weak pointer
429 to the thread id internally.
432 threadIdPrimTy = mkTyConTy threadIdPrimTyCon
433 threadIdPrimTyCon = pcPrimTyCon0 threadIdPrimTyConName PtrRep