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