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.''
27 falseDataCon, falseDataConId,
51 tupleTyCon, tupleCon, unitTyCon, unitDataConId, pairTyCon,
55 unboxedTupleTyCon, unboxedTupleCon,
56 unboxedPairTyCon, unboxedPairDataCon,
60 trueDataCon, trueDataConId,
67 isFFIArgumentTy, -- :: Bool -> Type -> Bool
68 isFFIResultTy, -- :: Type -> Bool
69 isFFIExternalTy, -- :: Type -> Bool
70 isAddrTy, -- :: Type -> Bool
71 isForeignObjTy -- :: Type -> Bool
75 #include "HsVersions.h"
77 import {-# SOURCE #-} MkId( mkDataConId, mkDataConWrapId )
84 import Constants ( mAX_TUPLE_SIZE )
85 import Module ( Module, mkPrelModule )
86 import Name ( mkWiredInTyConName, mkWiredInIdName, mkSrcOccFS, mkWorkerOcc, dataName )
87 import DataCon ( DataCon, StrictnessMark(..), mkDataCon, dataConId )
88 import Var ( TyVar, tyVarKind )
89 import TyCon ( TyCon, AlgTyConFlavour(..), ArgVrcs, tyConDataCons,
90 mkAlgTyCon, mkSynTyCon, mkTupleTyCon, isUnLiftedTyCon
92 import BasicTypes ( Arity, NewOrData(..), RecFlag(..) )
93 import Type ( Type, mkTyConTy, mkTyConApp, mkSigmaTy, mkTyVarTys,
94 mkArrowKinds, boxedTypeKind, unboxedTypeKind,
96 splitTyConApp_maybe, repType,
97 TauType, ClassContext )
98 import PrimRep ( PrimRep(..) )
100 import CmdLineOpts ( opt_GlasgowExts )
101 import Util ( assoc )
102 import Panic ( panic )
105 alpha_tyvar = [alphaTyVar]
107 alpha_beta_tyvars = [alphaTyVar, betaTyVar]
109 pcRecDataTyCon, pcNonRecDataTyCon
110 :: Unique{-TyConKey-} -> Module -> FAST_STRING
111 -> [TyVar] -> ArgVrcs -> [DataCon] -> TyCon
113 pcRecDataTyCon = pcTyCon DataTyCon Recursive
114 pcNonRecDataTyCon = pcTyCon DataTyCon NonRecursive
116 pcTyCon new_or_data is_rec key mod str tyvars argvrcs cons
119 tycon = mkAlgTyCon name kind
128 name = mkWiredInTyConName key mod str tycon
129 kind = mkArrowKinds (map tyVarKind tyvars) boxedTypeKind
131 pcSynTyCon key mod str kind arity tyvars expansion argvrcs -- this fun never used!
134 tycon = mkSynTyCon name kind arity tyvars expansion argvrcs
135 name = mkWiredInTyConName key mod str tycon
137 pcDataCon :: Unique{-DataConKey-} -> Module -> FAST_STRING
138 -> [TyVar] -> ClassContext -> [TauType] -> TyCon -> DataCon
139 -- The unique is the first of two free uniques;
140 -- the first is used for the datacon itself and the worker;
141 -- the second is used for the wrapper.
142 pcDataCon wrap_key mod str tyvars context arg_tys tycon
145 data_con = mkDataCon wrap_name
146 [ NotMarkedStrict | a <- arg_tys ]
147 [ {- no labelled fields -} ]
148 tyvars context [] [] arg_tys tycon work_id wrap_id
150 work_occ = mkWorkerOcc wrap_occ
151 work_key = incrUnique wrap_key
152 work_name = mkWiredInIdName work_key mod work_occ work_id
153 work_id = mkDataConId work_name data_con
155 wrap_occ = mkSrcOccFS dataName str
156 wrap_name = mkWiredInIdName wrap_key mod wrap_occ wrap_id
157 wrap_id = mkDataConWrapId data_con
161 %************************************************************************
163 \subsection[TysWiredIn-tuples]{The tuple types}
165 %************************************************************************
168 tupleTyCon :: Arity -> TyCon
169 tupleTyCon i | i > mAX_TUPLE_SIZE = fst (mk_tuple i) -- Build one specially
170 | otherwise = tupleTyConArr!i
172 tupleCon :: Arity -> DataCon
173 tupleCon i | i > mAX_TUPLE_SIZE = snd (mk_tuple i) -- Build one specially
174 | otherwise = tupleConArr!i
176 tupleTyCons :: [TyCon]
177 tupleTyCons = elems tupleTyConArr
179 tupleTyConArr :: Array Int TyCon
180 tupleTyConArr = array (0,mAX_TUPLE_SIZE) ([0..] `zip` map fst tuples)
182 tupleConArr :: Array Int DataCon
183 tupleConArr = array (0,mAX_TUPLE_SIZE) ([0..] `zip` map snd tuples)
185 tuples :: [(TyCon,DataCon)]
186 tuples = [mk_tuple i | i <- [0..mAX_TUPLE_SIZE]]
188 mk_tuple :: Int -> (TyCon,DataCon)
189 mk_tuple arity = (tycon, tuple_con)
191 tycon = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con True
192 tc_name = mkWiredInTyConName tc_uniq mod name_str tycon
193 tc_kind = mkArrowKinds (map tyVarKind tyvars) boxedTypeKind
195 tuple_con = pcDataCon dc_uniq mod name_str tyvars [] tyvar_tys tycon
196 tyvars = take arity alphaTyVars
197 tyvar_tys = mkTyVarTys tyvars
198 (mod_name, name_str) = mkTupNameStr arity
199 tc_uniq = mkTupleTyConUnique arity
200 dc_uniq = mkTupleDataConUnique arity
201 mod = mkPrelModule mod_name
203 unitTyCon = tupleTyCon 0
204 unitDataConId = dataConId (head (tyConDataCons unitTyCon))
206 pairTyCon = tupleTyCon 2
209 %************************************************************************
211 \subsection[TysWiredIn-ubx-tuples]{Unboxed Tuple Types}
213 %************************************************************************
216 unboxedTupleTyCon :: Arity -> TyCon
217 unboxedTupleTyCon i | i > mAX_TUPLE_SIZE = fst (mk_unboxed_tuple i)
218 | otherwise = unboxedTupleTyConArr!i
220 unboxedTupleCon :: Arity -> DataCon
221 unboxedTupleCon i | i > mAX_TUPLE_SIZE = snd (mk_unboxed_tuple i)
222 | otherwise = unboxedTupleConArr!i
224 unboxedTupleTyConArr :: Array Int TyCon
225 unboxedTupleTyConArr = array (0,mAX_TUPLE_SIZE) ([0..] `zip` map fst ubx_tuples)
227 unboxedTupleConArr :: Array Int DataCon
228 unboxedTupleConArr = array (0,mAX_TUPLE_SIZE) ([0..] `zip` map snd ubx_tuples)
230 ubx_tuples :: [(TyCon,DataCon)]
231 ubx_tuples = [mk_unboxed_tuple i | i <- [0..mAX_TUPLE_SIZE]]
233 mk_unboxed_tuple :: Int -> (TyCon,DataCon)
234 mk_unboxed_tuple arity = (tycon, tuple_con)
236 tycon = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con False
237 tc_name = mkWiredInTyConName tc_uniq mod name_str tycon
238 tc_kind = mkArrowKinds (map tyVarKind tyvars) unboxedTypeKind
240 tuple_con = pcDataCon dc_uniq mod name_str tyvars [] tyvar_tys tycon
241 tyvars = take arity openAlphaTyVars
242 tyvar_tys = mkTyVarTys tyvars
243 (mod_name, name_str) = mkUbxTupNameStr arity
244 tc_uniq = mkUbxTupleTyConUnique arity
245 dc_uniq = mkUbxTupleDataConUnique arity
246 mod = mkPrelModule mod_name
248 unboxedPairTyCon = unboxedTupleTyCon 2
249 unboxedPairDataCon = unboxedTupleCon 2
252 %************************************************************************
254 \subsection[TysWiredIn-boxed-prim]{The ``boxed primitive'' types (@Char@, @Int@, etc)}
256 %************************************************************************
259 -- The Void type is represented as a data type with no constructors
260 -- It's a built in type (i.e. there's no way to define it in Haskell;
261 -- the nearest would be
263 -- data Void = -- No constructors!
265 -- ) It's boxed; there is only one value of this
266 -- type, namely "void", whose semantics is just bottom.
268 -- Haskell 98 drops the definition of a Void type, so we just 'simulate'
275 charTy = mkTyConTy charTyCon
277 charTyCon = pcNonRecDataTyCon charTyConKey pREL_BASE SLIT("Char") [] [] [charDataCon]
278 charDataCon = pcDataCon charDataConKey pREL_BASE SLIT("C#") [] [] [charPrimTy] charTyCon
280 stringTy = mkListTy charTy -- convenience only
284 intTy = mkTyConTy intTyCon
286 intTyCon = pcNonRecDataTyCon intTyConKey pREL_BASE SLIT("Int") [] [] [intDataCon]
287 intDataCon = pcDataCon intDataConKey pREL_BASE SLIT("I#") [] [] [intPrimTy] intTyCon
289 isIntTy :: Type -> Bool
290 isIntTy = isTyCon intTyConKey
295 wordTy = mkTyConTy wordTyCon
297 wordTyCon = pcNonRecDataTyCon wordTyConKey pREL_ADDR SLIT("Word") [] [] [wordDataCon]
298 wordDataCon = pcDataCon wordDataConKey pREL_ADDR SLIT("W#") [] [] [wordPrimTy] wordTyCon
302 addrTy = mkTyConTy addrTyCon
304 addrTyCon = pcNonRecDataTyCon addrTyConKey pREL_ADDR SLIT("Addr") [] [] [addrDataCon]
305 addrDataCon = pcDataCon addrDataConKey pREL_ADDR SLIT("A#") [] [] [addrPrimTy] addrTyCon
307 isAddrTy :: Type -> Bool
308 isAddrTy = isTyCon addrTyConKey
312 floatTy = mkTyConTy floatTyCon
314 floatTyCon = pcNonRecDataTyCon floatTyConKey pREL_FLOAT SLIT("Float") [] [] [floatDataCon]
315 floatDataCon = pcDataCon floatDataConKey pREL_FLOAT SLIT("F#") [] [] [floatPrimTy] floatTyCon
317 isFloatTy :: Type -> Bool
318 isFloatTy = isTyCon floatTyConKey
322 doubleTy = mkTyConTy doubleTyCon
324 isDoubleTy :: Type -> Bool
325 isDoubleTy = isTyCon doubleTyConKey
327 doubleTyCon = pcNonRecDataTyCon doubleTyConKey pREL_FLOAT SLIT("Double") [] [] [doubleDataCon]
328 doubleDataCon = pcDataCon doubleDataConKey pREL_FLOAT SLIT("D#") [] [] [doublePrimTy] doubleTyCon
333 = pcNonRecDataTyCon stablePtrTyConKey pREL_STABLE SLIT("StablePtr")
334 alpha_tyvar [(True,False)] [stablePtrDataCon]
337 = pcDataCon stablePtrDataConKey pREL_STABLE SLIT("StablePtr")
338 alpha_tyvar [] [mkStablePtrPrimTy alphaTy] stablePtrTyCon
343 = pcNonRecDataTyCon foreignObjTyConKey pREL_IO_BASE SLIT("ForeignObj")
344 [] [] [foreignObjDataCon]
347 = pcDataCon foreignObjDataConKey pREL_IO_BASE SLIT("ForeignObj")
348 [] [] [foreignObjPrimTy] foreignObjTyCon
350 isForeignObjTy :: Type -> Bool
351 isForeignObjTy = isTyCon foreignObjTyConKey
354 %************************************************************************
356 \subsection[TysWiredIn-Integer]{@Integer@ and its related ``pairing'' types}
358 %************************************************************************
360 @Integer@ and its pals are not really primitive. @Integer@ itself, first:
363 integerTy = mkTyConTy integerTyCon
365 integerTyCon = pcNonRecDataTyCon integerTyConKey pREL_NUM SLIT("Integer")
366 [] [] [smallIntegerDataCon, largeIntegerDataCon]
368 smallIntegerDataCon = pcDataCon smallIntegerDataConKey pREL_NUM SLIT("S#")
369 [] [] [intPrimTy] integerTyCon
370 largeIntegerDataCon = pcDataCon largeIntegerDataConKey pREL_NUM SLIT("J#")
371 [] [] [intPrimTy, byteArrayPrimTy] integerTyCon
374 isIntegerTy :: Type -> Bool
375 isIntegerTy = isTyCon integerTyConKey
379 %************************************************************************
381 \subsection[TysWiredIn-ext-type]{External types}
383 %************************************************************************
385 The compiler's foreign function interface supports the passing of a
386 restricted set of types as arguments and results (the restricting factor
390 isFFIArgumentTy :: Bool -> Type -> Bool
391 -- Checks for valid argument type for a 'foreign import'
392 isFFIArgumentTy is_safe ty = checkTyCon (legalOutgoingTyCon is_safe) ty
394 isFFIExternalTy :: Type -> Bool
395 -- Types that are allowed as arguments of a 'foreign export'
396 isFFIExternalTy ty = checkTyCon legalIncomingTyCon ty
398 isFFIResultTy :: Type -> Bool
399 -- Types that are allowed as a result of a 'foreign import' or of a 'foreign export'
400 -- Maybe we should distinguish between import and export, but
401 -- here we just choose the more restrictive 'incoming' predicate
402 -- But we allow () as well
403 isFFIResultTy ty = checkTyCon (\tc -> tc == unitTyCon || legalIncomingTyCon tc) ty
405 checkTyCon :: (TyCon -> Bool) -> Type -> Bool
406 checkTyCon check_tc ty = case splitTyConApp_maybe (repType ty) of
407 Just (tycon, _) -> check_tc tycon
410 isTyCon :: Unique -> Type -> Bool
411 isTyCon uniq ty = checkTyCon (\tc -> uniq == getUnique tc) ty
414 ----------------------------------------------
415 These chaps do the work; they are not exported
416 ----------------------------------------------
419 legalIncomingTyCon :: TyCon -> Bool
420 -- It's illegal to return foreign objects and (mutable)
421 -- bytearrays from a _ccall_ / foreign declaration
422 -- (or be passed them as arguments in foreign exported functions).
423 legalIncomingTyCon tc
424 | getUnique tc `elem` [ foreignObjTyConKey, byteArrayTyConKey, mutableByteArrayTyConKey ]
427 = marshalableTyCon tc
429 legalOutgoingTyCon :: Bool -> TyCon -> Bool
430 -- Checks validity of types going from Haskell -> external world
431 -- The boolean is true for a 'safe' call (when we don't want to
432 -- pass Haskell pointers to the world)
433 legalOutgoingTyCon be_safe tc
434 | be_safe && getUnique tc `elem` [byteArrayTyConKey, mutableByteArrayTyConKey]
437 = marshalableTyCon tc
440 = (opt_GlasgowExts && isUnLiftedTyCon tc)
441 || getUnique tc `elem` [ intTyConKey, int8TyConKey, int16TyConKey, int32TyConKey, int64TyConKey
442 , wordTyConKey, word8TyConKey, word16TyConKey, word32TyConKey, word64TyConKey
443 , floatTyConKey, doubleTyConKey
444 , addrTyConKey, charTyConKey, foreignObjTyConKey
446 , byteArrayTyConKey, mutableByteArrayTyConKey
452 %************************************************************************
454 \subsection[TysWiredIn-Bool]{The @Bool@ type}
456 %************************************************************************
458 An ordinary enumeration type, but deeply wired in. There are no
459 magical operations on @Bool@ (just the regular Prelude code).
461 {\em BEGIN IDLE SPECULATION BY SIMON}
463 This is not the only way to encode @Bool@. A more obvious coding makes
464 @Bool@ just a boxed up version of @Bool#@, like this:
467 data Bool = MkBool Bool#
470 Unfortunately, this doesn't correspond to what the Report says @Bool@
471 looks like! Furthermore, we get slightly less efficient code (I
472 think) with this coding. @gtInt@ would look like this:
475 gtInt :: Int -> Int -> Bool
476 gtInt x y = case x of I# x# ->
478 case (gtIntPrim x# y#) of
482 Notice that the result of the @gtIntPrim@ comparison has to be turned
483 into an integer (here called @b#@), and returned in a @MkBool@ box.
485 The @if@ expression would compile to this:
488 MkBool b# -> case b# of { 1# -> e1; 0# -> e2 }
491 I think this code is a little less efficient than the previous code,
492 but I'm not certain. At all events, corresponding with the Report is
493 important. The interesting thing is that the language is expressive
494 enough to describe more than one alternative; and that a type doesn't
495 necessarily need to be a straightforwardly boxed version of its
496 primitive counterpart.
498 {\em END IDLE SPECULATION BY SIMON}
501 boolTy = mkTyConTy boolTyCon
503 boolTyCon = pcTyCon EnumTyCon NonRecursive boolTyConKey
504 pREL_BASE SLIT("Bool") [] [] [falseDataCon, trueDataCon]
506 falseDataCon = pcDataCon falseDataConKey pREL_BASE SLIT("False") [] [] [] boolTyCon
507 trueDataCon = pcDataCon trueDataConKey pREL_BASE SLIT("True") [] [] [] boolTyCon
509 falseDataConId = dataConId falseDataCon
510 trueDataConId = dataConId trueDataCon
513 %************************************************************************
515 \subsection[TysWiredIn-List]{The @List@ type (incl ``build'' magic)}
517 %************************************************************************
519 Special syntax, deeply wired in, but otherwise an ordinary algebraic
522 data [] a = [] | a : (List a)
524 data (,) a b = (,,) a b
529 mkListTy :: Type -> Type
530 mkListTy ty = mkTyConApp listTyCon [ty]
532 alphaListTy = mkSigmaTy alpha_tyvar [] (mkTyConApp listTyCon alpha_ty)
534 listTyCon = pcRecDataTyCon listTyConKey pREL_BASE SLIT("[]")
535 alpha_tyvar [(True,False)] [nilDataCon, consDataCon]
537 nilDataCon = pcDataCon nilDataConKey pREL_BASE SLIT("[]") alpha_tyvar [] [] listTyCon
538 consDataCon = pcDataCon consDataConKey pREL_BASE SLIT(":")
539 alpha_tyvar [] [alphaTy, mkTyConApp listTyCon alpha_ty] listTyCon
540 -- Interesting: polymorphic recursion would help here.
541 -- We can't use (mkListTy alphaTy) in the defn of consDataCon, else mkListTy
542 -- gets the over-specific type (Type -> Type)
545 %************************************************************************
547 \subsection[TysWiredIn-Tuples]{The @Tuple@ types}
549 %************************************************************************
551 The tuple types are definitely magic, because they form an infinite
556 They have a special family of type constructors, of type @TyCon@
557 These contain the tycon arity, but don't require a Unique.
560 They have a special family of constructors, of type
561 @Id@. Again these contain their arity but don't need a Unique.
564 There should be a magic way of generating the info tables and
565 entry code for all tuples.
567 But at the moment we just compile a Haskell source
568 file\srcloc{lib/prelude/...} containing declarations like:
571 data Tuple2 a b = Tup2 a b
572 data Tuple3 a b c = Tup3 a b c
573 data Tuple4 a b c d = Tup4 a b c d
576 The print-names associated with the magic @Id@s for tuple constructors
577 ``just happen'' to be the same as those generated by these
581 The instance environment should have a magic way to know
582 that each tuple type is an instances of classes @Eq@, @Ix@, @Ord@ and
583 so on. \ToDo{Not implemented yet.}
586 There should also be a way to generate the appropriate code for each
587 of these instances, but (like the info tables and entry code) it is
588 done by enumeration\srcloc{lib/prelude/InTup?.hs}.
592 mkTupleTy :: Int -> [Type] -> Type
593 mkTupleTy arity tys = mkTyConApp (tupleTyCon arity) tys
595 mkUnboxedTupleTy :: Int -> [Type] -> Type
596 mkUnboxedTupleTy arity tys = mkTyConApp (unboxedTupleTyCon arity) tys
598 unitTy = mkTupleTy 0 []