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