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, openAlphaTyVar, 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
45 #include "HsVersions.h"
47 import Var ( TyVar, mkTyVar )
48 import Name ( Name, BuiltInSyntax(..), mkInternalName, mkWiredInName )
49 import OccName ( mkOccNameFS, tcName, mkTyVarOcc )
50 import TyCon ( TyCon, mkPrimTyCon, mkLiftedPrimTyCon,
52 import Type ( mkTyConApp, mkTyConTy, mkTyVarTys, mkTyVarTy,
53 unliftedTypeKind, unboxedTypeKind,
54 liftedTypeKind, openTypeKind,
58 import SrcLoc ( noSrcLoc )
59 import Unique ( mkAlphaTyVarUnique )
61 import FastString ( FastString, mkFastString )
64 import Char ( ord, chr )
67 %************************************************************************
69 \subsection{Primitive type constructors}
71 %************************************************************************
87 , mutableArrayPrimTyCon
88 , mutableByteArrayPrimTyCon
102 mkPrimTc :: FastString -> Unique -> TyCon -> Name
103 mkPrimTc fs uniq tycon
104 = mkWiredInName gHC_PRIM (mkOccNameFS tcName fs)
106 Nothing -- No parent object
107 (ATyCon tycon) -- Relevant TyCon
108 UserSyntax -- None are built-in syntax
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
136 %************************************************************************
138 \subsection{Support code}
140 %************************************************************************
142 alphaTyVars is a list of type variables for use in templates:
143 ["a", "b", ..., "z", "t1", "t2", ... ]
146 tyVarList :: Kind -> [TyVar]
147 tyVarList kind = [ mkTyVar (mkInternalName (mkAlphaTyVarUnique u)
148 (mkTyVarOcc (mkFastString name))
151 let name | c <= 'z' = [c]
152 | otherwise = 't':show u
153 where c = chr (u-2 + ord 'a')
156 alphaTyVars :: [TyVar]
157 alphaTyVars = tyVarList liftedTypeKind
159 betaTyVars = tail alphaTyVars
161 alphaTyVar, betaTyVar, gammaTyVar :: TyVar
162 (alphaTyVar:betaTyVar:gammaTyVar:deltaTyVar:_) = alphaTyVars
164 alphaTys = mkTyVarTys alphaTyVars
165 (alphaTy:betaTy:gammaTy:deltaTy:_) = alphaTys
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
173 openAlphaTy = mkTyVarTy openAlphaTyVar
177 %************************************************************************
179 \subsection[TysPrim-basic]{Basic primitive types (@Char#@, @Int#@, etc.)}
181 %************************************************************************
185 pcPrimTyCon :: Name -> Int -> PrimRep -> TyCon
186 pcPrimTyCon name arity rep
187 = mkPrimTyCon name kind arity rep
189 kind = mkArrowKinds (replicate arity liftedTypeKind) result_kind
190 result_kind = case rep of
191 PtrRep -> unliftedTypeKind
192 _other -> unboxedTypeKind
194 pcPrimTyCon0 :: Name -> PrimRep -> TyCon
195 pcPrimTyCon0 name rep
196 = mkPrimTyCon name result_kind 0 rep
198 result_kind = case rep of
199 PtrRep -> unliftedTypeKind
200 _other -> unboxedTypeKind
202 charPrimTy = mkTyConTy charPrimTyCon
203 charPrimTyCon = pcPrimTyCon0 charPrimTyConName WordRep
205 intPrimTy = mkTyConTy intPrimTyCon
206 intPrimTyCon = pcPrimTyCon0 intPrimTyConName IntRep
208 int32PrimTy = mkTyConTy int32PrimTyCon
209 int32PrimTyCon = pcPrimTyCon0 int32PrimTyConName IntRep
211 int64PrimTy = mkTyConTy int64PrimTyCon
212 int64PrimTyCon = pcPrimTyCon0 int64PrimTyConName Int64Rep
214 wordPrimTy = mkTyConTy wordPrimTyCon
215 wordPrimTyCon = pcPrimTyCon0 wordPrimTyConName WordRep
217 word32PrimTy = mkTyConTy word32PrimTyCon
218 word32PrimTyCon = pcPrimTyCon0 word32PrimTyConName WordRep
220 word64PrimTy = mkTyConTy word64PrimTyCon
221 word64PrimTyCon = pcPrimTyCon0 word64PrimTyConName Word64Rep
223 addrPrimTy = mkTyConTy addrPrimTyCon
224 addrPrimTyCon = pcPrimTyCon0 addrPrimTyConName AddrRep
226 floatPrimTy = mkTyConTy floatPrimTyCon
227 floatPrimTyCon = pcPrimTyCon0 floatPrimTyConName FloatRep
229 doublePrimTy = mkTyConTy doublePrimTyCon
230 doublePrimTyCon = pcPrimTyCon0 doublePrimTyConName DoubleRep
234 %************************************************************************
236 \subsection[TysPrim-state]{The @State#@ type (and @_RealWorld@ types)}
238 %************************************************************************
240 State# is the primitive, unlifted type of states. It has one type parameter,
246 where s is a type variable. The only purpose of the type parameter is to
247 keep different state threads separate. It is represented by nothing at all.
250 mkStatePrimTy ty = mkTyConApp statePrimTyCon [ty]
251 statePrimTyCon = pcPrimTyCon statePrimTyConName 1 VoidRep
254 RealWorld is deeply magical. It is *primitive*, but it is not
255 *unlifted* (hence ptrArg). We never manipulate values of type
256 RealWorld; it's only used in the type system, to parameterise State#.
259 realWorldTyCon = mkLiftedPrimTyCon realWorldTyConName liftedTypeKind 0 PtrRep
260 realWorldTy = mkTyConTy realWorldTyCon
261 realWorldStatePrimTy = mkStatePrimTy realWorldTy -- State# RealWorld
264 Note: the ``state-pairing'' types are not truly primitive, so they are
265 defined in \tr{TysWiredIn.lhs}, not here.
268 %************************************************************************
270 \subsection[TysPrim-arrays]{The primitive array types}
272 %************************************************************************
275 arrayPrimTyCon = pcPrimTyCon arrayPrimTyConName 1 PtrRep
276 mutableArrayPrimTyCon = pcPrimTyCon mutableArrayPrimTyConName 2 PtrRep
277 mutableByteArrayPrimTyCon = pcPrimTyCon mutableByteArrayPrimTyConName 1 PtrRep
278 byteArrayPrimTyCon = pcPrimTyCon0 byteArrayPrimTyConName PtrRep
280 mkArrayPrimTy elt = mkTyConApp arrayPrimTyCon [elt]
281 byteArrayPrimTy = mkTyConTy byteArrayPrimTyCon
282 mkMutableArrayPrimTy s elt = mkTyConApp mutableArrayPrimTyCon [s, elt]
283 mkMutableByteArrayPrimTy s = mkTyConApp mutableByteArrayPrimTyCon [s]
286 %************************************************************************
288 \subsection[TysPrim-mut-var]{The mutable variable type}
290 %************************************************************************
293 mutVarPrimTyCon = pcPrimTyCon mutVarPrimTyConName 2 PtrRep
295 mkMutVarPrimTy s elt = mkTyConApp mutVarPrimTyCon [s, elt]
298 %************************************************************************
300 \subsection[TysPrim-synch-var]{The synchronizing variable type}
302 %************************************************************************
305 mVarPrimTyCon = pcPrimTyCon mVarPrimTyConName 2 PtrRep
307 mkMVarPrimTy s elt = mkTyConApp mVarPrimTyCon [s, elt]
310 %************************************************************************
312 \subsection[TysPrim-stm-var]{The transactional variable type}
314 %************************************************************************
317 tVarPrimTyCon = pcPrimTyCon tVarPrimTyConName 2 PtrRep
319 mkTVarPrimTy s elt = mkTyConApp tVarPrimTyCon [s, elt]
322 %************************************************************************
324 \subsection[TysPrim-stable-ptrs]{The stable-pointer type}
326 %************************************************************************
329 stablePtrPrimTyCon = pcPrimTyCon stablePtrPrimTyConName 1 AddrRep
331 mkStablePtrPrimTy ty = mkTyConApp stablePtrPrimTyCon [ty]
334 %************************************************************************
336 \subsection[TysPrim-stable-names]{The stable-name type}
338 %************************************************************************
341 stableNamePrimTyCon = pcPrimTyCon stableNamePrimTyConName 1 PtrRep
343 mkStableNamePrimTy ty = mkTyConApp stableNamePrimTyCon [ty]
346 %************************************************************************
348 \subsection[TysPrim-BCOs]{The ``bytecode object'' type}
350 %************************************************************************
353 bcoPrimTy = mkTyConTy bcoPrimTyCon
354 bcoPrimTyCon = pcPrimTyCon0 bcoPrimTyConName PtrRep
357 %************************************************************************
359 \subsection[TysPrim-Weak]{The ``weak pointer'' type}
361 %************************************************************************
364 weakPrimTyCon = pcPrimTyCon weakPrimTyConName 1 PtrRep
366 mkWeakPrimTy v = mkTyConApp weakPrimTyCon [v]
369 %************************************************************************
371 \subsection[TysPrim-thread-ids]{The ``thread id'' type}
373 %************************************************************************
375 A thread id is represented by a pointer to the TSO itself, to ensure
376 that they are always unique and we can always find the TSO for a given
377 thread id. However, this has the unfortunate consequence that a
378 ThreadId# for a given thread is treated as a root by the garbage
379 collector and can keep TSOs around for too long.
381 Hence the programmer API for thread manipulation uses a weak pointer
382 to the thread id internally.
385 threadIdPrimTy = mkTyConTy threadIdPrimTyCon
386 threadIdPrimTyCon = pcPrimTyCon0 threadIdPrimTyConName PtrRep