2 % (c) The GRASP Project, Glasgow University, 1994-1998
4 \section[TysWiredIn]{Wired-in knowledge about {\em non-primitive} types}
6 This module is about types that can be defined in Haskell, but which
7 must be wired into the compiler nonetheless.
9 This module tracks the ``state interface'' document, ``GHC prelude:
10 types and operations.''
52 tupleTyCon, tupleCon, unitTyCon, unitDataCon, pairTyCon, pairDataCon,
56 unboxedTupleTyCon, unboxedTupleCon,
57 unboxedPairTyCon, unboxedPairDataCon,
68 isFFIArgumentTy, -- :: Bool -> Type -> Bool
69 isFFIResultTy, -- :: Type -> Bool
70 isFFIExternalTy, -- :: Type -> Bool
71 isAddrTy, -- :: Type -> Bool
72 isForeignObjTy -- :: Type -> Bool
76 #include "HsVersions.h"
78 import {-# SOURCE #-} MkId( mkDataConId )
85 import Constants ( mAX_TUPLE_SIZE )
86 import Module ( Module, mkPrelModule )
87 import Name ( mkWiredInTyConName, mkWiredInIdName, mkSrcOccFS, dataName )
88 import DataCon ( DataCon, StrictnessMark(..), mkDataCon )
89 import Var ( TyVar, tyVarKind )
90 import TyCon ( TyCon, ArgVrcs, mkAlgTyCon, mkSynTyCon, mkTupleTyCon )
91 import BasicTypes ( Arity, NewOrData(..), RecFlag(..) )
92 import Type ( Type, mkTyConTy, mkTyConApp, mkSigmaTy, mkTyVarTys,
93 mkArrowKinds, boxedTypeKind, unboxedTypeKind,
94 mkFunTy, mkFunTys, isUnLiftedType,
95 splitTyConApp_maybe, splitAlgTyConApp_maybe,
97 import PrimRep ( PrimRep(..) )
99 import CmdLineOpts ( opt_GlasgowExts )
100 import Util ( assoc )
101 import Panic ( panic )
104 alpha_tyvar = [alphaTyVar]
106 alpha_beta_tyvars = [alphaTyVar, betaTyVar]
108 pcRecDataTyCon, pcNonRecDataTyCon, pcNonRecNewTyCon
109 :: Unique{-TyConKey-} -> Module -> FAST_STRING
110 -> [TyVar] -> ArgVrcs -> [DataCon] -> TyCon
112 pcRecDataTyCon = pcTyCon DataType Recursive
113 pcNonRecDataTyCon = pcTyCon DataType NonRecursive
114 pcNonRecNewTyCon = pcTyCon NewType NonRecursive
116 pcTyCon new_or_data is_rec key mod str tyvars argvrcs cons
119 tycon = mkAlgTyCon name kind
125 Nothing -- Not a dictionary
129 name = mkWiredInTyConName key mod str tycon
130 kind = mkArrowKinds (map tyVarKind tyvars) boxedTypeKind
132 pcSynTyCon key mod str kind arity tyvars expansion argvrcs -- this fun never used!
135 tycon = mkSynTyCon name kind arity tyvars expansion argvrcs
136 name = mkWiredInTyConName key mod str tycon
138 pcDataCon :: Unique{-DataConKey-} -> Module -> FAST_STRING
139 -> [TyVar] -> ThetaType -> [TauType] -> TyCon -> DataCon
140 pcDataCon key mod str tyvars context arg_tys tycon
143 data_con = mkDataCon name
144 [ NotMarkedStrict | a <- arg_tys ]
145 [ {- no labelled fields -} ]
146 tyvars context [] [] arg_tys tycon id
147 name = mkWiredInIdName key mod (mkSrcOccFS dataName str) id
148 id = mkDataConId data_con
151 %************************************************************************
153 \subsection[TysWiredIn-tuples]{The tuple types}
155 %************************************************************************
158 tupleTyCon :: Arity -> TyCon
159 tupleTyCon i | i > mAX_TUPLE_SIZE = fst (mk_tuple i) -- Build one specially
160 | otherwise = tupleTyConArr!i
162 tupleCon :: Arity -> DataCon
163 tupleCon i | i > mAX_TUPLE_SIZE = snd (mk_tuple i) -- Build one specially
164 | otherwise = tupleConArr!i
166 tupleTyCons :: [TyCon]
167 tupleTyCons = elems tupleTyConArr
169 tupleTyConArr :: Array Int TyCon
170 tupleTyConArr = array (0,mAX_TUPLE_SIZE) ([0..] `zip` map fst tuples)
172 tupleConArr :: Array Int DataCon
173 tupleConArr = array (0,mAX_TUPLE_SIZE) ([0..] `zip` map snd tuples)
175 tuples :: [(TyCon,DataCon)]
176 tuples = [mk_tuple i | i <- [0..mAX_TUPLE_SIZE]]
178 mk_tuple :: Int -> (TyCon,DataCon)
179 mk_tuple arity = (tycon, tuple_con)
181 tycon = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con True
182 tc_name = mkWiredInTyConName tc_uniq mod name_str tycon
183 tc_kind = mkArrowKinds (map tyVarKind tyvars) boxedTypeKind
185 tuple_con = pcDataCon dc_uniq mod name_str tyvars [] tyvar_tys tycon
186 tyvars = take arity alphaTyVars
187 tyvar_tys = mkTyVarTys tyvars
188 (mod_name, name_str) = mkTupNameStr arity
189 tc_uniq = mkTupleTyConUnique arity
190 dc_uniq = mkTupleDataConUnique arity
191 mod = mkPrelModule mod_name
193 unitTyCon = tupleTyCon 0
194 pairTyCon = tupleTyCon 2
196 unitDataCon = tupleCon 0
197 pairDataCon = tupleCon 2
200 %************************************************************************
202 \subsection[TysWiredIn-ubx-tuples]{Unboxed Tuple Types}
204 %************************************************************************
207 unboxedTupleTyCon :: Arity -> TyCon
208 unboxedTupleTyCon i | i > mAX_TUPLE_SIZE = fst (mk_unboxed_tuple i)
209 | otherwise = unboxedTupleTyConArr!i
211 unboxedTupleCon :: Arity -> DataCon
212 unboxedTupleCon i | i > mAX_TUPLE_SIZE = snd (mk_unboxed_tuple i)
213 | otherwise = unboxedTupleConArr!i
215 unboxedTupleTyConArr :: Array Int TyCon
216 unboxedTupleTyConArr = array (0,mAX_TUPLE_SIZE) ([0..] `zip` map fst ubx_tuples)
218 unboxedTupleConArr :: Array Int DataCon
219 unboxedTupleConArr = array (0,mAX_TUPLE_SIZE) ([0..] `zip` map snd ubx_tuples)
221 ubx_tuples :: [(TyCon,DataCon)]
222 ubx_tuples = [mk_unboxed_tuple i | i <- [0..mAX_TUPLE_SIZE]]
224 mk_unboxed_tuple :: Int -> (TyCon,DataCon)
225 mk_unboxed_tuple arity = (tycon, tuple_con)
227 tycon = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con False
228 tc_name = mkWiredInTyConName tc_uniq mod name_str tycon
229 tc_kind = mkArrowKinds (map tyVarKind tyvars) unboxedTypeKind
231 tuple_con = pcDataCon dc_uniq mod name_str tyvars [] tyvar_tys tycon
232 tyvars = take arity openAlphaTyVars
233 tyvar_tys = mkTyVarTys tyvars
234 (mod_name, name_str) = mkUbxTupNameStr arity
235 tc_uniq = mkUbxTupleTyConUnique arity
236 dc_uniq = mkUbxTupleDataConUnique arity
237 mod = mkPrelModule mod_name
239 unboxedPairTyCon = unboxedTupleTyCon 2
240 unboxedPairDataCon = unboxedTupleCon 2
243 %************************************************************************
245 \subsection[TysWiredIn-boxed-prim]{The ``boxed primitive'' types (@Char@, @Int@, etc)}
247 %************************************************************************
250 -- The Void type is represented as a data type with no constructors
251 -- It's a built in type (i.e. there's no way to define it in Haskell;
252 -- the nearest would be
254 -- data Void = -- No constructors!
256 -- ) It's boxed; there is only one value of this
257 -- type, namely "void", whose semantics is just bottom.
259 -- Haskell 98 drops the definition of a Void type, so we just 'simulate'
266 charTy = mkTyConTy charTyCon
268 charTyCon = pcNonRecDataTyCon charTyConKey pREL_BASE SLIT("Char") [] [] [charDataCon]
269 charDataCon = pcDataCon charDataConKey pREL_BASE SLIT("C#") [] [] [charPrimTy] charTyCon
271 stringTy = mkListTy charTy -- convenience only
275 intTy = mkTyConTy intTyCon
277 intTyCon = pcNonRecDataTyCon intTyConKey pREL_BASE SLIT("Int") [] [] [intDataCon]
278 intDataCon = pcDataCon intDataConKey pREL_BASE SLIT("I#") [] [] [intPrimTy] intTyCon
280 isIntTy :: Type -> Bool
282 = case (splitAlgTyConApp_maybe ty) of
283 Just (tycon, [], _) -> getUnique tycon == intTyConKey
286 inIntRange :: Integer -> Bool -- Tells if an integer lies in the legal range of Ints
287 inIntRange i = (min_int <= i) && (i <= max_int)
289 max_int, min_int :: Integer
290 max_int = toInteger maxInt
291 min_int = toInteger minInt
297 wordTy = mkTyConTy wordTyCon
299 wordTyCon = pcNonRecDataTyCon wordTyConKey pREL_ADDR SLIT("Word") [] [] [wordDataCon]
300 wordDataCon = pcDataCon wordDataConKey pREL_ADDR SLIT("W#") [] [] [wordPrimTy] wordTyCon
304 addrTy = mkTyConTy addrTyCon
306 addrTyCon = pcNonRecDataTyCon addrTyConKey pREL_ADDR SLIT("Addr") [] [] [addrDataCon]
307 addrDataCon = pcDataCon addrDataConKey pREL_ADDR SLIT("A#") [] [] [addrPrimTy] addrTyCon
309 isAddrTy :: Type -> Bool
311 = case (splitAlgTyConApp_maybe ty) of
312 Just (tycon, [], _) -> getUnique tycon == addrTyConKey
318 floatTy = mkTyConTy floatTyCon
320 floatTyCon = pcNonRecDataTyCon floatTyConKey pREL_BASE SLIT("Float") [] [] [floatDataCon]
321 floatDataCon = pcDataCon floatDataConKey pREL_BASE SLIT("F#") [] [] [floatPrimTy] floatTyCon
323 isFloatTy :: Type -> Bool
325 = case (splitAlgTyConApp_maybe ty) of
326 Just (tycon, [], _) -> getUnique tycon == floatTyConKey
332 doubleTy = mkTyConTy doubleTyCon
334 isDoubleTy :: Type -> Bool
336 = case (splitAlgTyConApp_maybe ty) of
337 Just (tycon, [], _) -> getUnique tycon == doubleTyConKey
340 doubleTyCon = pcNonRecDataTyCon doubleTyConKey pREL_BASE SLIT("Double") [] [] [doubleDataCon]
341 doubleDataCon = pcDataCon doubleDataConKey pREL_BASE SLIT("D#") [] [] [doublePrimTy] doubleTyCon
346 = pcNonRecDataTyCon stablePtrTyConKey pREL_STABLE SLIT("StablePtr")
347 alpha_tyvar [(True,False)] [stablePtrDataCon]
350 = pcDataCon stablePtrDataConKey pREL_STABLE SLIT("StablePtr")
351 alpha_tyvar [] [mkStablePtrPrimTy alphaTy] stablePtrTyCon
356 = pcNonRecDataTyCon foreignObjTyConKey pREL_IO_BASE SLIT("ForeignObj")
357 [] [] [foreignObjDataCon]
360 = pcDataCon foreignObjDataConKey pREL_IO_BASE SLIT("ForeignObj")
361 [] [] [foreignObjPrimTy] foreignObjTyCon
364 %************************************************************************
366 \subsection[TysWiredIn-Integer]{@Integer@ and its related ``pairing'' types}
368 %************************************************************************
370 @Integer@ and its pals are not really primitive. @Integer@ itself, first:
373 integerTy = mkTyConTy integerTyCon
375 integerTyCon = pcNonRecDataTyCon integerTyConKey pREL_BASE SLIT("Integer")
376 [] [] [smallIntegerDataCon, largeIntegerDataCon]
378 smallIntegerDataCon = pcDataCon smallIntegerDataConKey pREL_BASE SLIT("S#")
379 [] [] [intPrimTy] integerTyCon
380 largeIntegerDataCon = pcDataCon largeIntegerDataConKey pREL_BASE SLIT("J#")
381 [] [] [intPrimTy, byteArrayPrimTy] integerTyCon
384 isIntegerTy :: Type -> Bool
386 = case (splitAlgTyConApp_maybe ty) of
387 Just (tycon, [], _) -> getUnique tycon == integerTyConKey
392 %************************************************************************
394 \subsection[TysWiredIn-ext-type]{External types}
396 %************************************************************************
398 The compiler's foreign function interface supports the passing of a
399 restricted set of types as arguments and results (the restricting factor
403 isFFIArgumentTy :: Bool -> Type -> Bool
404 isFFIArgumentTy forASafeCall ty =
405 (opt_GlasgowExts && isUnLiftedType ty) ||
406 case (splitAlgTyConApp_maybe ty) of
407 Just (tycon, _, _) ->
411 u `elem` primArgTyConKeys && -- it has a suitable prim type, and
412 (not forASafeCall || not ( u `elem` notSafeExternalTyCons)) -- it is safe to pass out.
415 -- types that can be passed as arguments to "foreign" functions
417 = [ intTyConKey, int8TyConKey, int16TyConKey, int32TyConKey, int64TyConKey
418 , wordTyConKey, word8TyConKey, word16TyConKey, word32TyConKey, word64TyConKey
419 , floatTyConKey, doubleTyConKey
420 , addrTyConKey, charTyConKey, foreignObjTyConKey
422 , byteArrayTyConKey, mutableByteArrayTyConKey
425 -- types that can be passed from the outside world into Haskell.
426 -- excludes (mutable) byteArrays.
427 isFFIExternalTy :: Type -> Bool
429 (opt_GlasgowExts && isUnLiftedType ty) || --leave out for now: maybeToBool (maybeBoxedPrimType ty))) ||
430 case (splitAlgTyConApp_maybe ty) of
431 Just (tycon, _, _) ->
433 u_tycon = getUnique tycon
435 (u_tycon `elem` primArgTyConKeys) &&
436 not (u_tycon `elem` notLegalExternalTyCons)
440 isFFIResultTy :: Type -> Bool
442 not (isUnLiftedType ty) &&
443 case (splitAlgTyConApp_maybe ty) of
444 Just (tycon, _, _) ->
446 u_tycon = getUnique tycon
448 (u_tycon == getUnique unitTyCon) ||
449 ((u_tycon `elem` primArgTyConKeys) &&
450 not (u_tycon `elem` notLegalExternalTyCons))
453 -- it's illegal to return foreign objects and (mutable)
454 -- bytearrays from a _ccall_ / foreign declaration
455 -- (or be passed them as arguments in foreign exported functions).
456 notLegalExternalTyCons =
457 [ foreignObjTyConKey, byteArrayTyConKey, mutableByteArrayTyConKey ]
459 -- it's really unsafe to pass out references to objects in the heap,
460 -- so for safe call-outs we simply disallow it.
461 notSafeExternalTyCons =
462 [ byteArrayTyConKey, mutableByteArrayTyConKey ]
465 isForeignObjTy :: Type -> Bool
467 case (splitAlgTyConApp_maybe ty) of
468 Just (tycon, _, _) -> (getUnique tycon) == foreignObjTyConKey
473 %************************************************************************
475 \subsection[TysWiredIn-Bool]{The @Bool@ type}
477 %************************************************************************
479 An ordinary enumeration type, but deeply wired in. There are no
480 magical operations on @Bool@ (just the regular Prelude code).
482 {\em BEGIN IDLE SPECULATION BY SIMON}
484 This is not the only way to encode @Bool@. A more obvious coding makes
485 @Bool@ just a boxed up version of @Bool#@, like this:
488 data Bool = MkBool Bool#
491 Unfortunately, this doesn't correspond to what the Report says @Bool@
492 looks like! Furthermore, we get slightly less efficient code (I
493 think) with this coding. @gtInt@ would look like this:
496 gtInt :: Int -> Int -> Bool
497 gtInt x y = case x of I# x# ->
499 case (gtIntPrim x# y#) of
503 Notice that the result of the @gtIntPrim@ comparison has to be turned
504 into an integer (here called @b#@), and returned in a @MkBool@ box.
506 The @if@ expression would compile to this:
509 MkBool b# -> case b# of { 1# -> e1; 0# -> e2 }
512 I think this code is a little less efficient than the previous code,
513 but I'm not certain. At all events, corresponding with the Report is
514 important. The interesting thing is that the language is expressive
515 enough to describe more than one alternative; and that a type doesn't
516 necessarily need to be a straightforwardly boxed version of its
517 primitive counterpart.
519 {\em END IDLE SPECULATION BY SIMON}
522 boolTy = mkTyConTy boolTyCon
524 boolTyCon = pcTyCon EnumType NonRecursive boolTyConKey
525 pREL_BASE SLIT("Bool") [] [] [falseDataCon, trueDataCon]
527 falseDataCon = pcDataCon falseDataConKey pREL_BASE SLIT("False") [] [] [] boolTyCon
528 trueDataCon = pcDataCon trueDataConKey pREL_BASE SLIT("True") [] [] [] boolTyCon
531 %************************************************************************
533 \subsection[TysWiredIn-List]{The @List@ type (incl ``build'' magic)}
535 %************************************************************************
537 Special syntax, deeply wired in, but otherwise an ordinary algebraic
540 data [] a = [] | a : (List a)
542 data (,) a b = (,,) a b
547 mkListTy :: Type -> Type
548 mkListTy ty = mkTyConApp listTyCon [ty]
550 alphaListTy = mkSigmaTy alpha_tyvar [] (mkTyConApp listTyCon alpha_ty)
552 listTyCon = pcRecDataTyCon listTyConKey pREL_BASE SLIT("[]")
553 alpha_tyvar [(True,False)] [nilDataCon, consDataCon]
555 nilDataCon = pcDataCon nilDataConKey pREL_BASE SLIT("[]") alpha_tyvar [] [] listTyCon
556 consDataCon = pcDataCon consDataConKey pREL_BASE SLIT(":")
557 alpha_tyvar [] [alphaTy, mkTyConApp listTyCon alpha_ty] listTyCon
558 -- Interesting: polymorphic recursion would help here.
559 -- We can't use (mkListTy alphaTy) in the defn of consDataCon, else mkListTy
560 -- gets the over-specific type (Type -> Type)
563 %************************************************************************
565 \subsection[TysWiredIn-Tuples]{The @Tuple@ types}
567 %************************************************************************
569 The tuple types are definitely magic, because they form an infinite
574 They have a special family of type constructors, of type @TyCon@
575 These contain the tycon arity, but don't require a Unique.
578 They have a special family of constructors, of type
579 @Id@. Again these contain their arity but don't need a Unique.
582 There should be a magic way of generating the info tables and
583 entry code for all tuples.
585 But at the moment we just compile a Haskell source
586 file\srcloc{lib/prelude/...} containing declarations like:
589 data Tuple2 a b = Tup2 a b
590 data Tuple3 a b c = Tup3 a b c
591 data Tuple4 a b c d = Tup4 a b c d
594 The print-names associated with the magic @Id@s for tuple constructors
595 ``just happen'' to be the same as those generated by these
599 The instance environment should have a magic way to know
600 that each tuple type is an instances of classes @Eq@, @Ix@, @Ord@ and
601 so on. \ToDo{Not implemented yet.}
604 There should also be a way to generate the appropriate code for each
605 of these instances, but (like the info tables and entry code) it is
606 done by enumeration\srcloc{lib/prelude/InTup?.hs}.
610 mkTupleTy :: Int -> [Type] -> Type
611 mkTupleTy arity tys = mkTyConApp (tupleTyCon arity) tys
613 mkUnboxedTupleTy :: Int -> [Type] -> Type
614 mkUnboxedTupleTy arity tys = mkTyConApp (unboxedTupleTyCon arity) tys
616 unitTy = mkTupleTy 0 []