2 % (c) The AQUA Project, Glasgow University, 1994-1996
4 \section[TysPrim]{Wired-in knowledge about primitive types}
6 This module tracks the ``state interface'' document, ``GHC prelude:
7 types and operations.''
12 #include "HsVersions.h"
14 import Kind ( mkBoxedTypeKind )
15 import Name ( mkWiredInTyConName )
16 import PrimRep ( PrimRep(..) ) -- getPrimRepInfo uses PrimRep repn
17 import TyCon ( mkPrimTyCon, mkDataTyCon, TyCon )
18 import BasicTypes ( NewOrData(..), RecFlag(..) )
19 import Type ( mkTyConApp, mkTyConTy, mkTyVarTys, Type )
20 import TyVar ( GenTyVar(..), alphaTyVars )
21 import PrelMods ( pREL_GHC )
26 alphaTys = mkTyVarTys alphaTyVars
27 (alphaTy:betaTy:gammaTy:deltaTy:_) = alphaTys
30 %************************************************************************
32 \subsection[TysPrim-basic]{Basic primitive types (@Char#@, @Int#@, etc.)}
34 %************************************************************************
38 pcPrimTyCon :: Unique{-TyConKey-} -> FAST_STRING -> Int -> PrimRep -> TyCon
40 pcPrimTyCon key str arity primrep
43 name = mkWiredInTyConName key pREL_GHC str the_tycon
44 the_tycon = mkPrimTyCon name arity primrep
47 charPrimTy = mkTyConTy charPrimTyCon
48 charPrimTyCon = pcPrimTyCon charPrimTyConKey SLIT("Char#") 0 CharRep
50 intPrimTy = mkTyConTy intPrimTyCon
51 intPrimTyCon = pcPrimTyCon intPrimTyConKey SLIT("Int#") 0 IntRep
53 int64PrimTy = mkTyConTy int64PrimTyCon
54 int64PrimTyCon = pcPrimTyCon int64PrimTyConKey SLIT("Int64#") 0 Int64Rep
56 wordPrimTy = mkTyConTy wordPrimTyCon
57 wordPrimTyCon = pcPrimTyCon wordPrimTyConKey SLIT("Word#") 0 WordRep
59 word64PrimTy = mkTyConTy word64PrimTyCon
60 word64PrimTyCon = pcPrimTyCon word64PrimTyConKey SLIT("Word64#") 0 Word64Rep
62 addrPrimTy = mkTyConTy addrPrimTyCon
63 addrPrimTyCon = pcPrimTyCon addrPrimTyConKey SLIT("Addr#") 0 AddrRep
65 floatPrimTy = mkTyConTy floatPrimTyCon
66 floatPrimTyCon = pcPrimTyCon floatPrimTyConKey SLIT("Float#") 0 FloatRep
68 doublePrimTy = mkTyConTy doublePrimTyCon
69 doublePrimTyCon = pcPrimTyCon doublePrimTyConKey SLIT("Double#") 0 DoubleRep
72 @PrimitiveKinds@ are used in @PrimitiveOps@, for which we often need
73 to reconstruct various type information. (It's slightly more
74 convenient/efficient to make type info from kinds, than kinds [etc.]
79 PrimRep -> (String, -- tag string
80 Type, TyCon) -- prim type and tycon
82 getPrimRepInfo CharRep = ("Char", charPrimTy, charPrimTyCon)
83 getPrimRepInfo IntRep = ("Int", intPrimTy, intPrimTyCon)
84 getPrimRepInfo WordRep = ("Word", wordPrimTy, wordPrimTyCon)
85 getPrimRepInfo AddrRep = ("Addr", addrPrimTy, addrPrimTyCon)
86 getPrimRepInfo FloatRep = ("Float", floatPrimTy, floatPrimTyCon)
87 getPrimRepInfo DoubleRep = ("Double", doublePrimTy, doublePrimTyCon)
88 getPrimRepInfo Int64Rep = ("Int64", int64PrimTy, int64PrimTyCon)
89 getPrimRepInfo Word64Rep = ("Word64", word64PrimTy, word64PrimTyCon)
90 getPrimRepInfo StablePtrRep = ("StablePtr", mkStablePtrPrimTy alphaTy, stablePtrPrimTyCon)
91 getPrimRepInfo ForeignObjRep = ("ForeignObj", foreignObjPrimTy, foreignObjPrimTyCon)
95 %************************************************************************
97 \subsection[TysPrim-state]{The @State#@ type (and @_RealWorld@ types)}
99 %************************************************************************
101 State# is the primitive, unboxed type of states. It has one type parameter,
107 where s is a type variable. The only purpose of the type parameter is to
108 keep different state threads separate. It is represented by nothing at all.
111 mkStatePrimTy ty = mkTyConApp statePrimTyCon [ty]
112 statePrimTyCon = pcPrimTyCon statePrimTyConKey SLIT("State#") 1 VoidRep
115 @_RealWorld@ is deeply magical. It {\em is primitive}, but it
116 {\em is not unboxed}.
117 We never manipulate values of type RealWorld; it's only used in the type
118 system, to parameterise State#.
121 realWorldTy = mkTyConTy realWorldTyCon
122 realWorldTyCon = mk_no_constr_tycon realWorldTyConKey SLIT("RealWorld")
123 realWorldStatePrimTy = mkStatePrimTy realWorldTy
126 Note: the ``state-pairing'' types are not truly primitive, so they are
127 defined in \tr{TysWiredIn.lhs}, not here.
130 -- The Void type is represented as a data type with no constructors
131 -- It's a built in type (i.e. there's no way to define it in Haskell;
132 -- the nearest would be
134 -- data Void = -- No constructors!
136 -- ) It's boxed; there is only one value of this
137 -- type, namely "void", whose semantics is just bottom.
138 voidTy = mkTyConTy voidTyCon
139 voidTyCon = mk_no_constr_tycon voidTyConKey SLIT("Void")
143 mk_no_constr_tycon key str
146 name = mkWiredInTyConName key pREL_GHC str the_tycon
147 the_tycon = mkDataTyCon name mkBoxedTypeKind
150 [] -- No constructors; we tell you *nothing* about this guy
152 Nothing -- Not a dictionary
157 %************************************************************************
159 \subsection[TysPrim-arrays]{The primitive array types}
161 %************************************************************************
164 arrayPrimTyCon = pcPrimTyCon arrayPrimTyConKey SLIT("Array#") 1 ArrayRep
166 byteArrayPrimTyCon = pcPrimTyCon byteArrayPrimTyConKey SLIT("ByteArray#") 0 ByteArrayRep
168 mutableArrayPrimTyCon = pcPrimTyCon mutableArrayPrimTyConKey SLIT("MutableArray#") 2 ArrayRep
170 mutableByteArrayPrimTyCon = pcPrimTyCon mutableByteArrayPrimTyConKey SLIT("MutableByteArray#") 1 ByteArrayRep
172 mkArrayPrimTy elt = mkTyConApp arrayPrimTyCon [elt]
173 byteArrayPrimTy = mkTyConTy byteArrayPrimTyCon
174 mkMutableArrayPrimTy s elt = mkTyConApp mutableArrayPrimTyCon [s, elt]
175 mkMutableByteArrayPrimTy s = mkTyConApp mutableByteArrayPrimTyCon [s]
178 %************************************************************************
180 \subsection[TysPrim-synch-var]{The synchronizing variable type}
182 %************************************************************************
185 synchVarPrimTyCon = pcPrimTyCon synchVarPrimTyConKey SLIT("SynchVar#") 2 PtrRep
187 mkSynchVarPrimTy s elt = mkTyConApp synchVarPrimTyCon [s, elt]
190 %************************************************************************
192 \subsection[TysPrim-stable-ptrs]{The stable-pointer type}
194 %************************************************************************
197 stablePtrPrimTyCon = pcPrimTyCon stablePtrPrimTyConKey SLIT("StablePtr#") 1 StablePtrRep
199 mkStablePtrPrimTy ty = mkTyConApp stablePtrPrimTyCon [ty]
202 %************************************************************************
204 \subsection[TysPrim-foreign-objs]{The ``foreign object'' type}
206 %************************************************************************
208 Foreign objects (formerly ``Malloc'' pointers) provide a mechanism which
209 will let Haskell's garbage collector communicate with a {\em simple\/}
210 garbage collector in the IO world. We want Haskell to be able to hold
211 onto references to objects in the IO world and for Haskell's garbage
212 collector to tell the IO world when these references become garbage.
213 We are not aiming to provide a mechanism that could
214 talk to a sophisticated garbage collector such as that provided by a
215 LISP system (with a correspondingly complex interface); in particular,
216 we shall ignore the danger of circular structures spread across the
219 There are no primitive operations on @ForeignObj#@s (although equality
220 could possibly be added?)
223 foreignObjPrimTy = mkTyConTy foreignObjPrimTyCon
224 foreignObjPrimTyCon = pcPrimTyCon foreignObjPrimTyConKey SLIT("ForeignObj#") 0 ForeignObjRep