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