Replace (State# RealWorld) with Void# where we just want a 0-bit value
[ghc.git] / compiler / prelude / TysPrim.lhs
1 %
2 % (c) The AQUA Project, Glasgow University, 1994-1998
3 %
4
5      
6 \section[TysPrim]{Wired-in knowledge about primitive types}
7
8 \begin{code}
9 {-# OPTIONS -fno-warn-tabs #-}
10 -- The above warning supression flag is a temporary kludge.
11 -- While working on this module you are encouraged to remove it and
12 -- detab the module (please do the detabbing in a separate patch). See
13 --     http://ghc.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#TabsvsSpaces
14 -- for details
15
16 -- | This module defines TyCons that can't be expressed in Haskell. 
17 --   They are all, therefore, wired-in TyCons.  C.f module TysWiredIn
18 module TysPrim(
19         mkPrimTyConName, -- For implicit parameters in TysWiredIn only
20
21         tyVarList, alphaTyVars, betaTyVars, alphaTyVar, betaTyVar, gammaTyVar, deltaTyVar,
22         alphaTy, betaTy, gammaTy, deltaTy,
23         openAlphaTy, openBetaTy, openAlphaTyVar, openBetaTyVar, openAlphaTyVars,
24         kKiVar,
25
26         -- Kind constructors...
27         superKindTyCon, superKind, anyKindTyCon, liftedTypeKindTyCon,
28         openTypeKindTyCon, unliftedTypeKindTyCon, constraintKindTyCon,
29
30         superKindTyConName, anyKindTyConName, liftedTypeKindTyConName,
31         openTypeKindTyConName, unliftedTypeKindTyConName,
32         constraintKindTyConName,
33
34         -- Kinds
35         anyKind, liftedTypeKind, unliftedTypeKind, openTypeKind, constraintKind,
36         mkArrowKind, mkArrowKinds,
37
38         funTyCon, funTyConName,
39         primTyCons,
40
41         charPrimTyCon,          charPrimTy,
42         intPrimTyCon,           intPrimTy,
43         wordPrimTyCon,          wordPrimTy,
44         addrPrimTyCon,          addrPrimTy,
45         floatPrimTyCon,         floatPrimTy,
46         doublePrimTyCon,        doublePrimTy,
47
48         voidPrimTyCon,          voidPrimTy,
49         statePrimTyCon,         mkStatePrimTy,
50         realWorldTyCon,         realWorldTy, realWorldStatePrimTy,
51
52         proxyPrimTyCon,         mkProxyPrimTy,
53
54         arrayPrimTyCon, mkArrayPrimTy, 
55         byteArrayPrimTyCon,     byteArrayPrimTy,
56         arrayArrayPrimTyCon, mkArrayArrayPrimTy, 
57         mutableArrayPrimTyCon, mkMutableArrayPrimTy,
58         mutableByteArrayPrimTyCon, mkMutableByteArrayPrimTy,
59         mutableArrayArrayPrimTyCon, mkMutableArrayArrayPrimTy,
60         mutVarPrimTyCon, mkMutVarPrimTy,
61
62         mVarPrimTyCon,                  mkMVarPrimTy,   
63         tVarPrimTyCon,                  mkTVarPrimTy,
64         stablePtrPrimTyCon,             mkStablePtrPrimTy,
65         stableNamePrimTyCon,            mkStableNamePrimTy,
66         bcoPrimTyCon,                   bcoPrimTy,
67         weakPrimTyCon,                  mkWeakPrimTy,
68         threadIdPrimTyCon,              threadIdPrimTy,
69         
70         int32PrimTyCon,         int32PrimTy,
71         word32PrimTyCon,        word32PrimTy,
72
73         int64PrimTyCon,         int64PrimTy,
74         word64PrimTyCon,        word64PrimTy,
75
76         eqPrimTyCon,            -- ty1 ~# ty2
77         eqReprPrimTyCon,        -- ty1 ~R# ty2  (at role Representational)
78
79         -- * Any
80         anyTy, anyTyCon, anyTypeOfKind,
81
82         -- * SIMD
83 #include "primop-vector-tys-exports.hs-incl"
84   ) where
85
86 #include "HsVersions.h"
87
88 import Var              ( TyVar, KindVar, mkTyVar )
89 import Name             ( Name, BuiltInSyntax(..), mkInternalName, mkWiredInName )
90 import OccName          ( mkTyVarOccFS, mkTcOccFS )
91 import TyCon
92 import TypeRep
93 import SrcLoc
94 import Unique           ( mkAlphaTyVarUnique )
95 import PrelNames
96 import FastString
97
98 import Data.Char
99 \end{code}
100
101 %************************************************************************
102 %*                                                                      *
103 \subsection{Primitive type constructors}
104 %*                                                                      *
105 %************************************************************************
106
107 \begin{code}
108 primTyCons :: [TyCon]
109 primTyCons 
110   = [ addrPrimTyCon
111     , arrayPrimTyCon
112     , byteArrayPrimTyCon
113     , arrayArrayPrimTyCon
114     , charPrimTyCon
115     , doublePrimTyCon
116     , floatPrimTyCon
117     , intPrimTyCon
118     , int32PrimTyCon
119     , int64PrimTyCon
120     , bcoPrimTyCon
121     , weakPrimTyCon
122     , mutableArrayPrimTyCon
123     , mutableByteArrayPrimTyCon
124     , mutableArrayArrayPrimTyCon
125     , mVarPrimTyCon
126     , tVarPrimTyCon
127     , mutVarPrimTyCon
128     , realWorldTyCon
129     , stablePtrPrimTyCon
130     , stableNamePrimTyCon
131     , statePrimTyCon
132     , voidPrimTyCon
133     , proxyPrimTyCon
134     , threadIdPrimTyCon
135     , wordPrimTyCon
136     , word32PrimTyCon
137     , word64PrimTyCon
138     , anyTyCon
139     , eqPrimTyCon
140     , eqReprPrimTyCon
141
142     , liftedTypeKindTyCon
143     , unliftedTypeKindTyCon
144     , openTypeKindTyCon
145     , constraintKindTyCon
146     , superKindTyCon
147     , anyKindTyCon
148
149 #include "primop-vector-tycons.hs-incl"
150     ]
151
152 mkPrimTc :: FastString -> Unique -> TyCon -> Name
153 mkPrimTc fs unique tycon
154   = mkWiredInName gHC_PRIM (mkTcOccFS fs) 
155                   unique
156                   (ATyCon tycon)        -- Relevant TyCon
157                   UserSyntax            -- None are built-in syntax
158
159 charPrimTyConName, intPrimTyConName, int32PrimTyConName, int64PrimTyConName, wordPrimTyConName, word32PrimTyConName, word64PrimTyConName, addrPrimTyConName, floatPrimTyConName, doublePrimTyConName, statePrimTyConName, proxyPrimTyConName, realWorldTyConName, arrayPrimTyConName, arrayArrayPrimTyConName, byteArrayPrimTyConName, mutableArrayPrimTyConName, mutableByteArrayPrimTyConName, mutableArrayArrayPrimTyConName, mutVarPrimTyConName, mVarPrimTyConName, tVarPrimTyConName, stablePtrPrimTyConName, stableNamePrimTyConName, bcoPrimTyConName, weakPrimTyConName, threadIdPrimTyConName, eqPrimTyConName, eqReprPrimTyConName, voidPrimTyConName :: Name
160 charPrimTyConName             = mkPrimTc (fsLit "Char#") charPrimTyConKey charPrimTyCon
161 intPrimTyConName              = mkPrimTc (fsLit "Int#") intPrimTyConKey  intPrimTyCon
162 int32PrimTyConName            = mkPrimTc (fsLit "Int32#") int32PrimTyConKey int32PrimTyCon
163 int64PrimTyConName            = mkPrimTc (fsLit "Int64#") int64PrimTyConKey int64PrimTyCon
164 wordPrimTyConName             = mkPrimTc (fsLit "Word#") wordPrimTyConKey wordPrimTyCon
165 word32PrimTyConName           = mkPrimTc (fsLit "Word32#") word32PrimTyConKey word32PrimTyCon
166 word64PrimTyConName           = mkPrimTc (fsLit "Word64#") word64PrimTyConKey word64PrimTyCon
167 addrPrimTyConName             = mkPrimTc (fsLit "Addr#") addrPrimTyConKey addrPrimTyCon
168 floatPrimTyConName            = mkPrimTc (fsLit "Float#") floatPrimTyConKey floatPrimTyCon
169 doublePrimTyConName           = mkPrimTc (fsLit "Double#") doublePrimTyConKey doublePrimTyCon
170 statePrimTyConName            = mkPrimTc (fsLit "State#") statePrimTyConKey statePrimTyCon
171 voidPrimTyConName             = mkPrimTc (fsLit "Void#") voidPrimTyConKey voidPrimTyCon
172 proxyPrimTyConName            = mkPrimTc (fsLit "Proxy#") proxyPrimTyConKey proxyPrimTyCon
173 eqPrimTyConName               = mkPrimTc (fsLit "~#") eqPrimTyConKey eqPrimTyCon
174 eqReprPrimTyConName           = mkPrimTc (fsLit "~R#") eqReprPrimTyConKey eqReprPrimTyCon
175 realWorldTyConName            = mkPrimTc (fsLit "RealWorld") realWorldTyConKey realWorldTyCon
176 arrayPrimTyConName            = mkPrimTc (fsLit "Array#") arrayPrimTyConKey arrayPrimTyCon
177 byteArrayPrimTyConName        = mkPrimTc (fsLit "ByteArray#") byteArrayPrimTyConKey byteArrayPrimTyCon
178 arrayArrayPrimTyConName           = mkPrimTc (fsLit "ArrayArray#") arrayArrayPrimTyConKey arrayArrayPrimTyCon
179 mutableArrayPrimTyConName     = mkPrimTc (fsLit "MutableArray#") mutableArrayPrimTyConKey mutableArrayPrimTyCon
180 mutableByteArrayPrimTyConName = mkPrimTc (fsLit "MutableByteArray#") mutableByteArrayPrimTyConKey mutableByteArrayPrimTyCon
181 mutableArrayArrayPrimTyConName= mkPrimTc (fsLit "MutableArrayArray#") mutableArrayArrayPrimTyConKey mutableArrayArrayPrimTyCon
182 mutVarPrimTyConName           = mkPrimTc (fsLit "MutVar#") mutVarPrimTyConKey mutVarPrimTyCon
183 mVarPrimTyConName             = mkPrimTc (fsLit "MVar#") mVarPrimTyConKey mVarPrimTyCon
184 tVarPrimTyConName             = mkPrimTc (fsLit "TVar#") tVarPrimTyConKey tVarPrimTyCon
185 stablePtrPrimTyConName        = mkPrimTc (fsLit "StablePtr#") stablePtrPrimTyConKey stablePtrPrimTyCon
186 stableNamePrimTyConName       = mkPrimTc (fsLit "StableName#") stableNamePrimTyConKey stableNamePrimTyCon
187 bcoPrimTyConName              = mkPrimTc (fsLit "BCO#") bcoPrimTyConKey bcoPrimTyCon
188 weakPrimTyConName             = mkPrimTc (fsLit "Weak#") weakPrimTyConKey weakPrimTyCon
189 threadIdPrimTyConName         = mkPrimTc (fsLit "ThreadId#") threadIdPrimTyConKey threadIdPrimTyCon
190 \end{code}
191
192 %************************************************************************
193 %*                                                                      *
194 \subsection{Support code}
195 %*                                                                      *
196 %************************************************************************
197
198 alphaTyVars is a list of type variables for use in templates: 
199         ["a", "b", ..., "z", "t1", "t2", ... ]
200
201 \begin{code}
202 tyVarList :: Kind -> [TyVar]
203 tyVarList kind = [ mkTyVar (mkInternalName (mkAlphaTyVarUnique u) 
204                                 (mkTyVarOccFS (mkFastString name))
205                                 noSrcSpan) kind
206                  | u <- [2..],
207                    let name | c <= 'z'  = [c]
208                             | otherwise = 't':show u
209                             where c = chr (u-2 + ord 'a')
210                  ]
211
212 alphaTyVars :: [TyVar]
213 alphaTyVars = tyVarList liftedTypeKind
214
215 betaTyVars :: [TyVar]
216 betaTyVars = tail alphaTyVars
217
218 alphaTyVar, betaTyVar, gammaTyVar, deltaTyVar :: TyVar
219 (alphaTyVar:betaTyVar:gammaTyVar:deltaTyVar:_) = alphaTyVars
220
221 alphaTys :: [Type]
222 alphaTys = mkTyVarTys alphaTyVars
223 alphaTy, betaTy, gammaTy, deltaTy :: Type
224 (alphaTy:betaTy:gammaTy:deltaTy:_) = alphaTys
225
226         -- openAlphaTyVar is prepared to be instantiated
227         -- to a lifted or unlifted type variable.  It's used for the 
228         -- result type for "error", so that we can have (error Int# "Help")
229 openAlphaTyVars :: [TyVar]
230 openAlphaTyVar, openBetaTyVar :: TyVar
231 openAlphaTyVars@(openAlphaTyVar:openBetaTyVar:_) = tyVarList openTypeKind
232
233 openAlphaTy, openBetaTy :: Type
234 openAlphaTy = mkTyVarTy openAlphaTyVar
235 openBetaTy  = mkTyVarTy openBetaTyVar
236
237 kKiVar :: KindVar
238 kKiVar = (tyVarList superKind) !! 10
239
240 \end{code}
241
242
243 %************************************************************************
244 %*                                                                      *
245                 FunTyCon
246 %*                                                                      *
247 %************************************************************************
248
249 \begin{code}
250 funTyConName :: Name
251 funTyConName = mkPrimTyConName (fsLit "(->)") funTyConKey funTyCon
252
253 funTyCon :: TyCon
254 funTyCon = mkFunTyCon funTyConName $ 
255            mkArrowKinds [liftedTypeKind, liftedTypeKind] liftedTypeKind
256         -- You might think that (->) should have type (?? -> ? -> *), and you'd be right
257         -- But if we do that we get kind errors when saying
258         --      instance Control.Arrow (->)
259         -- because the expected kind is (*->*->*).  The trouble is that the
260         -- expected/actual stuff in the unifier does not go contra-variant, whereas
261         -- the kind sub-typing does.  Sigh.  It really only matters if you use (->) in
262         -- a prefix way, thus:  (->) Int# Int#.  And this is unusual.
263         -- because they are never in scope in the source
264
265 -- One step to remove subkinding.
266 -- (->) :: * -> * -> *
267 -- but we should have (and want) the following typing rule for fully applied arrows
268 --      Gamma |- tau   :: k1    k1 in {*, #}
269 --      Gamma |- sigma :: k2    k2 in {*, #, (#)}
270 --      -----------------------------------------
271 --      Gamma |- tau -> sigma :: *
272 -- Currently we have the following rule which achieves more or less the same effect
273 --      Gamma |- tau   :: ??
274 --      Gamma |- sigma :: ?
275 --      --------------------------
276 --      Gamma |- tau -> sigma :: *
277 -- In the end we don't want subkinding at all.
278 \end{code}
279
280
281 %************************************************************************
282 %*                                                                      *
283                 Kinds
284 %*                                                                      *
285 %************************************************************************
286
287 Note [SuperKind (BOX)]
288 ~~~~~~~~~~~~~~~~~~~~~~
289 Kinds are classified by "super-kinds".  There is only one super-kind, namely BOX.
290
291 Perhaps surprisingly we give BOX the kind BOX, thus   BOX :: BOX
292 Reason: we want to have kind equalities, thus (without the kind applications)
293             keq :: * ~ * = Eq# <refl *>
294 Remember that
295    (~)  :: forall (k:BOX). k -> k -> Constraint
296    (~#) :: forall (k:BOX). k -> k -> #
297    Eq#  :: forall (k:BOX). forall (a:k) (b:k). (~#) k a b -> (~) k a b
298
299 So the full defn of keq is
300    keq :: (~) BOX * * = Eq# BOX * * <refl *>
301
302 So you can see it's convenient to have BOX:BOX
303
304
305 \begin{code}
306 -- | See "Type#kind_subtyping" for details of the distinction between the 'Kind' 'TyCon's
307 superKindTyCon, anyKindTyCon, liftedTypeKindTyCon,
308       openTypeKindTyCon, unliftedTypeKindTyCon,
309       constraintKindTyCon
310    :: TyCon
311 superKindTyConName, anyKindTyConName, liftedTypeKindTyConName,
312       openTypeKindTyConName, unliftedTypeKindTyConName,
313       constraintKindTyConName
314    :: Name
315
316 superKindTyCon        = mkKindTyCon superKindTyConName        superKind
317    -- See Note [SuperKind (BOX)]
318
319 anyKindTyCon          = mkKindTyCon anyKindTyConName          superKind
320 liftedTypeKindTyCon   = mkKindTyCon liftedTypeKindTyConName   superKind
321 openTypeKindTyCon     = mkKindTyCon openTypeKindTyConName     superKind
322 unliftedTypeKindTyCon = mkKindTyCon unliftedTypeKindTyConName superKind
323 constraintKindTyCon   = mkKindTyCon constraintKindTyConName   superKind
324
325 --------------------------
326 -- ... and now their names
327
328 -- If you edit these, you may need to update the GHC formalism
329 -- See Note [GHC Formalism] in coreSyn/CoreLint.lhs
330 superKindTyConName      = mkPrimTyConName (fsLit "BOX") superKindTyConKey superKindTyCon
331 anyKindTyConName          = mkPrimTyConName (fsLit "AnyK") anyKindTyConKey anyKindTyCon
332 liftedTypeKindTyConName   = mkPrimTyConName (fsLit "*") liftedTypeKindTyConKey liftedTypeKindTyCon
333 openTypeKindTyConName     = mkPrimTyConName (fsLit "OpenKind") openTypeKindTyConKey openTypeKindTyCon
334 unliftedTypeKindTyConName = mkPrimTyConName (fsLit "#") unliftedTypeKindTyConKey unliftedTypeKindTyCon
335 constraintKindTyConName   = mkPrimTyConName (fsLit "Constraint") constraintKindTyConKey constraintKindTyCon
336
337 mkPrimTyConName :: FastString -> Unique -> TyCon -> Name
338 mkPrimTyConName occ key tycon = mkWiredInName gHC_PRIM (mkTcOccFS occ) 
339                                               key 
340                                               (ATyCon tycon)
341                                               BuiltInSyntax
342         -- All of the super kinds and kinds are defined in Prim and use BuiltInSyntax,
343         -- because they are never in scope in the source
344 \end{code}
345
346
347 \begin{code}
348 kindTyConType :: TyCon -> Type
349 kindTyConType kind = TyConApp kind []   -- mkTyConApp isn't defined yet
350
351 -- | See "Type#kind_subtyping" for details of the distinction between these 'Kind's
352 anyKind, liftedTypeKind, unliftedTypeKind, openTypeKind, constraintKind, superKind :: Kind
353
354 superKind        = kindTyConType superKindTyCon 
355 anyKind          = kindTyConType anyKindTyCon  -- See Note [Any kinds]
356 liftedTypeKind   = kindTyConType liftedTypeKindTyCon
357 unliftedTypeKind = kindTyConType unliftedTypeKindTyCon
358 openTypeKind     = kindTyConType openTypeKindTyCon
359 constraintKind   = kindTyConType constraintKindTyCon
360
361 -- | Given two kinds @k1@ and @k2@, creates the 'Kind' @k1 -> k2@
362 mkArrowKind :: Kind -> Kind -> Kind
363 mkArrowKind k1 k2 = FunTy k1 k2
364
365 -- | Iterated application of 'mkArrowKind'
366 mkArrowKinds :: [Kind] -> Kind -> Kind
367 mkArrowKinds arg_kinds result_kind = foldr mkArrowKind result_kind arg_kinds
368 \end{code}
369
370 %************************************************************************
371 %*                                                                      *
372 \subsection[TysPrim-basic]{Basic primitive types (@Char#@, @Int#@, etc.)}
373 %*                                                                      *
374 %************************************************************************
375
376 \begin{code}
377 -- only used herein
378 pcPrimTyCon :: Name -> [Role] -> PrimRep -> TyCon
379 pcPrimTyCon name roles rep
380   = mkPrimTyCon name kind roles rep
381   where
382     kind        = mkArrowKinds (map (const liftedTypeKind) roles) result_kind
383     result_kind = unliftedTypeKind
384
385 pcPrimTyCon0 :: Name -> PrimRep -> TyCon
386 pcPrimTyCon0 name rep
387   = mkPrimTyCon name result_kind [] rep
388   where
389     result_kind = unliftedTypeKind
390
391 charPrimTy :: Type
392 charPrimTy      = mkTyConTy charPrimTyCon
393 charPrimTyCon :: TyCon
394 charPrimTyCon   = pcPrimTyCon0 charPrimTyConName WordRep
395
396 intPrimTy :: Type
397 intPrimTy       = mkTyConTy intPrimTyCon
398 intPrimTyCon :: TyCon
399 intPrimTyCon    = pcPrimTyCon0 intPrimTyConName IntRep
400
401 int32PrimTy :: Type
402 int32PrimTy     = mkTyConTy int32PrimTyCon
403 int32PrimTyCon :: TyCon
404 int32PrimTyCon  = pcPrimTyCon0 int32PrimTyConName IntRep
405
406 int64PrimTy :: Type
407 int64PrimTy     = mkTyConTy int64PrimTyCon
408 int64PrimTyCon :: TyCon
409 int64PrimTyCon  = pcPrimTyCon0 int64PrimTyConName Int64Rep
410
411 wordPrimTy :: Type
412 wordPrimTy      = mkTyConTy wordPrimTyCon
413 wordPrimTyCon :: TyCon
414 wordPrimTyCon   = pcPrimTyCon0 wordPrimTyConName WordRep
415
416 word32PrimTy :: Type
417 word32PrimTy    = mkTyConTy word32PrimTyCon
418 word32PrimTyCon :: TyCon
419 word32PrimTyCon = pcPrimTyCon0 word32PrimTyConName WordRep
420
421 word64PrimTy :: Type
422 word64PrimTy    = mkTyConTy word64PrimTyCon
423 word64PrimTyCon :: TyCon
424 word64PrimTyCon = pcPrimTyCon0 word64PrimTyConName Word64Rep
425
426 addrPrimTy :: Type
427 addrPrimTy      = mkTyConTy addrPrimTyCon
428 addrPrimTyCon :: TyCon
429 addrPrimTyCon   = pcPrimTyCon0 addrPrimTyConName AddrRep
430
431 floatPrimTy     :: Type
432 floatPrimTy     = mkTyConTy floatPrimTyCon
433 floatPrimTyCon :: TyCon
434 floatPrimTyCon  = pcPrimTyCon0 floatPrimTyConName FloatRep
435
436 doublePrimTy :: Type
437 doublePrimTy    = mkTyConTy doublePrimTyCon
438 doublePrimTyCon :: TyCon
439 doublePrimTyCon = pcPrimTyCon0 doublePrimTyConName DoubleRep
440 \end{code}
441
442
443 %************************************************************************
444 %*                                                                      *
445 \subsection[TysPrim-state]{The @State#@ type (and @_RealWorld@ types)}
446 %*                                                                      *
447 %************************************************************************
448
449 Note [The ~# TyCon)
450 ~~~~~~~~~~~~~~~~~~~~
451 There is a perfectly ordinary type constructor ~# that represents the type
452 of coercions (which, remember, are values).  For example
453    Refl Int :: ~# * Int Int
454
455 It is a kind-polymorphic type constructor like Any:
456    Refl Maybe :: ~# (* -> *) Maybe Maybe
457
458 (~) only appears saturated. So we check that in CoreLint (and, in an
459 assertion, in Kind.typeKind).
460
461 Note [The State# TyCon]
462 ~~~~~~~~~~~~~~~~~~~~~~~
463 State# is the primitive, unlifted type of states.  It has one type parameter,
464 thus
465         State# RealWorld
466 or
467         State# s
468
469 where s is a type variable. The only purpose of the type parameter is to
470 keep different state threads separate.  It is represented by nothing at all.
471
472 The type parameter to State# is intended to keep separate threads separate.
473 Even though this parameter is not used in the definition of State#, it is
474 given role Nominal to enforce its intended use.
475
476 \begin{code}
477 mkStatePrimTy :: Type -> Type
478 mkStatePrimTy ty = TyConApp statePrimTyCon [ty]
479
480 statePrimTyCon :: TyCon   -- See Note [The State# TyCon]
481 statePrimTyCon   = pcPrimTyCon statePrimTyConName [Nominal] VoidRep
482
483 voidPrimTy :: Type
484 voidPrimTy = TyConApp voidPrimTyCon []
485
486 voidPrimTyCon :: TyCon
487 voidPrimTyCon    = pcPrimTyCon voidPrimTyConName [] VoidRep
488
489 mkProxyPrimTy :: Type -> Type -> Type
490 mkProxyPrimTy k ty = TyConApp proxyPrimTyCon [k, ty]
491
492 proxyPrimTyCon :: TyCon
493 proxyPrimTyCon = mkPrimTyCon proxyPrimTyConName kind [Nominal,Nominal] VoidRep
494   where kind = ForAllTy kv $ mkArrowKind k unliftedTypeKind
495         kv   = kKiVar
496         k    = mkTyVarTy kv
497
498 eqPrimTyCon :: TyCon  -- The representation type for equality predicates
499                       -- See Note [The ~# TyCon]
500 eqPrimTyCon  = mkPrimTyCon eqPrimTyConName kind [Nominal, Nominal, Nominal] VoidRep
501   where kind = ForAllTy kv $ mkArrowKinds [k, k] unliftedTypeKind
502         kv = kKiVar
503         k = mkTyVarTy kv
504
505 -- like eqPrimTyCon, but the type for *Representational* coercions
506 -- this should only ever appear as the type of a covar. Its role is
507 -- interpreted in coercionRole
508 eqReprPrimTyCon :: TyCon
509 eqReprPrimTyCon = mkPrimTyCon eqReprPrimTyConName kind
510                                   -- the roles really should be irrelevant!
511                               [Nominal, Representational, Representational] VoidRep
512   where kind = ForAllTy kv $ mkArrowKinds [k, k] unliftedTypeKind
513         kv = kKiVar
514         k  = mkTyVarTy kv
515 \end{code}
516
517 RealWorld is deeply magical.  It is *primitive*, but it is not
518 *unlifted* (hence ptrArg).  We never manipulate values of type
519 RealWorld; it's only used in the type system, to parameterise State#.
520
521 \begin{code}
522 realWorldTyCon :: TyCon
523 realWorldTyCon = mkLiftedPrimTyCon realWorldTyConName liftedTypeKind [] PtrRep
524 realWorldTy :: Type
525 realWorldTy          = mkTyConTy realWorldTyCon
526 realWorldStatePrimTy :: Type
527 realWorldStatePrimTy = mkStatePrimTy realWorldTy        -- State# RealWorld
528 \end{code}
529
530 Note: the ``state-pairing'' types are not truly primitive, so they are
531 defined in \tr{TysWiredIn.lhs}, not here.
532
533 %************************************************************************
534 %*                                                                      *
535 \subsection[TysPrim-arrays]{The primitive array types}
536 %*                                                                      *
537 %************************************************************************
538
539 \begin{code}
540 arrayPrimTyCon, mutableArrayPrimTyCon, mutableByteArrayPrimTyCon,
541     byteArrayPrimTyCon, arrayArrayPrimTyCon, mutableArrayArrayPrimTyCon :: TyCon
542 arrayPrimTyCon             = pcPrimTyCon arrayPrimTyConName             [Representational] PtrRep
543 mutableArrayPrimTyCon      = pcPrimTyCon  mutableArrayPrimTyConName     [Nominal, Representational] PtrRep
544 mutableByteArrayPrimTyCon  = pcPrimTyCon mutableByteArrayPrimTyConName  [Nominal] PtrRep
545 byteArrayPrimTyCon         = pcPrimTyCon0 byteArrayPrimTyConName        PtrRep
546 arrayArrayPrimTyCon        = pcPrimTyCon0 arrayArrayPrimTyConName       PtrRep
547 mutableArrayArrayPrimTyCon = pcPrimTyCon mutableArrayArrayPrimTyConName [Nominal] PtrRep
548
549 mkArrayPrimTy :: Type -> Type
550 mkArrayPrimTy elt           = TyConApp arrayPrimTyCon [elt]
551 byteArrayPrimTy :: Type
552 byteArrayPrimTy             = mkTyConTy byteArrayPrimTyCon
553 mkArrayArrayPrimTy :: Type
554 mkArrayArrayPrimTy = mkTyConTy arrayArrayPrimTyCon
555 mkMutableArrayPrimTy :: Type -> Type -> Type
556 mkMutableArrayPrimTy s elt  = TyConApp mutableArrayPrimTyCon [s, elt]
557 mkMutableByteArrayPrimTy :: Type -> Type
558 mkMutableByteArrayPrimTy s  = TyConApp mutableByteArrayPrimTyCon [s]
559 mkMutableArrayArrayPrimTy :: Type -> Type
560 mkMutableArrayArrayPrimTy s = TyConApp mutableArrayArrayPrimTyCon [s]
561 \end{code}
562
563 %************************************************************************
564 %*                                                                      *
565 \subsection[TysPrim-mut-var]{The mutable variable type}
566 %*                                                                      *
567 %************************************************************************
568
569 \begin{code}
570 mutVarPrimTyCon :: TyCon
571 mutVarPrimTyCon = pcPrimTyCon mutVarPrimTyConName [Nominal, Representational] PtrRep
572
573 mkMutVarPrimTy :: Type -> Type -> Type
574 mkMutVarPrimTy s elt        = TyConApp mutVarPrimTyCon [s, elt]
575 \end{code}
576
577 %************************************************************************
578 %*                                                                      *
579 \subsection[TysPrim-synch-var]{The synchronizing variable type}
580 %*                                                                      *
581 %************************************************************************
582
583 \begin{code}
584 mVarPrimTyCon :: TyCon
585 mVarPrimTyCon = pcPrimTyCon mVarPrimTyConName [Nominal, Representational] PtrRep
586
587 mkMVarPrimTy :: Type -> Type -> Type
588 mkMVarPrimTy s elt          = TyConApp mVarPrimTyCon [s, elt]
589 \end{code}
590
591 %************************************************************************
592 %*                                                                      *
593 \subsection[TysPrim-stm-var]{The transactional variable type}
594 %*                                                                      *
595 %************************************************************************
596
597 \begin{code}
598 tVarPrimTyCon :: TyCon
599 tVarPrimTyCon = pcPrimTyCon tVarPrimTyConName [Nominal, Representational] PtrRep
600
601 mkTVarPrimTy :: Type -> Type -> Type
602 mkTVarPrimTy s elt = TyConApp tVarPrimTyCon [s, elt]
603 \end{code}
604
605 %************************************************************************
606 %*                                                                      *
607 \subsection[TysPrim-stable-ptrs]{The stable-pointer type}
608 %*                                                                      *
609 %************************************************************************
610
611 \begin{code}
612 stablePtrPrimTyCon :: TyCon
613 stablePtrPrimTyCon = pcPrimTyCon stablePtrPrimTyConName [Representational] AddrRep
614
615 mkStablePtrPrimTy :: Type -> Type
616 mkStablePtrPrimTy ty = TyConApp stablePtrPrimTyCon [ty]
617 \end{code}
618
619 %************************************************************************
620 %*                                                                      *
621 \subsection[TysPrim-stable-names]{The stable-name type}
622 %*                                                                      *
623 %************************************************************************
624
625 \begin{code}
626 stableNamePrimTyCon :: TyCon
627 stableNamePrimTyCon = pcPrimTyCon stableNamePrimTyConName [Representational] PtrRep
628
629 mkStableNamePrimTy :: Type -> Type
630 mkStableNamePrimTy ty = TyConApp stableNamePrimTyCon [ty]
631 \end{code}
632
633 %************************************************************************
634 %*                                                                      *
635 \subsection[TysPrim-BCOs]{The ``bytecode object'' type}
636 %*                                                                      *
637 %************************************************************************
638
639 \begin{code}
640 bcoPrimTy    :: Type
641 bcoPrimTy    = mkTyConTy bcoPrimTyCon
642 bcoPrimTyCon :: TyCon
643 bcoPrimTyCon = pcPrimTyCon0 bcoPrimTyConName PtrRep
644 \end{code}
645   
646 %************************************************************************
647 %*                                                                      *
648 \subsection[TysPrim-Weak]{The ``weak pointer'' type}
649 %*                                                                      *
650 %************************************************************************
651
652 \begin{code}
653 weakPrimTyCon :: TyCon
654 weakPrimTyCon = pcPrimTyCon weakPrimTyConName [Representational] PtrRep
655
656 mkWeakPrimTy :: Type -> Type
657 mkWeakPrimTy v = TyConApp weakPrimTyCon [v]
658 \end{code}
659
660 %************************************************************************
661 %*                                                                      *
662 \subsection[TysPrim-thread-ids]{The ``thread id'' type}
663 %*                                                                      *
664 %************************************************************************
665
666 A thread id is represented by a pointer to the TSO itself, to ensure
667 that they are always unique and we can always find the TSO for a given
668 thread id.  However, this has the unfortunate consequence that a
669 ThreadId# for a given thread is treated as a root by the garbage
670 collector and can keep TSOs around for too long.
671
672 Hence the programmer API for thread manipulation uses a weak pointer
673 to the thread id internally.
674
675 \begin{code}
676 threadIdPrimTy :: Type
677 threadIdPrimTy    = mkTyConTy threadIdPrimTyCon
678 threadIdPrimTyCon :: TyCon
679 threadIdPrimTyCon = pcPrimTyCon0 threadIdPrimTyConName PtrRep
680 \end{code}
681
682 %************************************************************************
683 %*                                                                      *
684                 Any
685 %*                                                                      *
686 %************************************************************************
687
688 Note [Any types]
689 ~~~~~~~~~~~~~~~~
690 The type constructor Any of kind forall k. k -> k has these properties:
691
692   * It is defined in module GHC.Prim, and exported so that it is 
693     available to users.  For this reason it's treated like any other 
694     primitive type:
695       - has a fixed unique, anyTyConKey, 
696       - lives in the global name cache
697
698   * It is a *closed* type family, with no instances.  This means that
699     if   ty :: '(k1, k2)  we add a given coercion
700              g :: ty ~ (Fst ty, Snd ty)
701     If Any was a *data* type, then we'd get inconsistency because 'ty'
702     could be (Any '(k1,k2)) and then we'd have an equality with Any on
703     one side and '(,) on the other
704
705   * It is lifted, and hence represented by a pointer
706
707   * It is inhabited by at least one value, namely bottom
708
709   * You can unsafely coerce any lifted type to Any, and back.
710
711   * It does not claim to be a *data* type, and that's important for
712     the code generator, because the code gen may *enter* a data value
713     but never enters a function value. 
714
715   * It is used to instantiate otherwise un-constrained type variables
716     For example         length Any []
717     See Note [Strangely-kinded void TyCons]
718
719 Note [Any kinds]
720 ~~~~~~~~~~~~~~~~
721
722 The type constructor AnyK (of sort BOX) is used internally only to zonk kind
723 variables with no constraints on them. It appears in similar circumstances to
724 Any, but at the kind level. For example:
725
726   type family Length (l :: [k]) :: Nat
727   type instance Length [] = Zero
728
729 Length is kind-polymorphic, and when applied to the empty (promoted) list it
730 will have the kind Length AnyK [].
731
732 Note [Strangely-kinded void TyCons]
733 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
734 See Trac #959 for more examples
735
736 When the type checker finds a type variable with no binding, which
737 means it can be instantiated with an arbitrary type, it usually
738 instantiates it to Void.  Eg.
739
740         length []
741 ===>
742         length Any (Nil Any)
743
744 But in really obscure programs, the type variable might have a kind
745 other than *, so we need to invent a suitably-kinded type.
746
747 This commit uses
748         Any for kind *
749         Any(*->*) for kind *->*
750         etc
751
752 \begin{code}
753 anyTyConName :: Name
754 anyTyConName = mkPrimTc (fsLit "Any") anyTyConKey anyTyCon
755
756 anyTy :: Type
757 anyTy = mkTyConTy anyTyCon
758
759 anyTyCon :: TyCon
760 anyTyCon = mkLiftedPrimTyCon anyTyConName kind [Nominal] PtrRep
761   where kind = ForAllTy kKiVar (mkTyVarTy kKiVar)
762
763 {-   Can't do this yet without messing up kind proxies
764 -- RAE: I think you can now.
765 anyTyCon :: TyCon
766 anyTyCon = mkSynTyCon anyTyConName kind [kKiVar] 
767                       syn_rhs
768                       NoParentTyCon
769   where 
770     kind = ForAllTy kKiVar (mkTyVarTy kKiVar)
771     syn_rhs = SynFamilyTyCon { synf_open = False, synf_injective = True }
772                   -- NB Closed, injective
773 -}
774
775 anyTypeOfKind :: Kind -> Type
776 anyTypeOfKind kind = TyConApp anyTyCon [kind]
777 \end{code}
778
779 %************************************************************************
780 %*                                                                      *
781 \subsection{SIMD vector types}
782 %*                                                                      *
783 %************************************************************************
784
785 \begin{code}
786 #include "primop-vector-tys.hs-incl"
787 \end{code}