X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fprelude%2FTysWiredIn.lhs;h=5b1e3d0a0c3ada9c101c5a855fc97890dd2bf543;hb=f7ecf7234c224489be8a5e63fced903b655d92ee;hp=ce285871099336030984ecd7f4dcaf5bc1fc130d;hpb=e7d21ee4f8ac907665a7e170c71d59e13a01da09;p=ghc-hetmet.git diff --git a/ghc/compiler/prelude/TysWiredIn.lhs b/ghc/compiler/prelude/TysWiredIn.lhs index ce28587..5b1e3d0 100644 --- a/ghc/compiler/prelude/TysWiredIn.lhs +++ b/ghc/compiler/prelude/TysWiredIn.lhs @@ -21,44 +21,38 @@ module TysWiredIn ( charDataCon, charTy, charTyCon, - cmpTagTy, - cmpTagTyCon, consDataCon, doubleDataCon, doubleTy, doubleTyCon, - eqPrimDataCon, falseDataCon, floatDataCon, floatTy, floatTyCon, getStatePairingConInfo, - gtPrimDataCon, intDataCon, intTy, intTyCon, integerTy, integerTyCon, + integerDataCon, liftDataCon, liftTyCon, listTyCon, - ltPrimDataCon, - mallocPtrTyCon, + foreignObjTyCon, mkLiftTy, mkListTy, mkPrimIoTy, + mkStateTy, mkStateTransformerTy, mkTupleTy, nilDataCon, primIoTyCon, - ratioDataCon, - ratioTyCon, - rationalTy, - rationalTyCon, realWorldStateTy, return2GMPsTyCon, returnIntAndGMPTyCon, stTyCon, + stDataCon, stablePtrTyCon, stateAndAddrPrimTyCon, stateAndArrayPrimTyCon, @@ -67,7 +61,7 @@ module TysWiredIn ( stateAndDoublePrimTyCon, stateAndFloatPrimTyCon, stateAndIntPrimTyCon, - stateAndMallocPtrPrimTyCon, + stateAndForeignObjPrimTyCon, stateAndMutableArrayPrimTyCon, stateAndMutableByteArrayPrimTyCon, stateAndPtrPrimTyCon, @@ -77,7 +71,6 @@ module TysWiredIn ( stateDataCon, stateTyCon, stringTy, - stringTyCon, trueDataCon, unitTy, wordDataCon, @@ -85,20 +78,77 @@ module TysWiredIn ( wordTyCon ) where -import Pretty --ToDo:rm debugging only +--ToDo:rm +--import Pretty +--import Util +--import PprType +--import PprStyle +--import Kind -import PrelFuns -- help functions, types and things +IMP_Ubiq() +IMPORT_DELOOPER(TyLoop) ( mkDataCon, StrictnessMark(..) ) +IMPORT_DELOOPER(IdLoop) ( SpecEnv ) + +-- friends: +import PrelMods import TysPrim -import AbsUniType ( applyTyCon, mkTupleTyCon, mkSynonymTyCon, - getUniDataTyCon_maybe, mkSigmaTy, TyCon - , pprUniType --ToDo: rm debugging only - IF_ATTACK_PRAGMAS(COMMA cmpTyCon) +-- others: +import Kind ( mkBoxedTypeKind, mkArrowKind ) +import Name ( mkWiredInName, ExportFlag(..) ) +import SrcLoc ( mkBuiltinSrcLoc ) +import TyCon ( mkDataTyCon, mkTupleTyCon, mkSynTyCon, + NewOrData(..), TyCon ) -import IdInfo -import Maybes ( Maybe(..) ) +import Type ( mkTyConTy, applyTyCon, mkSigmaTy, + mkFunTy, maybeAppTyCon, + GenType(..), SYN_IE(ThetaType), SYN_IE(TauType) ) +import TyVar ( tyVarKind, alphaTyVar, betaTyVar ) import Unique -import Util +import Util ( assoc, panic ) + +nullSpecEnv = error "TysWiredIn:nullSpecEnv = " +addOneToSpecEnv = error "TysWiredIn:addOneToSpecEnv = " +pc_gen_specs = error "TysWiredIn:pc_gen_specs " +mkSpecInfo = error "TysWiredIn:SpecInfo" + +alpha_tyvar = [alphaTyVar] +alpha_ty = [alphaTy] +alpha_beta_tyvars = [alphaTyVar, betaTyVar] + +pcDataTyCon, pcNewTyCon + :: Unique{-TyConKey-} -> Module -> FAST_STRING + -> [TyVar] -> [Id] -> TyCon + +pcDataTyCon = pc_tycon DataType +pcNewTyCon = pc_tycon NewType + +pc_tycon new_or_data key mod str tyvars cons + = mkDataTyCon (mkWiredInName key (OrigName mod str) ExportAll) tycon_kind + tyvars [{-no context-}] cons [{-no derivings-}] + new_or_data + where + tycon_kind = foldr (mkArrowKind . tyVarKind) mkBoxedTypeKind tyvars + +pcSynTyCon key mod str kind arity tyvars expansion + = mkSynTyCon + (mkWiredInName key (OrigName mod str) ExportAll) + kind arity tyvars expansion + +pcDataCon :: Unique{-DataConKey-} -> Module -> FAST_STRING + -> [TyVar] -> ThetaType -> [TauType] -> TyCon -> SpecEnv -> Id +pcDataCon key mod str tyvars context arg_tys tycon specenv + = mkDataCon (mkWiredInName key (OrigName mod str) ExportAll) + [ NotMarkedStrict | a <- arg_tys ] + [ {- no labelled fields -} ] + tyvars context arg_tys tycon + -- specenv + +pcGenerateDataSpecs :: Type -> SpecEnv +pcGenerateDataSpecs ty + = pc_gen_specs False err err err ty + where + err = panic "PrelUtils:GenerateDataSpecs" \end{code} %************************************************************************ @@ -108,117 +158,77 @@ import Util %************************************************************************ \begin{code} -charTy = UniData charTyCon [] +charTy = mkTyConTy charTyCon + +charTyCon = pcDataTyCon charTyConKey pRELUDE SLIT("Char") [] [charDataCon] +charDataCon = pcDataCon charDataConKey pRELUDE SLIT("C#") [] [] [charPrimTy] charTyCon nullSpecEnv -charTyCon = pcDataTyCon charTyConKey pRELUDE_BUILTIN SLIT("Char") [] [charDataCon] -charDataCon = pcDataCon charDataConKey pRELUDE_BUILTIN SLIT("C#") [] [] [charPrimTy] charTyCon nullSpecEnv +stringTy = mkListTy charTy -- convenience only \end{code} \begin{code} -intTy = UniData intTyCon [] +intTy = mkTyConTy intTyCon -intTyCon = pcDataTyCon intTyConKey pRELUDE_BUILTIN SLIT("Int") [] [intDataCon] -intDataCon = pcDataCon intDataConKey pRELUDE_BUILTIN SLIT("I#") [] [] [intPrimTy] intTyCon nullSpecEnv +intTyCon = pcDataTyCon intTyConKey pRELUDE SLIT("Int") [] [intDataCon] +intDataCon = pcDataCon intDataConKey pRELUDE SLIT("I#") [] [] [intPrimTy] intTyCon nullSpecEnv \end{code} \begin{code} -wordTy = UniData wordTyCon [] +wordTy = mkTyConTy wordTyCon -wordTyCon = pcDataTyCon wordTyConKey pRELUDE_BUILTIN SLIT("_Word") [] [wordDataCon] -wordDataCon = pcDataCon wordDataConKey pRELUDE_BUILTIN SLIT("W#") [] [] [wordPrimTy] wordTyCon nullSpecEnv +wordTyCon = pcDataTyCon wordTyConKey gHC__ SLIT("Word") [] [wordDataCon] +wordDataCon = pcDataCon wordDataConKey gHC__ SLIT("W#") [] [] [wordPrimTy] wordTyCon nullSpecEnv \end{code} \begin{code} -addrTy = UniData addrTyCon [] +addrTy = mkTyConTy addrTyCon -addrTyCon = pcDataTyCon addrTyConKey pRELUDE_BUILTIN SLIT("_Addr") [] [addrDataCon] -addrDataCon = pcDataCon addrDataConKey pRELUDE_BUILTIN SLIT("A#") [] [] [addrPrimTy] addrTyCon nullSpecEnv +addrTyCon = pcDataTyCon addrTyConKey gHC__ SLIT("Addr") [] [addrDataCon] +addrDataCon = pcDataCon addrDataConKey gHC__ SLIT("A#") [] [] [addrPrimTy] addrTyCon nullSpecEnv \end{code} \begin{code} -floatTy = UniData floatTyCon [] +floatTy = mkTyConTy floatTyCon -floatTyCon = pcDataTyCon floatTyConKey pRELUDE_BUILTIN SLIT("Float") [] [floatDataCon] -floatDataCon = pcDataCon floatDataConKey pRELUDE_BUILTIN SLIT("F#") [] [] [floatPrimTy] floatTyCon nullSpecEnv +floatTyCon = pcDataTyCon floatTyConKey pRELUDE SLIT("Float") [] [floatDataCon] +floatDataCon = pcDataCon floatDataConKey pRELUDE SLIT("F#") [] [] [floatPrimTy] floatTyCon nullSpecEnv \end{code} \begin{code} -doubleTy = UniData doubleTyCon [] +doubleTy = mkTyConTy doubleTyCon -doubleTyCon = pcDataTyCon doubleTyConKey pRELUDE_BUILTIN SLIT("Double") [] [doubleDataCon] -doubleDataCon = pcDataCon doubleDataConKey pRELUDE_BUILTIN SLIT("D#") [] [] [doublePrimTy] doubleTyCon nullSpecEnv +doubleTyCon = pcDataTyCon doubleTyConKey pRELUDE SLIT("Double") [] [doubleDataCon] +doubleDataCon = pcDataCon doubleDataConKey pRELUDE SLIT("D#") [] [] [doublePrimTy] doubleTyCon nullSpecEnv \end{code} \begin{code} mkStateTy ty = applyTyCon stateTyCon [ty] realWorldStateTy = mkStateTy realWorldTy -- a common use -stateTyCon = pcDataTyCon stateTyConKey pRELUDE_BUILTIN SLIT("_State") [alpha_tv] [stateDataCon] +stateTyCon = pcDataTyCon stateTyConKey gHC__ SLIT("State") alpha_tyvar [stateDataCon] stateDataCon - = pcDataCon stateDataConKey pRELUDE_BUILTIN SLIT("S#") - [alpha_tv] [] [mkStatePrimTy alpha] stateTyCon nullSpecEnv -\end{code} - -\begin{code} -{- OLD: -byteArrayTyCon - = pcDataTyCon byteArrayTyConKey pRELUDE_ARRAY SLIT("_ByteArray") - [alpha_tv] [byteArrayDataCon] - -byteArrayDataCon - = pcDataCon byteArrayDataConKey pRELUDE_ARRAY SLIT("_ByteArray") - [alpha_tv] [] - [mkTupleTy 2 [alpha, alpha], byteArrayPrimTy] - byteArrayTyCon nullSpecEnv --} -\end{code} - -\begin{code} -{- OLD: -mutableArrayTyCon - = pcDataTyCon mutableArrayTyConKey gLASGOW_ST SLIT("_MutableArray") - [alpha_tv, beta_tv, gamma_tv] [mutableArrayDataCon] - where - mutableArrayDataCon - = pcDataCon mutableArrayDataConKey gLASGOW_ST SLIT("_MutableArray") - [alpha_tv, beta_tv, gamma_tv] [] - [mkTupleTy 2 [beta, beta], applyTyCon mutableArrayPrimTyCon [alpha, gamma]] - mutableArrayTyCon nullSpecEnv --} -\end{code} - -\begin{code} -{- -mutableByteArrayTyCon - = pcDataTyCon mutableByteArrayTyConKey gLASGOW_ST SLIT("_MutableByteArray") - [alpha_tv, beta_tv] [mutableByteArrayDataCon] - -mutableByteArrayDataCon - = pcDataCon mutableByteArrayDataConKey gLASGOW_ST SLIT("_MutableByteArray") - [alpha_tv, beta_tv] [] - [mkTupleTy 2 [beta, beta], mkMutableByteArrayPrimTy alpha] - mutableByteArrayTyCon nullSpecEnv --} + = pcDataCon stateDataConKey gHC__ SLIT("S#") + alpha_tyvar [] [mkStatePrimTy alphaTy] stateTyCon nullSpecEnv \end{code} \begin{code} stablePtrTyCon - = pcDataTyCon stablePtrTyConKey gLASGOW_MISC SLIT("_StablePtr") - [alpha_tv] [stablePtrDataCon] + = pcDataTyCon stablePtrTyConKey gHC__ SLIT("StablePtr") + alpha_tyvar [stablePtrDataCon] where stablePtrDataCon - = pcDataCon stablePtrDataConKey gLASGOW_MISC SLIT("_StablePtr") - [alpha_tv] [] [applyTyCon stablePtrPrimTyCon [alpha]] stablePtrTyCon nullSpecEnv + = pcDataCon stablePtrDataConKey gHC__ SLIT("StablePtr") + alpha_tyvar [] [mkStablePtrPrimTy alphaTy] stablePtrTyCon nullSpecEnv \end{code} \begin{code} -mallocPtrTyCon - = pcDataTyCon mallocPtrTyConKey gLASGOW_MISC SLIT("_MallocPtr") - [] [mallocPtrDataCon] +foreignObjTyCon + = pcDataTyCon foreignObjTyConKey gHC__ SLIT("ForeignObj") + [] [foreignObjDataCon] where - mallocPtrDataCon - = pcDataCon mallocPtrDataConKey gLASGOW_MISC SLIT("_MallocPtr") - [] [] [applyTyCon mallocPtrPrimTyCon []] mallocPtrTyCon nullSpecEnv + foreignObjDataCon + = pcDataCon foreignObjDataConKey gHC__ SLIT("ForeignObj") + [] [] [foreignObjPrimTy] foreignObjTyCon nullSpecEnv \end{code} %************************************************************************ @@ -229,36 +239,30 @@ mallocPtrTyCon @Integer@ and its pals are not really primitive. @Integer@ itself, first: \begin{code} -integerTy :: UniType -integerTy = UniData integerTyCon [] +integerTy :: GenType t u +integerTy = mkTyConTy integerTyCon -integerTyCon = pcDataTyCon integerTyConKey pRELUDE_BUILTIN SLIT("Integer") [] [integerDataCon] +integerTyCon = pcDataTyCon integerTyConKey pRELUDE SLIT("Integer") [] [integerDataCon] -#ifndef DPH -integerDataCon = pcDataCon integerDataConKey pRELUDE_BUILTIN SLIT("J#") +integerDataCon = pcDataCon integerDataConKey pRELUDE SLIT("J#") [] [] [intPrimTy, intPrimTy, byteArrayPrimTy] integerTyCon nullSpecEnv -#else --- DPH: For the time being we implement Integers in the same way as Ints. -integerDataCon = pcDataCon integerDataConKey pRELUDE_BUILTIN SLIT("J#") - [] [] [intPrimTy] integerTyCon nullSpecEnv -#endif {- Data Parallel Haskell -} \end{code} And the other pairing types: \begin{code} return2GMPsTyCon = pcDataTyCon return2GMPsTyConKey - pRELUDE_BUILTIN SLIT("_Return2GMPs") [] [return2GMPsDataCon] + gHC__ SLIT("Return2GMPs") [] [return2GMPsDataCon] return2GMPsDataCon - = pcDataCon return2GMPsDataConKey pRELUDE_BUILTIN SLIT("_Return2GMPs") [] [] + = pcDataCon return2GMPsDataConKey gHC__ SLIT("Return2GMPs") [] [] [intPrimTy, intPrimTy, byteArrayPrimTy, intPrimTy, intPrimTy, byteArrayPrimTy] return2GMPsTyCon nullSpecEnv returnIntAndGMPTyCon = pcDataTyCon returnIntAndGMPTyConKey - pRELUDE_BUILTIN SLIT("_ReturnIntAndGMP") [] [returnIntAndGMPDataCon] + gHC__ SLIT("ReturnIntAndGMP") [] [returnIntAndGMPDataCon] returnIntAndGMPDataCon - = pcDataCon returnIntAndGMPDataConKey pRELUDE_BUILTIN SLIT("_ReturnIntAndGMP") [] [] + = pcDataCon returnIntAndGMPDataConKey gHC__ SLIT("ReturnIntAndGMP") [] [] [intPrimTy, intPrimTy, intPrimTy, byteArrayPrimTy] returnIntAndGMPTyCon nullSpecEnv \end{code} @@ -277,119 +281,119 @@ We fish one of these \tr{StateAnd#} things with \begin{code} stateAndPtrPrimTyCon - = pcDataTyCon stateAndPtrPrimTyConKey pRELUDE_BUILTIN SLIT("StateAndPtr#") - [alpha_tv, beta_tv] [stateAndPtrPrimDataCon] + = pcDataTyCon stateAndPtrPrimTyConKey gHC__ SLIT("StateAndPtr#") + alpha_beta_tyvars [stateAndPtrPrimDataCon] stateAndPtrPrimDataCon - = pcDataCon stateAndPtrPrimDataConKey pRELUDE_BUILTIN SLIT("StateAndPtr#") - [alpha_tv, beta_tv] [] [mkStatePrimTy alpha, beta] + = pcDataCon stateAndPtrPrimDataConKey gHC__ SLIT("StateAndPtr#") + alpha_beta_tyvars [] [mkStatePrimTy alphaTy, betaTy] stateAndPtrPrimTyCon nullSpecEnv stateAndCharPrimTyCon - = pcDataTyCon stateAndCharPrimTyConKey pRELUDE_BUILTIN SLIT("StateAndChar#") - [alpha_tv] [stateAndCharPrimDataCon] + = pcDataTyCon stateAndCharPrimTyConKey gHC__ SLIT("StateAndChar#") + alpha_tyvar [stateAndCharPrimDataCon] stateAndCharPrimDataCon - = pcDataCon stateAndCharPrimDataConKey pRELUDE_BUILTIN SLIT("StateAndChar#") - [alpha_tv] [] [mkStatePrimTy alpha, charPrimTy] + = pcDataCon stateAndCharPrimDataConKey gHC__ SLIT("StateAndChar#") + alpha_tyvar [] [mkStatePrimTy alphaTy, charPrimTy] stateAndCharPrimTyCon nullSpecEnv stateAndIntPrimTyCon - = pcDataTyCon stateAndIntPrimTyConKey pRELUDE_BUILTIN SLIT("StateAndInt#") - [alpha_tv] [stateAndIntPrimDataCon] + = pcDataTyCon stateAndIntPrimTyConKey gHC__ SLIT("StateAndInt#") + alpha_tyvar [stateAndIntPrimDataCon] stateAndIntPrimDataCon - = pcDataCon stateAndIntPrimDataConKey pRELUDE_BUILTIN SLIT("StateAndInt#") - [alpha_tv] [] [mkStatePrimTy alpha, intPrimTy] + = pcDataCon stateAndIntPrimDataConKey gHC__ SLIT("StateAndInt#") + alpha_tyvar [] [mkStatePrimTy alphaTy, intPrimTy] stateAndIntPrimTyCon nullSpecEnv stateAndWordPrimTyCon - = pcDataTyCon stateAndWordPrimTyConKey pRELUDE_BUILTIN SLIT("StateAndWord#") - [alpha_tv] [stateAndWordPrimDataCon] + = pcDataTyCon stateAndWordPrimTyConKey gHC__ SLIT("StateAndWord#") + alpha_tyvar [stateAndWordPrimDataCon] stateAndWordPrimDataCon - = pcDataCon stateAndWordPrimDataConKey pRELUDE_BUILTIN SLIT("StateAndWord#") - [alpha_tv] [] [mkStatePrimTy alpha, wordPrimTy] + = pcDataCon stateAndWordPrimDataConKey gHC__ SLIT("StateAndWord#") + alpha_tyvar [] [mkStatePrimTy alphaTy, wordPrimTy] stateAndWordPrimTyCon nullSpecEnv stateAndAddrPrimTyCon - = pcDataTyCon stateAndAddrPrimTyConKey pRELUDE_BUILTIN SLIT("StateAndAddr#") - [alpha_tv] [stateAndAddrPrimDataCon] + = pcDataTyCon stateAndAddrPrimTyConKey gHC__ SLIT("StateAndAddr#") + alpha_tyvar [stateAndAddrPrimDataCon] stateAndAddrPrimDataCon - = pcDataCon stateAndAddrPrimDataConKey pRELUDE_BUILTIN SLIT("StateAndAddr#") - [alpha_tv] [] [mkStatePrimTy alpha, addrPrimTy] + = pcDataCon stateAndAddrPrimDataConKey gHC__ SLIT("StateAndAddr#") + alpha_tyvar [] [mkStatePrimTy alphaTy, addrPrimTy] stateAndAddrPrimTyCon nullSpecEnv stateAndStablePtrPrimTyCon - = pcDataTyCon stateAndStablePtrPrimTyConKey pRELUDE_BUILTIN SLIT("StateAndStablePtr#") - [alpha_tv, beta_tv] [stateAndStablePtrPrimDataCon] + = pcDataTyCon stateAndStablePtrPrimTyConKey gHC__ SLIT("StateAndStablePtr#") + alpha_beta_tyvars [stateAndStablePtrPrimDataCon] stateAndStablePtrPrimDataCon - = pcDataCon stateAndStablePtrPrimDataConKey pRELUDE_BUILTIN SLIT("StateAndStablePtr#") - [alpha_tv, beta_tv] [] - [mkStatePrimTy alpha, applyTyCon stablePtrPrimTyCon [beta]] + = pcDataCon stateAndStablePtrPrimDataConKey gHC__ SLIT("StateAndStablePtr#") + alpha_beta_tyvars [] + [mkStatePrimTy alphaTy, applyTyCon stablePtrPrimTyCon [betaTy]] stateAndStablePtrPrimTyCon nullSpecEnv -stateAndMallocPtrPrimTyCon - = pcDataTyCon stateAndMallocPtrPrimTyConKey pRELUDE_BUILTIN SLIT("StateAndMallocPtr#") - [alpha_tv] [stateAndMallocPtrPrimDataCon] -stateAndMallocPtrPrimDataCon - = pcDataCon stateAndMallocPtrPrimDataConKey pRELUDE_BUILTIN SLIT("StateAndMallocPtr#") - [alpha_tv] [] - [mkStatePrimTy alpha, applyTyCon mallocPtrPrimTyCon []] - stateAndMallocPtrPrimTyCon nullSpecEnv +stateAndForeignObjPrimTyCon + = pcDataTyCon stateAndForeignObjPrimTyConKey gHC__ SLIT("StateAndForeignObj#") + alpha_tyvar [stateAndForeignObjPrimDataCon] +stateAndForeignObjPrimDataCon + = pcDataCon stateAndForeignObjPrimDataConKey gHC__ SLIT("StateAndForeignObj#") + alpha_tyvar [] + [mkStatePrimTy alphaTy, applyTyCon foreignObjPrimTyCon []] + stateAndForeignObjPrimTyCon nullSpecEnv stateAndFloatPrimTyCon - = pcDataTyCon stateAndFloatPrimTyConKey pRELUDE_BUILTIN SLIT("StateAndFloat#") - [alpha_tv] [stateAndFloatPrimDataCon] + = pcDataTyCon stateAndFloatPrimTyConKey gHC__ SLIT("StateAndFloat#") + alpha_tyvar [stateAndFloatPrimDataCon] stateAndFloatPrimDataCon - = pcDataCon stateAndFloatPrimDataConKey pRELUDE_BUILTIN SLIT("StateAndFloat#") - [alpha_tv] [] [mkStatePrimTy alpha, floatPrimTy] + = pcDataCon stateAndFloatPrimDataConKey gHC__ SLIT("StateAndFloat#") + alpha_tyvar [] [mkStatePrimTy alphaTy, floatPrimTy] stateAndFloatPrimTyCon nullSpecEnv stateAndDoublePrimTyCon - = pcDataTyCon stateAndDoublePrimTyConKey pRELUDE_BUILTIN SLIT("StateAndDouble#") - [alpha_tv] [stateAndDoublePrimDataCon] + = pcDataTyCon stateAndDoublePrimTyConKey gHC__ SLIT("StateAndDouble#") + alpha_tyvar [stateAndDoublePrimDataCon] stateAndDoublePrimDataCon - = pcDataCon stateAndDoublePrimDataConKey pRELUDE_BUILTIN SLIT("StateAndDouble#") - [alpha_tv] [] [mkStatePrimTy alpha, doublePrimTy] + = pcDataCon stateAndDoublePrimDataConKey gHC__ SLIT("StateAndDouble#") + alpha_tyvar [] [mkStatePrimTy alphaTy, doublePrimTy] stateAndDoublePrimTyCon nullSpecEnv \end{code} \begin{code} stateAndArrayPrimTyCon - = pcDataTyCon stateAndArrayPrimTyConKey pRELUDE_BUILTIN SLIT("StateAndArray#") - [alpha_tv, beta_tv] [stateAndArrayPrimDataCon] + = pcDataTyCon stateAndArrayPrimTyConKey gHC__ SLIT("StateAndArray#") + alpha_beta_tyvars [stateAndArrayPrimDataCon] stateAndArrayPrimDataCon - = pcDataCon stateAndArrayPrimDataConKey pRELUDE_BUILTIN SLIT("StateAndArray#") - [alpha_tv, beta_tv] [] [mkStatePrimTy alpha, mkArrayPrimTy beta] + = pcDataCon stateAndArrayPrimDataConKey gHC__ SLIT("StateAndArray#") + alpha_beta_tyvars [] [mkStatePrimTy alphaTy, mkArrayPrimTy betaTy] stateAndArrayPrimTyCon nullSpecEnv stateAndMutableArrayPrimTyCon - = pcDataTyCon stateAndMutableArrayPrimTyConKey pRELUDE_BUILTIN SLIT("StateAndMutableArray#") - [alpha_tv, beta_tv] [stateAndMutableArrayPrimDataCon] + = pcDataTyCon stateAndMutableArrayPrimTyConKey gHC__ SLIT("StateAndMutableArray#") + alpha_beta_tyvars [stateAndMutableArrayPrimDataCon] stateAndMutableArrayPrimDataCon - = pcDataCon stateAndMutableArrayPrimDataConKey pRELUDE_BUILTIN SLIT("StateAndMutableArray#") - [alpha_tv, beta_tv] [] [mkStatePrimTy alpha, mkMutableArrayPrimTy alpha beta] + = pcDataCon stateAndMutableArrayPrimDataConKey gHC__ SLIT("StateAndMutableArray#") + alpha_beta_tyvars [] [mkStatePrimTy alphaTy, mkMutableArrayPrimTy alphaTy betaTy] stateAndMutableArrayPrimTyCon nullSpecEnv stateAndByteArrayPrimTyCon - = pcDataTyCon stateAndByteArrayPrimTyConKey pRELUDE_BUILTIN SLIT("StateAndByteArray#") - [alpha_tv] [stateAndByteArrayPrimDataCon] + = pcDataTyCon stateAndByteArrayPrimTyConKey gHC__ SLIT("StateAndByteArray#") + alpha_tyvar [stateAndByteArrayPrimDataCon] stateAndByteArrayPrimDataCon - = pcDataCon stateAndByteArrayPrimDataConKey pRELUDE_BUILTIN SLIT("StateAndByteArray#") - [alpha_tv] [] [mkStatePrimTy alpha, byteArrayPrimTy] + = pcDataCon stateAndByteArrayPrimDataConKey gHC__ SLIT("StateAndByteArray#") + alpha_tyvar [] [mkStatePrimTy alphaTy, byteArrayPrimTy] stateAndByteArrayPrimTyCon nullSpecEnv stateAndMutableByteArrayPrimTyCon - = pcDataTyCon stateAndMutableByteArrayPrimTyConKey pRELUDE_BUILTIN SLIT("StateAndMutableByteArray#") - [alpha_tv] [stateAndMutableByteArrayPrimDataCon] + = pcDataTyCon stateAndMutableByteArrayPrimTyConKey gHC__ SLIT("StateAndMutableByteArray#") + alpha_tyvar [stateAndMutableByteArrayPrimDataCon] stateAndMutableByteArrayPrimDataCon - = pcDataCon stateAndMutableByteArrayPrimDataConKey pRELUDE_BUILTIN SLIT("StateAndMutableByteArray#") - [alpha_tv] [] [mkStatePrimTy alpha, applyTyCon mutableByteArrayPrimTyCon [alpha]] + = pcDataCon stateAndMutableByteArrayPrimDataConKey gHC__ SLIT("StateAndMutableByteArray#") + alpha_tyvar [] [mkStatePrimTy alphaTy, applyTyCon mutableByteArrayPrimTyCon alpha_ty] stateAndMutableByteArrayPrimTyCon nullSpecEnv stateAndSynchVarPrimTyCon - = pcDataTyCon stateAndSynchVarPrimTyConKey pRELUDE_BUILTIN SLIT("StateAndSynchVar#") - [alpha_tv, beta_tv] [stateAndSynchVarPrimDataCon] + = pcDataTyCon stateAndSynchVarPrimTyConKey gHC__ SLIT("StateAndSynchVar#") + alpha_beta_tyvars [stateAndSynchVarPrimDataCon] stateAndSynchVarPrimDataCon - = pcDataCon stateAndSynchVarPrimDataConKey pRELUDE_BUILTIN SLIT("StateAndSynchVar#") - [alpha_tv, beta_tv] [] [mkStatePrimTy alpha, mkSynchVarPrimTy alpha beta] + = pcDataCon stateAndSynchVarPrimDataConKey gHC__ SLIT("StateAndSynchVar#") + alpha_beta_tyvars [] [mkStatePrimTy alphaTy, mkSynchVarPrimTy alphaTy betaTy] stateAndSynchVarPrimTyCon nullSpecEnv \end{code} @@ -399,14 +403,14 @@ how many types to drop from \tr{tys_applied}. \begin{code} getStatePairingConInfo - :: UniType -- primitive type + :: Type -- primitive type -> (Id, -- state pair constructor for prim type - UniType) -- type of state pair + Type) -- type of state pair getStatePairingConInfo prim_ty - = case (getUniDataTyCon_maybe prim_ty) of + = case (maybeAppTyCon prim_ty) of Nothing -> panic "getStatePairingConInfo:1" - Just (prim_tycon, tys_applied, _) -> + Just (prim_tycon, tys_applied) -> let (pair_con, pair_tycon, num_tys) = assoc "getStatePairingConInfo" tbl prim_tycon pair_ty = applyTyCon pair_tycon (realWorldTy : drop num_tys tys_applied) @@ -419,7 +423,7 @@ getStatePairingConInfo prim_ty (wordPrimTyCon, (stateAndWordPrimDataCon, stateAndWordPrimTyCon, 0)), (addrPrimTyCon, (stateAndAddrPrimDataCon, stateAndAddrPrimTyCon, 0)), (stablePtrPrimTyCon, (stateAndStablePtrPrimDataCon, stateAndStablePtrPrimTyCon, 0)), - (mallocPtrPrimTyCon, (stateAndMallocPtrPrimDataCon, stateAndMallocPtrPrimTyCon, 0)), + (foreignObjPrimTyCon, (stateAndForeignObjPrimDataCon, stateAndForeignObjPrimTyCon, 0)), (floatPrimTyCon, (stateAndFloatPrimDataCon, stateAndFloatPrimTyCon, 0)), (doublePrimTyCon, (stateAndDoublePrimDataCon, stateAndDoublePrimTyCon, 0)), (arrayPrimTyCon, (stateAndArrayPrimDataCon, stateAndArrayPrimTyCon, 0)), @@ -442,35 +446,28 @@ This is really just an ordinary synonym, except it is ABSTRACT. \begin{code} mkStateTransformerTy s a = applyTyCon stTyCon [s, a] -stTyCon - = mkSynonymTyCon - stTyConKey - (mkPreludeCoreName gLASGOW_ST SLIT("_ST")) - 2 - [alpha_tv, beta_tv] - (mkStateTy alpha `UniFun` mkTupleTy 2 [beta, mkStateTy alpha]) - True -- ToDo: make... *** ABSTRACT *** +stTyCon = pcNewTyCon stTyConKey gHC__ SLIT("ST") alpha_beta_tyvars [stDataCon] + +stDataCon = pcDataCon stDataConKey gHC__ SLIT("ST") + alpha_beta_tyvars [] [ty] stTyCon nullSpecEnv + where + ty = mkFunTy (mkStateTy alphaTy) (mkTupleTy 2 [betaTy, mkStateTy alphaTy]) \end{code} %************************************************************************ %* * -\subsection[TysWiredIn-IO]{The @PrimIO@ and @IO@ monadic-I/O types} +\subsection[TysWiredIn-IO]{The @PrimIO@ monadic-I/O type} %* * %************************************************************************ -@PrimIO@ and @IO@ really are just a plain synonyms. - \begin{code} -mkPrimIoTy a = applyTyCon primIoTyCon [a] +mkPrimIoTy a = mkStateTransformerTy realWorldTy a primIoTyCon - = mkSynonymTyCon - primIoTyConKey - (mkPreludeCoreName pRELUDE_PRIMIO SLIT("PrimIO")) - 1 - [alpha_tv] - (mkStateTransformerTy realWorldTy alpha) - True -- need not be abstract + = pcSynTyCon + primIoTyConKey gHC__ SLIT("PrimIO") + (mkBoxedTypeKind `mkArrowKind` mkBoxedTypeKind) + 1 alpha_tyvar (mkPrimIoTy alphaTy) \end{code} %************************************************************************ @@ -522,33 +519,12 @@ primitive counterpart. {\em END IDLE SPECULATION BY SIMON} \begin{code} -boolTy = UniData boolTyCon [] +boolTy = mkTyConTy boolTyCon -boolTyCon = pcDataTyCon boolTyConKey pRELUDE_CORE SLIT("Bool") [] [falseDataCon, trueDataCon] +boolTyCon = pcDataTyCon boolTyConKey pRELUDE SLIT("Bool") [] [falseDataCon, trueDataCon] -falseDataCon = pcDataCon falseDataConKey pRELUDE_CORE SLIT("False") [] [] [] boolTyCon nullSpecEnv -trueDataCon = pcDataCon trueDataConKey pRELUDE_CORE SLIT("True") [] [] [] boolTyCon nullSpecEnv -\end{code} - -%************************************************************************ -%* * -\subsection[TysWiredIn-CMP-TAG]{The @CMP_TAG#@ type (for fast `derived' comparisons)} -%* * -%************************************************************************ - -\begin{code} ---------------------------------------------- --- data _CMP_TAG = _LT | _EQ | _GT deriving () ---------------------------------------------- - -cmpTagTy = UniData cmpTagTyCon [] - -cmpTagTyCon = pcDataTyCon cmpTagTyConKey pRELUDE_BUILTIN SLIT("_CMP_TAG") [] - [ltPrimDataCon, eqPrimDataCon, gtPrimDataCon] - -ltPrimDataCon = pcDataCon ltTagDataConKey pRELUDE_BUILTIN SLIT("_LT") [] [] [] cmpTagTyCon nullSpecEnv -eqPrimDataCon = pcDataCon eqTagDataConKey pRELUDE_BUILTIN SLIT("_EQ") [] [] [] cmpTagTyCon nullSpecEnv -gtPrimDataCon = pcDataCon gtTagDataConKey pRELUDE_BUILTIN SLIT("_GT") [] [] [] cmpTagTyCon nullSpecEnv +falseDataCon = pcDataCon falseDataConKey pRELUDE SLIT("False") [] [] [] boolTyCon nullSpecEnv +trueDataCon = pcDataCon trueDataConKey pRELUDE SLIT("True") [] [] [] boolTyCon nullSpecEnv \end{code} %************************************************************************ @@ -558,38 +534,31 @@ gtPrimDataCon = pcDataCon gtTagDataConKey pRELUDE_BUILTIN SLIT("_GT") [] [] [] %************************************************************************ Special syntax, deeply wired in, but otherwise an ordinary algebraic -data type: +data types: \begin{verbatim} -data List a = Nil | a : (List a) +data [] a = [] | a : (List a) +data () = () +data (,) a b = (,,) a b +... \end{verbatim} \begin{code} -mkListTy :: UniType -> UniType -mkListTy ty = UniData listTyCon [ty] +mkListTy :: GenType t u -> GenType t u +mkListTy ty = applyTyCon listTyCon [ty] -alphaListTy = mkSigmaTy [alpha_tv] [] (mkListTy alpha) +alphaListTy = mkSigmaTy alpha_tyvar [] (applyTyCon listTyCon alpha_ty) -listTyCon = pcDataTyCon listTyConKey pRELUDE_BUILTIN SLIT("List") [alpha_tv] [nilDataCon, consDataCon] +listTyCon = pcDataTyCon listTyConKey pRELUDE SLIT("[]") + alpha_tyvar [nilDataCon, consDataCon] -nilDataCon = pcDataCon nilDataConKey pRELUDE_BUILTIN SLIT("Nil") [alpha_tv] [] [] listTyCon +nilDataCon = pcDataCon nilDataConKey pRELUDE SLIT("[]") alpha_tyvar [] [] listTyCon (pcGenerateDataSpecs alphaListTy) -consDataCon = pcDataCon consDataConKey pRELUDE_BUILTIN SLIT(":") - [alpha_tv] [] [alpha, mkListTy alpha] listTyCon +consDataCon = pcDataCon consDataConKey pRELUDE SLIT(":") + alpha_tyvar [] [alphaTy, applyTyCon listTyCon alpha_ty] listTyCon (pcGenerateDataSpecs alphaListTy) -\end{code} - -This is the @_Build@ data constructor, it does {\em not} appear inside -listTyCon. It has this type: \tr{((a -> b -> b) -> b -> b) -> [a]}. -\begin{code} -{- NOT USED: -buildDataCon - = pcDataCon buildDataConKey pRELUDE_BUILTIN "Build" - [alpha_tv] [] [ - mkSigmaTy [beta_tv] [] - ((alpha `UniFun` (beta `UniFun` beta)) - `UniFun` (beta - `UniFun` beta))] listTyCon nullSpecEnv --} +-- Interesting: polymorphic recursion would help here. +-- We can't use (mkListTy alphaTy) in the defn of consDataCon, else mkListTy +-- gets the over-specific type (Type -> Type) \end{code} %************************************************************************ @@ -603,14 +572,12 @@ family. \begin{itemize} \item -They have a special family of type constructors, of type -@TyCon@\srcloc{uniType/TyCon.lhs}. +They have a special family of type constructors, of type @TyCon@ These contain the tycon arity, but don't require a Unique. \item They have a special family of constructors, of type -@Id@\srcloc{basicTypes/Id.lhs}. Again these contain their arity but -don't need a Unique. +@Id@. Again these contain their arity but don't need a Unique. \item There should be a magic way of generating the info tables and @@ -641,41 +608,11 @@ done by enumeration\srcloc{lib/prelude/InTup?.hs}. \end{itemize} \begin{code} -mkTupleTy :: Int -> [UniType] -> UniType +mkTupleTy :: Int -> [GenType t u] -> GenType t u mkTupleTy arity tys = applyTyCon (mkTupleTyCon arity) tys -unitTy = mkTupleTy 0 [] -\end{code} - -%************************************************************************ -%* * -\subsection[TysWiredIn-Ratios]{@Ratio@ and @Rational@} -%* * -%************************************************************************ - -ToDo: make this (mostly) go away. - -\begin{code} -rationalTy :: UniType - -mkRatioTy ty = UniData ratioTyCon [ty] -rationalTy = mkRatioTy integerTy - -ratioTyCon = pcDataTyCon ratioTyConKey pRELUDE_RATIO SLIT("Ratio") [alpha_tv] [ratioDataCon] - -ratioDataCon = pcDataCon ratioDataConKey pRELUDE_RATIO SLIT(":%") - [alpha_tv] [{-(integralClass,alpha)-}] [alpha, alpha] ratioTyCon nullSpecEnv - -- context omitted to match lib/prelude/ defn of "data Ratio ..." - -rationalTyCon - = mkSynonymTyCon - rationalTyConKey - (mkPreludeCoreName pRELUDE_RATIO SLIT("Rational")) - 0 -- arity - [] -- tyvars - rationalTy -- == mkRatioTy integerTy - True -- unabstract +unitTy = mkTupleTy 0 [] \end{code} %************************************************************************ @@ -691,67 +628,29 @@ mkLiftTy ty = applyTyCon liftTyCon [ty] {- mkLiftTy ty - = mkSigmaTy tvs theta (UniData liftTyCon [tau]) + = mkSigmaTy tvs theta (applyTyCon liftTyCon [tau]) where - (tvs, theta, tau) = splitType ty + (tvs, theta, tau) = splitSigmaTy ty isLiftTy ty - = case getUniDataTyCon_maybe tau of + = case (maybeAppDataTyConExpandingDicts tau) of Just (tycon, tys, _) -> tycon == liftTyCon Nothing -> False where - (tvs, theta, tau) = splitType ty + (tvs, theta, tau) = splitSigmaTy ty -} -alphaLiftTy = mkSigmaTy [alpha_tv] [] (UniData liftTyCon [alpha]) +alphaLiftTy = mkSigmaTy alpha_tyvar [] (applyTyCon liftTyCon alpha_ty) liftTyCon - = pcDataTyCon liftTyConKey pRELUDE_BUILTIN SLIT("_Lift") [alpha_tv] [liftDataCon] + = pcDataTyCon liftTyConKey gHC__ SLIT("Lift") alpha_tyvar [liftDataCon] liftDataCon - = pcDataCon liftDataConKey pRELUDE_BUILTIN SLIT("_Lift") - [alpha_tv] [] [alpha] liftTyCon + = pcDataCon liftDataConKey gHC__ SLIT("Lift") + alpha_tyvar [] alpha_ty liftTyCon ((pcGenerateDataSpecs alphaLiftTy) `addOneToSpecEnv` - (SpecInfo [Just realWorldStatePrimTy] 0 bottom)) + (mkSpecInfo [Just realWorldStatePrimTy] 0 bottom)) where bottom = panic "liftDataCon:State# _RealWorld" \end{code} - - -%************************************************************************ -%* * -\subsection[TysWiredIn-for-convenience]{Types wired in for convenience (e.g., @String@)} -%* * -%************************************************************************ - -\begin{code} -stringTy = mkListTy charTy - -stringTyCon - = mkSynonymTyCon - stringTyConKey - (mkPreludeCoreName pRELUDE_CORE SLIT("String")) - 0 - [] -- type variables - stringTy - True -- unabstract -\end{code} - -\begin{code} -{- UNUSED: -packedStringTy = applyTyCon packedStringTyCon [] - -packedStringTyCon - = pcDataTyCon packedStringTyConKey pRELUDE_PS SLIT("_PackedString") [] - [psDataCon, cpsDataCon] - -psDataCon - = pcDataCon psDataConKey pRELUDE_PS SLIT("_PS") - [] [] [intPrimTy, byteArrayPrimTy] packedStringTyCon - -cpsDataCon - = pcDataCon cpsDataConKey pRELUDE_PS SLIT("_CPS") - [] [] [addrPrimTy] packedStringTyCon --} -\end{code}