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 ( mkUnboxedTypeKind, mkBoxedTypeKind, mkTypeKind, mkArrowKind )
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 wordPrimTy = mkTyConTy wordPrimTyCon
54 wordPrimTyCon = pcPrimTyCon wordPrimTyConKey SLIT("Word#") 0 WordRep
56 addrPrimTy = mkTyConTy addrPrimTyCon
57 addrPrimTyCon = pcPrimTyCon addrPrimTyConKey SLIT("Addr#") 0 AddrRep
59 floatPrimTy = mkTyConTy floatPrimTyCon
60 floatPrimTyCon = pcPrimTyCon floatPrimTyConKey SLIT("Float#") 0 FloatRep
62 doublePrimTy = mkTyConTy doublePrimTyCon
63 doublePrimTyCon = pcPrimTyCon doublePrimTyConKey SLIT("Double#") 0 DoubleRep
66 @PrimitiveKinds@ are used in @PrimitiveOps@, for which we often need
67 to reconstruct various type information. (It's slightly more
68 convenient/efficient to make type info from kinds, than kinds [etc.]
73 PrimRep -> (String, -- tag string
74 Type, TyCon) -- prim type and tycon
76 getPrimRepInfo CharRep = ("Char", charPrimTy, charPrimTyCon)
77 getPrimRepInfo IntRep = ("Int", intPrimTy, intPrimTyCon)
78 getPrimRepInfo WordRep = ("Word", wordPrimTy, wordPrimTyCon)
79 getPrimRepInfo AddrRep = ("Addr", addrPrimTy, addrPrimTyCon)
80 getPrimRepInfo FloatRep = ("Float", floatPrimTy, floatPrimTyCon)
81 getPrimRepInfo DoubleRep = ("Double", doublePrimTy, doublePrimTyCon)
84 %************************************************************************
86 \subsection[TysPrim-state]{The @State#@ type (and @_RealWorld@ types)}
88 %************************************************************************
90 State# is the primitive, unboxed type of states. It has one type parameter,
96 where s is a type variable. The only purpose of the type parameter is to
97 keep different state threads separate. It is represented by nothing at all.
100 mkStatePrimTy ty = mkTyConApp statePrimTyCon [ty]
101 statePrimTyCon = pcPrimTyCon statePrimTyConKey SLIT("State#") 1 VoidRep
104 @_RealWorld@ is deeply magical. It {\em is primitive}, but it
105 {\em is not unboxed}.
106 We never manipulate values of type RealWorld; it's only used in the type
107 system, to parameterise State#.
110 realWorldTy = mkTyConTy realWorldTyCon
111 realWorldTyCon = mk_no_constr_tycon realWorldTyConKey SLIT("RealWorld")
112 realWorldStatePrimTy = mkStatePrimTy realWorldTy
115 Note: the ``state-pairing'' types are not truly primitive, so they are
116 defined in \tr{TysWiredIn.lhs}, not here.
119 -- The Void type is represented as a data type with no constructors
120 -- It's a built in type (i.e. there's no way to define it in Haskell;
121 -- the nearest would be
123 -- data Void = -- No constructors!
125 -- ) It's boxed; there is only one value of this
126 -- type, namely "void", whose semantics is just bottom.
127 voidTy = mkTyConTy voidTyCon
128 voidTyCon = mk_no_constr_tycon voidTyConKey SLIT("Void")
132 mk_no_constr_tycon key str
135 name = mkWiredInTyConName key pREL_GHC str the_tycon
136 the_tycon = mkDataTyCon name mkBoxedTypeKind
139 [] -- No constructors; we tell you *nothing* about this guy
141 Nothing -- Not a dictionary
146 %************************************************************************
148 \subsection[TysPrim-arrays]{The primitive array types}
150 %************************************************************************
153 arrayPrimTyCon = pcPrimTyCon arrayPrimTyConKey SLIT("Array#") 1 ArrayRep
155 byteArrayPrimTyCon = pcPrimTyCon byteArrayPrimTyConKey SLIT("ByteArray#") 0 ByteArrayRep
157 mutableArrayPrimTyCon = pcPrimTyCon mutableArrayPrimTyConKey SLIT("MutableArray#") 2 ArrayRep
159 mutableByteArrayPrimTyCon = pcPrimTyCon mutableByteArrayPrimTyConKey SLIT("MutableByteArray#") 1 ByteArrayRep
161 mkArrayPrimTy elt = mkTyConApp arrayPrimTyCon [elt]
162 byteArrayPrimTy = mkTyConTy byteArrayPrimTyCon
163 mkMutableArrayPrimTy s elt = mkTyConApp mutableArrayPrimTyCon [s, elt]
164 mkMutableByteArrayPrimTy s = mkTyConApp mutableByteArrayPrimTyCon [s]
167 %************************************************************************
169 \subsection[TysPrim-synch-var]{The synchronizing variable type}
171 %************************************************************************
174 synchVarPrimTyCon = pcPrimTyCon synchVarPrimTyConKey SLIT("SynchVar#") 2 PtrRep
176 mkSynchVarPrimTy s elt = mkTyConApp synchVarPrimTyCon [s, elt]
179 %************************************************************************
181 \subsection[TysPrim-stable-ptrs]{The stable-pointer type}
183 %************************************************************************
186 stablePtrPrimTyCon = pcPrimTyCon stablePtrPrimTyConKey SLIT("StablePtr#") 1 StablePtrRep
188 mkStablePtrPrimTy ty = mkTyConApp stablePtrPrimTyCon [ty]
191 %************************************************************************
193 \subsection[TysPrim-foreign-objs]{The ``foreign object'' type}
195 %************************************************************************
197 Foreign objects (formerly ``Malloc'' pointers) provide a mechanism which
198 will let Haskell's garbage collector communicate with a {\em simple\/}
199 garbage collector in the IO world. We want Haskell to be able to hold
200 onto references to objects in the IO world and for Haskell's garbage
201 collector to tell the IO world when these references become garbage.
202 We are not aiming to provide a mechanism that could
203 talk to a sophisticated garbage collector such as that provided by a
204 LISP system (with a correspondingly complex interface); in particular,
205 we shall ignore the danger of circular structures spread across the
208 There are no primitive operations on @ForeignObj#@s (although equality
209 could possibly be added?)
212 foreignObjPrimTy = mkTyConTy foreignObjPrimTyCon
213 foreignObjPrimTyCon = pcPrimTyCon foreignObjPrimTyConKey SLIT("ForeignObj#") 0 ForeignObjRep