X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fprelude%2FTysWiredIn.lhs;fp=ghc%2Fcompiler%2Fprelude%2FTysWiredIn.lhs;h=0000000000000000000000000000000000000000;hb=0065d5ab628975892cea1ec7303f968c3338cbe1;hp=ceb4df550aaec8e0651aa43cb63604a130e0782f;hpb=28a464a75e14cece5db40f2765a29348273ff2d2;p=ghc-hetmet.git diff --git a/ghc/compiler/prelude/TysWiredIn.lhs b/ghc/compiler/prelude/TysWiredIn.lhs deleted file mode 100644 index ceb4df5..0000000 --- a/ghc/compiler/prelude/TysWiredIn.lhs +++ /dev/null @@ -1,549 +0,0 @@ -% -% (c) The GRASP Project, Glasgow University, 1994-1998 -% -\section[TysWiredIn]{Wired-in knowledge about {\em non-primitive} types} - -This module is about types that can be defined in Haskell, but which -must be wired into the compiler nonetheless. - -This module tracks the ``state interface'' document, ``GHC prelude: -types and operations.'' - -\begin{code} -module TysWiredIn ( - wiredInTyCons, - - boolTy, boolTyCon, boolTyCon_RDR, boolTyConName, - trueDataCon, trueDataConId, true_RDR, - falseDataCon, falseDataConId, false_RDR, - - charTyCon, charDataCon, charTyCon_RDR, - charTy, stringTy, charTyConName, - - - doubleTyCon, doubleDataCon, doubleTy, doubleTyConName, - - floatTyCon, floatDataCon, floatTy, floatTyConName, - - intTyCon, intDataCon, intTyCon_RDR, intDataCon_RDR, intTyConName, - intTy, - - listTyCon, nilDataCon, consDataCon, - listTyCon_RDR, consDataCon_RDR, listTyConName, - mkListTy, - - -- tuples - mkTupleTy, - tupleTyCon, tupleCon, - unitTyCon, unitDataCon, unitDataConId, pairTyCon, - unboxedSingletonTyCon, unboxedSingletonDataCon, - unboxedPairTyCon, unboxedPairDataCon, - - unitTy, - voidTy, - - -- parallel arrays - mkPArrTy, - parrTyCon, parrFakeCon, isPArrTyCon, isPArrFakeCon, - parrTyCon_RDR, parrTyConName - ) where - -#include "HsVersions.h" - -import {-# SOURCE #-} MkId( mkDataConIds ) - --- friends: -import PrelNames -import TysPrim - --- others: -import Constants ( mAX_TUPLE_SIZE ) -import Module ( Module ) -import RdrName ( nameRdrName ) -import Name ( Name, BuiltInSyntax(..), nameUnique, nameOccName, - nameModule, mkWiredInName ) -import OccName ( mkOccNameFS, tcName, dataName, mkTupleOcc, - mkDataConWorkerOcc ) -import DataCon ( DataCon, mkDataCon, dataConWorkId, dataConSourceArity ) -import Var ( TyVar, tyVarKind ) -import TyCon ( TyCon, AlgTyConRhs(DataTyCon), tyConDataCons, - mkTupleTyCon, mkAlgTyCon, tyConName ) - -import BasicTypes ( Arity, RecFlag(..), Boxity(..), isBoxed, - StrictnessMark(..) ) - -import Type ( Type, mkTyConTy, mkTyConApp, mkTyVarTy, mkTyVarTys, - TyThing(..) ) -import Kind ( mkArrowKinds, liftedTypeKind, ubxTupleKind ) -import Unique ( incrUnique, mkTupleTyConUnique, - mkTupleDataConUnique, mkPArrDataConUnique ) -import Array -import FastString -import Outputable - -alpha_tyvar = [alphaTyVar] -alpha_ty = [alphaTy] -\end{code} - - -%************************************************************************ -%* * -\subsection{Wired in type constructors} -%* * -%************************************************************************ - -If you change which things are wired in, make sure you change their -names in PrelNames, so they use wTcQual, wDataQual, etc - -\begin{code} -wiredInTyCons :: [TyCon] -- Excludes tuples -wiredInTyCons = [ unitTyCon -- Not treated like other tuples, because - -- it's defined in GHC.Base, and there's only - -- one of it. We put it in wiredInTyCons so - -- that it'll pre-populate the name cache, so - -- the special case in lookupOrigNameCache - -- doesn't need to look out for it - , boolTyCon - , charTyCon - , doubleTyCon - , floatTyCon - , intTyCon - , listTyCon - , parrTyCon - ] -\end{code} - -\begin{code} -mkWiredInTyConName :: BuiltInSyntax -> Module -> FastString -> Unique -> TyCon -> Name -mkWiredInTyConName built_in mod fs uniq tycon - = mkWiredInName mod (mkOccNameFS tcName fs) uniq - Nothing -- No parent object - (ATyCon tycon) -- Relevant TyCon - built_in - -mkWiredInDataConName :: BuiltInSyntax -> Module -> FastString -> Unique -> DataCon -> Name -> Name -mkWiredInDataConName built_in mod fs uniq datacon parent - = mkWiredInName mod (mkOccNameFS dataName fs) uniq - (Just parent) -- Name of parent TyCon - (ADataCon datacon) -- Relevant DataCon - built_in - -charTyConName = mkWiredInTyConName UserSyntax pREL_BASE FSLIT("Char") charTyConKey charTyCon -charDataConName = mkWiredInDataConName UserSyntax pREL_BASE FSLIT("C#") charDataConKey charDataCon charTyConName -intTyConName = mkWiredInTyConName UserSyntax pREL_BASE FSLIT("Int") intTyConKey intTyCon -intDataConName = mkWiredInDataConName UserSyntax pREL_BASE FSLIT("I#") intDataConKey intDataCon intTyConName - -boolTyConName = mkWiredInTyConName UserSyntax pREL_BASE FSLIT("Bool") boolTyConKey boolTyCon -falseDataConName = mkWiredInDataConName UserSyntax pREL_BASE FSLIT("False") falseDataConKey falseDataCon boolTyConName -trueDataConName = mkWiredInDataConName UserSyntax pREL_BASE FSLIT("True") trueDataConKey trueDataCon boolTyConName -listTyConName = mkWiredInTyConName BuiltInSyntax pREL_BASE FSLIT("[]") listTyConKey listTyCon -nilDataConName = mkWiredInDataConName BuiltInSyntax pREL_BASE FSLIT("[]") nilDataConKey nilDataCon listTyConName -consDataConName = mkWiredInDataConName BuiltInSyntax pREL_BASE FSLIT(":") consDataConKey consDataCon listTyConName - -floatTyConName = mkWiredInTyConName UserSyntax pREL_FLOAT FSLIT("Float") floatTyConKey floatTyCon -floatDataConName = mkWiredInDataConName UserSyntax pREL_FLOAT FSLIT("F#") floatDataConKey floatDataCon floatTyConName -doubleTyConName = mkWiredInTyConName UserSyntax pREL_FLOAT FSLIT("Double") doubleTyConKey doubleTyCon -doubleDataConName = mkWiredInDataConName UserSyntax pREL_FLOAT FSLIT("D#") doubleDataConKey doubleDataCon doubleTyConName - -parrTyConName = mkWiredInTyConName BuiltInSyntax pREL_PARR FSLIT("[::]") parrTyConKey parrTyCon -parrDataConName = mkWiredInDataConName UserSyntax pREL_PARR FSLIT("PArr") parrDataConKey parrDataCon parrTyConName - -boolTyCon_RDR = nameRdrName boolTyConName -false_RDR = nameRdrName falseDataConName -true_RDR = nameRdrName trueDataConName -intTyCon_RDR = nameRdrName intTyConName -charTyCon_RDR = nameRdrName charTyConName -intDataCon_RDR = nameRdrName intDataConName -listTyCon_RDR = nameRdrName listTyConName -consDataCon_RDR = nameRdrName consDataConName -parrTyCon_RDR = nameRdrName parrTyConName -\end{code} - - -%************************************************************************ -%* * -\subsection{mkWiredInTyCon} -%* * -%************************************************************************ - -\begin{code} -pcNonRecDataTyCon = pcTyCon False NonRecursive -pcRecDataTyCon = pcTyCon False Recursive - -pcTyCon is_enum is_rec name tyvars argvrcs cons - = tycon - where - tycon = mkAlgTyCon name - (mkArrowKinds (map tyVarKind tyvars) liftedTypeKind) - tyvars - argvrcs - [] -- No stupid theta - (DataTyCon cons is_enum) - [] -- No record selectors - is_rec - True -- All the wired-in tycons have generics - -pcDataCon :: Name -> [TyVar] -> [Type] -> TyCon -> DataCon -pcDataCon = pcDataConWithFixity False - -pcDataConWithFixity :: Bool -> Name -> [TyVar] -> [Type] -> TyCon -> DataCon --- The Name should be in the DataName name space; it's the name --- of the DataCon itself. --- --- The unique is the first of two free uniques; --- the first is used for the datacon itself, --- the second is used for the "worker name" - -pcDataConWithFixity declared_infix dc_name tyvars arg_tys tycon - = data_con - where - data_con = mkDataCon dc_name declared_infix True {- Vanilla -} - (map (const NotMarkedStrict) arg_tys) - [{- No labelled fields -}] - tyvars [] [] arg_tys tycon (mkTyVarTys tyvars) - (mkDataConIds bogus_wrap_name wrk_name data_con) - - - mod = nameModule dc_name - wrk_occ = mkDataConWorkerOcc (nameOccName dc_name) - wrk_key = incrUnique (nameUnique dc_name) - wrk_name = mkWiredInName mod wrk_occ wrk_key - (Just (tyConName tycon)) - (AnId (dataConWorkId data_con)) UserSyntax - bogus_wrap_name = pprPanic "Wired-in data wrapper id" (ppr dc_name) - -- Wired-in types are too simple to need wrappers -\end{code} - - -%************************************************************************ -%* * -\subsection[TysWiredIn-tuples]{The tuple types} -%* * -%************************************************************************ - -\begin{code} -tupleTyCon :: Boxity -> Arity -> TyCon -tupleTyCon boxity i | i > mAX_TUPLE_SIZE = fst (mk_tuple boxity i) -- Build one specially -tupleTyCon Boxed i = fst (boxedTupleArr ! i) -tupleTyCon Unboxed i = fst (unboxedTupleArr ! i) - -tupleCon :: Boxity -> Arity -> DataCon -tupleCon boxity i | i > mAX_TUPLE_SIZE = snd (mk_tuple boxity i) -- Build one specially -tupleCon Boxed i = snd (boxedTupleArr ! i) -tupleCon Unboxed i = snd (unboxedTupleArr ! i) - -boxedTupleArr, unboxedTupleArr :: Array Int (TyCon,DataCon) -boxedTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple Boxed i | i <- [0..mAX_TUPLE_SIZE]] -unboxedTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple Unboxed i | i <- [0..mAX_TUPLE_SIZE]] - -mk_tuple :: Boxity -> Int -> (TyCon,DataCon) -mk_tuple boxity arity = (tycon, tuple_con) - where - tycon = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con boxity gen_info - mod = mkTupleModule boxity arity - tc_name = mkWiredInName mod (mkTupleOcc tcName boxity arity) tc_uniq - Nothing (ATyCon tycon) BuiltInSyntax - tc_kind = mkArrowKinds (map tyVarKind tyvars) res_kind - res_kind | isBoxed boxity = liftedTypeKind - | otherwise = ubxTupleKind - - tyvars | isBoxed boxity = take arity alphaTyVars - | otherwise = take arity openAlphaTyVars - - tuple_con = pcDataCon dc_name tyvars tyvar_tys tycon - tyvar_tys = mkTyVarTys tyvars - dc_name = mkWiredInName mod (mkTupleOcc dataName boxity arity) dc_uniq - (Just tc_name) (ADataCon tuple_con) BuiltInSyntax - tc_uniq = mkTupleTyConUnique boxity arity - dc_uniq = mkTupleDataConUnique boxity arity - gen_info = True -- Tuples all have generics.. - -- hmm: that's a *lot* of code - -unitTyCon = tupleTyCon Boxed 0 -unitDataCon = head (tyConDataCons unitTyCon) -unitDataConId = dataConWorkId unitDataCon - -pairTyCon = tupleTyCon Boxed 2 - -unboxedSingletonTyCon = tupleTyCon Unboxed 1 -unboxedSingletonDataCon = tupleCon Unboxed 1 - -unboxedPairTyCon = tupleTyCon Unboxed 2 -unboxedPairDataCon = tupleCon Unboxed 2 -\end{code} - -%************************************************************************ -%* * -\subsection[TysWiredIn-boxed-prim]{The ``boxed primitive'' types (@Char@, @Int@, etc)} -%* * -%************************************************************************ - -\begin{code} --- The Void type is represented as a data type with no constructors --- It's a built in type (i.e. there's no way to define it in Haskell; --- the nearest would be --- --- data Void = -- No constructors! --- --- ) It's lifted; there is only one value of this --- type, namely "void", whose semantics is just bottom. --- --- Haskell 98 drops the definition of a Void type, so we just 'simulate' --- voidTy using (). -voidTy = unitTy -\end{code} - - -\begin{code} -charTy = mkTyConTy charTyCon - -charTyCon = pcNonRecDataTyCon charTyConName [] [] [charDataCon] -charDataCon = pcDataCon charDataConName [] [charPrimTy] charTyCon - -stringTy = mkListTy charTy -- convenience only -\end{code} - -\begin{code} -intTy = mkTyConTy intTyCon - -intTyCon = pcNonRecDataTyCon intTyConName [] [] [intDataCon] -intDataCon = pcDataCon intDataConName [] [intPrimTy] intTyCon -\end{code} - -\begin{code} -floatTy = mkTyConTy floatTyCon - -floatTyCon = pcNonRecDataTyCon floatTyConName [] [] [floatDataCon] -floatDataCon = pcDataCon floatDataConName [] [floatPrimTy] floatTyCon -\end{code} - -\begin{code} -doubleTy = mkTyConTy doubleTyCon - -doubleTyCon = pcNonRecDataTyCon doubleTyConName [] [] [doubleDataCon] -doubleDataCon = pcDataCon doubleDataConName [] [doublePrimTy] doubleTyCon -\end{code} - - -%************************************************************************ -%* * -\subsection[TysWiredIn-Bool]{The @Bool@ type} -%* * -%************************************************************************ - -An ordinary enumeration type, but deeply wired in. There are no -magical operations on @Bool@ (just the regular Prelude code). - -{\em BEGIN IDLE SPECULATION BY SIMON} - -This is not the only way to encode @Bool@. A more obvious coding makes -@Bool@ just a boxed up version of @Bool#@, like this: -\begin{verbatim} -type Bool# = Int# -data Bool = MkBool Bool# -\end{verbatim} - -Unfortunately, this doesn't correspond to what the Report says @Bool@ -looks like! Furthermore, we get slightly less efficient code (I -think) with this coding. @gtInt@ would look like this: - -\begin{verbatim} -gtInt :: Int -> Int -> Bool -gtInt x y = case x of I# x# -> - case y of I# y# -> - case (gtIntPrim x# y#) of - b# -> MkBool b# -\end{verbatim} - -Notice that the result of the @gtIntPrim@ comparison has to be turned -into an integer (here called @b#@), and returned in a @MkBool@ box. - -The @if@ expression would compile to this: -\begin{verbatim} -case (gtInt x y) of - MkBool b# -> case b# of { 1# -> e1; 0# -> e2 } -\end{verbatim} - -I think this code is a little less efficient than the previous code, -but I'm not certain. At all events, corresponding with the Report is -important. The interesting thing is that the language is expressive -enough to describe more than one alternative; and that a type doesn't -necessarily need to be a straightforwardly boxed version of its -primitive counterpart. - -{\em END IDLE SPECULATION BY SIMON} - -\begin{code} -boolTy = mkTyConTy boolTyCon - -boolTyCon = pcTyCon True NonRecursive boolTyConName - [] [] [falseDataCon, trueDataCon] - -falseDataCon = pcDataCon falseDataConName [] [] boolTyCon -trueDataCon = pcDataCon trueDataConName [] [] boolTyCon - -falseDataConId = dataConWorkId falseDataCon -trueDataConId = dataConWorkId trueDataCon -\end{code} - -%************************************************************************ -%* * -\subsection[TysWiredIn-List]{The @List@ type (incl ``build'' magic)} -%* * -%************************************************************************ - -Special syntax, deeply wired in, but otherwise an ordinary algebraic -data types: -\begin{verbatim} -data [] a = [] | a : (List a) -data () = () -data (,) a b = (,,) a b -... -\end{verbatim} - -\begin{code} -mkListTy :: Type -> Type -mkListTy ty = mkTyConApp listTyCon [ty] - -listTyCon = pcRecDataTyCon listTyConName - alpha_tyvar [(True,False)] [nilDataCon, consDataCon] - -nilDataCon = pcDataCon nilDataConName alpha_tyvar [] listTyCon -consDataCon = pcDataConWithFixity True {- Declared infix -} - consDataConName - alpha_tyvar [alphaTy, mkTyConApp listTyCon alpha_ty] listTyCon --- 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} - -%************************************************************************ -%* * -\subsection[TysWiredIn-Tuples]{The @Tuple@ types} -%* * -%************************************************************************ - -The tuple types are definitely magic, because they form an infinite -family. - -\begin{itemize} -\item -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@. Again these contain their arity but don't need a Unique. - -\item -There should be a magic way of generating the info tables and -entry code for all tuples. - -But at the moment we just compile a Haskell source -file\srcloc{lib/prelude/...} containing declarations like: -\begin{verbatim} -data Tuple0 = Tup0 -data Tuple2 a b = Tup2 a b -data Tuple3 a b c = Tup3 a b c -data Tuple4 a b c d = Tup4 a b c d -... -\end{verbatim} -The print-names associated with the magic @Id@s for tuple constructors -``just happen'' to be the same as those generated by these -declarations. - -\item -The instance environment should have a magic way to know -that each tuple type is an instances of classes @Eq@, @Ix@, @Ord@ and -so on. \ToDo{Not implemented yet.} - -\item -There should also be a way to generate the appropriate code for each -of these instances, but (like the info tables and entry code) it is -done by enumeration\srcloc{lib/prelude/InTup?.hs}. -\end{itemize} - -\begin{code} -mkTupleTy :: Boxity -> Int -> [Type] -> Type -mkTupleTy boxity arity tys = mkTyConApp (tupleTyCon boxity arity) tys - -unitTy = mkTupleTy Boxed 0 [] -\end{code} - -%************************************************************************ -%* * -\subsection[TysWiredIn-PArr]{The @[::]@ type} -%* * -%************************************************************************ - -Special syntax for parallel arrays needs some wired in definitions. - -\begin{code} --- construct a type representing the application of the parallel array --- constructor --- -mkPArrTy :: Type -> Type -mkPArrTy ty = mkTyConApp parrTyCon [ty] - --- represents the type constructor of parallel arrays --- --- * this must match the definition in `PrelPArr' --- --- NB: Although the constructor is given here, it will not be accessible in --- user code as it is not in the environment of any compiled module except --- `PrelPArr'. --- -parrTyCon :: TyCon -parrTyCon = pcNonRecDataTyCon parrTyConName alpha_tyvar [(True, False)] [parrDataCon] - -parrDataCon :: DataCon -parrDataCon = pcDataCon - parrDataConName - alpha_tyvar -- forall'ed type variables - [intPrimTy, -- 1st argument: Int# - mkTyConApp -- 2nd argument: Array# a - arrayPrimTyCon - alpha_ty] - parrTyCon - --- check whether a type constructor is the constructor for parallel arrays --- -isPArrTyCon :: TyCon -> Bool -isPArrTyCon tc = tyConName tc == parrTyConName - --- fake array constructors --- --- * these constructors are never really used to represent array values; --- however, they are very convenient during desugaring (and, in particular, --- in the pattern matching compiler) to treat array pattern just like --- yet another constructor pattern --- -parrFakeCon :: Arity -> DataCon -parrFakeCon i | i > mAX_TUPLE_SIZE = mkPArrFakeCon i -- build one specially -parrFakeCon i = parrFakeConArr!i - --- pre-defined set of constructors --- -parrFakeConArr :: Array Int DataCon -parrFakeConArr = array (0, mAX_TUPLE_SIZE) [(i, mkPArrFakeCon i) - | i <- [0..mAX_TUPLE_SIZE]] - --- build a fake parallel array constructor for the given arity --- -mkPArrFakeCon :: Int -> DataCon -mkPArrFakeCon arity = data_con - where - data_con = pcDataCon name [tyvar] tyvarTys parrTyCon - tyvar = head alphaTyVars - tyvarTys = replicate arity $ mkTyVarTy tyvar - nameStr = mkFastString ("MkPArr" ++ show arity) - name = mkWiredInName pREL_PARR (mkOccNameFS dataName nameStr) uniq - Nothing (ADataCon data_con) UserSyntax - uniq = mkPArrDataConUnique arity - --- checks whether a data constructor is a fake constructor for parallel arrays --- -isPArrFakeCon :: DataCon -> Bool -isPArrFakeCon dcon = dcon == parrFakeCon (dataConSourceArity dcon) -\end{code} -