X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcGenDeriv.lhs;h=5e4a31a1e2705b0d19ab3fa2cd5ce934f9bd90bc;hb=05afb7485eea44d6410139f8a20c94b6f66c46f2;hp=6a701272ef6a003fe1e2c1ea702ff3233cca8fd1;hpb=6c381e873e222417d9a67aeec77b9555eca7b7a8;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcGenDeriv.lhs b/ghc/compiler/typecheck/TcGenDeriv.lhs index 6a70127..5e4a31a 100644 --- a/ghc/compiler/typecheck/TcGenDeriv.lhs +++ b/ghc/compiler/typecheck/TcGenDeriv.lhs @@ -1,5 +1,5 @@ % -% (c) The GRASP/AQUA Project, Glasgow University, 1992-1995 +% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998 % \section[TcGenDeriv]{Generating derived instance declarations} @@ -9,98 +9,77 @@ This module is nominally ``subordinate'' to @TcDeriv@, which is the This is where we do all the grimy bindings' generation. \begin{code} -#include "HsVersions.h" - module TcGenDeriv ( - a_Expr, - a_PN, - a_Pat, - ah_PN, - b_Expr, - b_PN, - b_Pat, - bh_PN, - c_Expr, - c_PN, - c_Pat, - ch_PN, - cmp_eq_PN, - d_Expr, - d_PN, - d_Pat, - dh_PN, - eqH_PN, - eqTag_Expr, - eq_PN, - error_PN, - false_Expr, - false_PN, - geH_PN, - gen_Binary_binds, + gen_Bounded_binds, gen_Enum_binds, gen_Eq_binds, gen_Ix_binds, gen_Ord_binds, gen_Read_binds, gen_Show_binds, + gen_Data_binds, + gen_Typeable_binds, gen_tag_n_con_monobind, - gtTag_Expr, - gt_PN, - leH_PN, - ltH_PN, - ltTag_Expr, - lt_PN, - minusH_PN, - mkInt_PN, - rangeSize_PN, - true_Expr, - true_PN, - - con2tag_FN, tag2con_FN, maxtag_FN, - con2tag_PN, tag2con_PN, maxtag_PN, + + con2tag_RDR, tag2con_RDR, maxtag_RDR, TagThingWanted(..) ) where -import Ubiq - -import HsSyn ( HsBinds(..), Bind(..), MonoBinds(..), Match(..), GRHSsAndBinds(..), - GRHS(..), HsExpr(..), HsLit(..), InPat(..), Qual(..), Stmt, - ArithSeqInfo, Sig, PolyType, FixityDecl, Fake ) -import RdrHsSyn ( ProtoNameMonoBinds(..), ProtoNameHsExpr(..), ProtoNamePat(..) ) -import RnHsSyn ( RenamedFixityDecl(..) ) - -import RnMonad4 -- initRn4, etc. -import RnUtils +#include "HsVersions.h" -import Id ( GenId, getDataConArity, getDataConTag, - getDataConSig, fIRST_TAG, - isDataCon, DataCon(..), ConTag(..) ) -import IdUtils ( primOpId ) -import Maybes ( maybeToBool ) -import Name ( Name(..) ) -import NameTypes ( mkFullName, Provenance(..) ) +import HsSyn ( Pat(..), HsConDetails(..), HsExpr(..), MonoBinds(..), + Match(..), GRHSs(..), Stmt(..), HsLit(..), + HsBinds(..), HsType(..), HsStmtContext(..), + unguardedRHS, mkSimpleMatch, mkMonoBind, andMonoBindList, placeHolderType + ) +import RdrName ( RdrName, mkUnqual, nameRdrName, getRdrName ) +import RdrHsSyn ( mkHsOpApp, RdrNameMonoBinds, RdrNameHsExpr, RdrNamePat, mkHsDo ) +import BasicTypes ( RecFlag(..), Fixity(..), FixityDirection(..) + , maxPrecedence + , Boxity(..) + ) +import FieldLabel ( fieldLabelName ) +import DataCon ( isNullaryDataCon, dataConTag, + dataConOrigArgTys, dataConSourceArity, fIRST_TAG, + DataCon, + dataConFieldLabels ) +import Name ( getOccString, getOccName, getSrcLoc, occNameString, + occNameUserString, varName, + Name, NamedThing(..), + isDataSymOcc, isSymOcc + ) + +import HscTypes ( FixityEnv, lookupFixity ) +import PrelNames -- Lots of Names +import PrimOp -- Lots of Names +import SrcLoc ( generatedSrcLoc, SrcLoc ) +import TyCon ( TyCon, isNewTyCon, tyConDataCons, isEnumerationTyCon, + maybeTyConSingleCon, tyConFamilySize, tyConTyVars + ) +import TcType ( isUnLiftedType, tcEqType, Type ) +import TysPrim ( charPrimTy, intPrimTy, wordPrimTy, addrPrimTy, floatPrimTy, doublePrimTy ) +import TysWiredIn ( charDataCon, intDataCon, floatDataCon, doubleDataCon, wordDataCon ) +import Util ( zipWithEqual, isSingleton, + zipWith3Equal, nOfThem, zipEqual ) +import Panic ( panic, assertPanic ) +import Char ( ord, isAlpha ) +import Constants +import List ( partition, intersperse ) import Outputable -import PrimOp -import PrelInfo -import Pretty -import ProtoName ( ProtoName(..) ) -import SrcLoc ( mkGeneratedSrcLoc ) -import TyCon ( TyCon, getTyConDataCons, isEnumerationTyCon, maybeTyConSingleCon ) -import Type ( eqTy, isPrimType ) -import Unique -import Util +import FastString +import OccName \end{code} %************************************************************************ %* * -\subsection[TcGenDeriv-classes]{Generating code, by derivable class} +\subsection{Generating code, by derivable class} %* * %************************************************************************ %************************************************************************ %* * -\subsubsection[TcGenDeriv-Eq]{Generating @Eq@ instance declarations} +\subsubsection{Generating @Eq@ instance declarations} %* * %************************************************************************ @@ -125,7 +104,7 @@ data Foo ... = N1 | N2 ... | Nn | O1 a b | O2 Int | O3 Double b b | ... (==) (O3 a1 b1 c1) (O3 a2 b2 c2) = a1 == a2 && b1 == b2 && c1 == c2 \end{verbatim} - Note: if we're comparing unboxed things, e.g., if \tr{a1} and + Note: if we're comparing unlifted things, e.g., if \tr{a1} and \tr{a2} are \tr{Float#}s, then we have to generate \begin{verbatim} case (a1 `eqFloat#` a2) of @@ -171,60 +150,73 @@ instance ... Eq (Foo ...) where produced don't get through the typechecker. \end{itemize} + +deriveEq :: RdrName -- Class + -> RdrName -- Type constructor + -> [ (RdrName, [RdrType]) ] -- Constructors + -> (RdrContext, -- Context for the inst decl + [RdrBind], -- Binds in the inst decl + [RdrBind]) -- Extra value bindings outside + +deriveEq clas tycon constrs + = (context, [eq_bind, ne_bind], []) + where + context = [(clas, [ty]) | (_, tys) <- constrs, ty <- tys] + + ne_bind = mkBind + (nullary_cons, non_nullary_cons) = partition is_nullary constrs + is_nullary (_, args) = null args + \begin{code} -gen_Eq_binds :: TyCon -> ProtoNameMonoBinds +gen_Eq_binds :: TyCon -> RdrNameMonoBinds gen_Eq_binds tycon - = case (partition (\ con -> getDataConArity con == 0) - (getTyConDataCons tycon)) - of { (nullary_cons, nonnullary_cons) -> - let + = let + tycon_loc = getSrcLoc tycon + (nullary_cons, nonnullary_cons) + | isNewTyCon tycon = ([], tyConDataCons tycon) + | otherwise = partition isNullaryDataCon (tyConDataCons tycon) + rest - = if null nullary_cons then + = if (null nullary_cons) then case maybeTyConSingleCon tycon of Just _ -> [] Nothing -> -- if cons don't match, then False - [([a_Pat, b_Pat], false_Expr)] + [([wildPat, wildPat], false_Expr)] else -- calc. and compare the tags [([a_Pat, b_Pat], - untag_Expr tycon [(a_PN,ah_PN), (b_PN,bh_PN)] - (cmp_tags_Expr eqH_PN ah_PN bh_PN true_Expr false_Expr))] + untag_Expr tycon [(a_RDR,ah_RDR), (b_RDR,bh_RDR)] + (genOpApp (HsVar ah_RDR) eqInt_RDR (HsVar bh_RDR)))] in - mk_FunMonoBind eq_PN ((map pats_etc nonnullary_cons) ++ rest) - `AndMonoBinds` boring_ne_method - } + mk_FunMonoBind tycon_loc eq_RDR ((map pats_etc nonnullary_cons) ++ rest) + `AndMonoBinds` + mk_easy_FunMonoBind tycon_loc ne_RDR [a_Pat, b_Pat] [] ( + HsApp (HsVar not_RDR) (HsPar (mkHsVarApps eq_RDR [a_RDR, b_RDR]))) where ------------------------------------------------------------------ pats_etc data_con = let - con1_pat = ConPatIn data_con_PN (map VarPatIn as_needed) - con2_pat = ConPatIn data_con_PN (map VarPatIn bs_needed) - - data_con_PN = Prel (WiredInVal data_con) - as_needed = take (getDataConArity data_con) as_PNs - bs_needed = take (getDataConArity data_con) bs_PNs - tys_needed = case (getDataConSig data_con) of - (_,_, arg_tys, _) -> arg_tys + con1_pat = mkConPat data_con_RDR as_needed + con2_pat = mkConPat data_con_RDR bs_needed + + data_con_RDR = getRdrName data_con + con_arity = length tys_needed + as_needed = take con_arity as_RDRs + bs_needed = take con_arity bs_RDRs + tys_needed = dataConOrigArgTys data_con in ([con1_pat, con2_pat], nested_eq_expr tys_needed as_needed bs_needed) where - nested_eq_expr [] [] [] = true_Expr - nested_eq_expr [ty] [a] [b] = eq_Expr ty (HsVar a) (HsVar b) - nested_eq_expr (t:ts) (a:as) (b:bs) - = let - rest_expr = nested_eq_expr ts as bs - in - and_Expr (eq_Expr t (HsVar a) (HsVar b)) rest_expr - -boring_ne_method - = mk_easy_FunMonoBind ne_PN [a_Pat, b_Pat] [] ( - HsApp (HsVar not_PN) (HsApp (HsApp (HsVar eq_PN) a_Expr) b_Expr) - ) + nested_eq_expr [] [] [] = true_Expr + nested_eq_expr tys as bs + = foldl1 and_Expr (zipWith3Equal "nested_eq" nested_eq tys as bs) + where + nested_eq ty a b = HsPar (eq_Expr tycon ty (HsVar a) (HsVar b)) \end{code} %************************************************************************ %* * -\subsubsection[TcGenDeriv-Ord]{Generating @Ord@ instance declarations} +\subsubsection{Generating @Ord@ instance declarations} %* * %************************************************************************ @@ -244,13 +236,13 @@ data Foo ... = N1 | N2 ... | Nn | O1 a b | O2 Int | O3 Double b b | ... We do all the other @Ord@ methods with calls to @compare@: \begin{verbatim} instance ... (Ord ) where - a < b = case compare a b of { LT -> True; EQ -> False; GT -> False } - a <= b = case compare a b of { LT -> True; EQ -> True; GT -> False } - a >= b = case compare a b of { LT -> False; EQ -> True; GT -> True } - a > b = case compare a b of { LT -> False; EQ -> False; GT -> True } + a < b = case (compare a b) of { LT -> True; EQ -> False; GT -> False } + a <= b = case (compare a b) of { LT -> True; EQ -> True; GT -> False } + a >= b = case (compare a b) of { LT -> False; EQ -> True; GT -> True } + a > b = case (compare a b) of { LT -> False; EQ -> False; GT -> True } - max a b = case compare a b of { LT -> b; EQ -> a; GT -> a } - min a b = case compare a b of { LT -> a; EQ -> b; GT -> b } + max a b = case (compare a b) of { LT -> b; EQ -> a; GT -> a } + min a b = case (compare a b) of { LT -> a; EQ -> b; GT -> b } -- compare to come... \end{verbatim} @@ -262,7 +254,7 @@ instance ... (Ord ) where \begin{verbatim} compare a b = case (con2tag_Foo a) of { a# -> case (con2tag_Foo b) of { b# -> - case (a# ==# b#) of { + case (a# ==# b#) of { True -> cmp_eq a b False -> case (a# <# b#) of True -> _LT @@ -297,9 +289,10 @@ cmp_eq (O3 a1 b1 c1) (O3 a2 b2 c2) } \end{verbatim} - Again, we must be careful about unboxed comparisons. For example, + Again, we must be careful about unlifted comparisons. For example, if \tr{a1} and \tr{a2} were \tr{Int#}s in the 2nd example above, we'd need to generate: + \begin{verbatim} cmp_eq lt eq gt (O2 a1) (O2 a2) = compareInt# a1 a2 @@ -314,85 +307,82 @@ cmp_eq _ _ = EQ \end{verbatim} \end{itemize} +If there is only one constructor in the Data Type we don't need the WildCard Pattern. +JJQC-30-Nov-1997 + \begin{code} -gen_Ord_binds :: TyCon -> ProtoNameMonoBinds +gen_Ord_binds :: TyCon -> RdrNameMonoBinds gen_Ord_binds tycon - = defaulted `AndMonoBinds` compare + = compare -- `AndMonoBinds` compare + -- The default declaration in PrelBase handles this where + tycon_loc = getSrcLoc tycon -------------------------------------------------------------------- - compare = mk_easy_FunMonoBind compare_PN - [a_Pat, b_Pat] - [cmp_eq] - (if maybeToBool (maybeTyConSingleCon tycon) then - cmp_eq_Expr ltTag_Expr eqTag_Expr gtTag_Expr a_Expr b_Expr - else - untag_Expr tycon [(a_PN, ah_PN), (b_PN, bh_PN)] - (cmp_tags_Expr eqH_PN ah_PN bh_PN - -- True case; they are equal - -- If an enumeration type we are done; else - -- recursively compare their components - (if isEnumerationTyCon tycon then - eqTag_Expr - else - cmp_eq_Expr ltTag_Expr eqTag_Expr gtTag_Expr a_Expr b_Expr - ) + compare = mk_easy_FunMonoBind tycon_loc compare_RDR + [a_Pat, b_Pat] [cmp_eq] compare_rhs + compare_rhs + | single_con_type = cmp_eq_Expr a_Expr b_Expr + | otherwise + = untag_Expr tycon [(a_RDR, ah_RDR), (b_RDR, bh_RDR)] + (cmp_tags_Expr eqInt_RDR ah_RDR bh_RDR + (cmp_eq_Expr a_Expr b_Expr) -- True case -- False case; they aren't equal -- So we need to do a less-than comparison on the tags - (cmp_tags_Expr ltH_PN ah_PN bh_PN ltTag_Expr gtTag_Expr))) + (cmp_tags_Expr ltInt_RDR ah_RDR bh_RDR ltTag_Expr gtTag_Expr)) + tycon_data_cons = tyConDataCons tycon + single_con_type = isSingleton tycon_data_cons (nullary_cons, nonnullary_cons) - = partition (\ con -> getDataConArity con == 0) (getTyConDataCons tycon) + | isNewTyCon tycon = ([], tyConDataCons tycon) + | otherwise = partition isNullaryDataCon tycon_data_cons + + cmp_eq = mk_FunMonoBind tycon_loc cmp_eq_RDR cmp_eq_match + cmp_eq_match + | isEnumerationTyCon tycon + -- We know the tags are equal, so if it's an enumeration TyCon, + -- then there is nothing left to do + -- Catch this specially to avoid warnings + -- about overlapping patterns from the desugarer, + -- and to avoid unnecessary pattern-matching + = [([wildPat,wildPat], eqTag_Expr)] + | otherwise + = map pats_etc nonnullary_cons ++ + (if single_con_type then -- Omit wildcards when there's just one + [] -- constructor, to silence desugarer + else + [([wildPat, wildPat], default_rhs)]) - cmp_eq - = mk_FunMonoBind cmp_eq_PN (map pats_etc nonnullary_cons ++ deflt_pats_etc) where pats_etc data_con = ([con1_pat, con2_pat], nested_compare_expr tys_needed as_needed bs_needed) where - con1_pat = ConPatIn data_con_PN (map VarPatIn as_needed) - con2_pat = ConPatIn data_con_PN (map VarPatIn bs_needed) + con1_pat = mkConPat data_con_RDR as_needed + con2_pat = mkConPat data_con_RDR bs_needed - data_con_PN = Prel (WiredInVal data_con) - as_needed = take (getDataConArity data_con) as_PNs - bs_needed = take (getDataConArity data_con) bs_PNs - tys_needed = case (getDataConSig data_con) of - (_,_, arg_tys, _) -> arg_tys + data_con_RDR = getRdrName data_con + con_arity = length tys_needed + as_needed = take con_arity as_RDRs + bs_needed = take con_arity bs_RDRs + tys_needed = dataConOrigArgTys data_con nested_compare_expr [ty] [a] [b] - = careful_compare_Case ty ltTag_Expr eqTag_Expr gtTag_Expr (HsVar a) (HsVar b) + = careful_compare_Case tycon ty eqTag_Expr (HsVar a) (HsVar b) nested_compare_expr (ty:tys) (a:as) (b:bs) = let eq_expr = nested_compare_expr tys as bs - in careful_compare_Case ty ltTag_Expr eq_expr gtTag_Expr (HsVar a) (HsVar b) - - deflt_pats_etc - = if null nullary_cons - then [] - else [([a_Pat, b_Pat], eqTag_Expr)] - -------------------------------------------------------------------- + in careful_compare_Case tycon ty eq_expr (HsVar a) (HsVar b) -defaulted = foldr1 AndMonoBinds [lt, le, ge, gt, max_, min_] - -lt = mk_easy_FunMonoBind lt_PN [a_Pat, b_Pat] [] ( - compare_Case true_Expr false_Expr false_Expr a_Expr b_Expr) -le = mk_easy_FunMonoBind le_PN [a_Pat, b_Pat] [] ( - compare_Case true_Expr true_Expr false_Expr a_Expr b_Expr) -ge = mk_easy_FunMonoBind ge_PN [a_Pat, b_Pat] [] ( - compare_Case false_Expr true_Expr true_Expr a_Expr b_Expr) -gt = mk_easy_FunMonoBind gt_PN [a_Pat, b_Pat] [] ( - compare_Case false_Expr false_Expr true_Expr a_Expr b_Expr) - -max_ = mk_easy_FunMonoBind max_PN [a_Pat, b_Pat] [] ( - compare_Case b_Expr a_Expr a_Expr a_Expr b_Expr) -min_ = mk_easy_FunMonoBind min_PN [a_Pat, b_Pat] [] ( - compare_Case a_Expr b_Expr b_Expr a_Expr b_Expr) + default_rhs | null nullary_cons = impossible_Expr -- Keep desugarer from complaining about + -- inexhaustive patterns + | otherwise = eqTag_Expr -- Some nullary constructors; + -- Tags are equal, no args => return EQ \end{code} %************************************************************************ %* * -\subsubsection[TcGenDeriv-Enum]{Generating @Enum@ instance declarations} +\subsubsection{Generating @Enum@ instance declarations} %* * %************************************************************************ @@ -406,6 +396,11 @@ we use both @con2tag_Foo@ and @tag2con_Foo@ functions, as well as a \begin{verbatim} instance ... Enum (Foo ...) where + succ x = toEnum (1 + fromEnum x) + pred x = toEnum (fromEnum x - 1) + + toEnum i = tag2con_Foo i + enumFrom a = map tag2con_Foo [con2tag_Foo a .. maxtag_Foo] -- or, really... @@ -427,32 +422,116 @@ instance ... Enum (Foo ...) where For @enumFromTo@ and @enumFromThenTo@, we use the default methods. \begin{code} -gen_Enum_binds :: TyCon -> ProtoNameMonoBinds +gen_Enum_binds :: TyCon -> RdrNameMonoBinds gen_Enum_binds tycon - = enum_from `AndMonoBinds` enum_from_then + = succ_enum `AndMonoBinds` + pred_enum `AndMonoBinds` + to_enum `AndMonoBinds` + enum_from `AndMonoBinds` + enum_from_then `AndMonoBinds` + from_enum where + tycon_loc = getSrcLoc tycon + occ_nm = getOccString tycon + + succ_enum + = mk_easy_FunMonoBind tycon_loc succ_RDR [a_Pat] [] $ + untag_Expr tycon [(a_RDR, ah_RDR)] $ + HsIf (mkHsApps eq_RDR [HsVar (maxtag_RDR tycon), + mkHsVarApps mkInt_RDR [ah_RDR]]) + (illegal_Expr "succ" occ_nm "tried to take `succ' of last tag in enumeration") + (HsApp (HsVar (tag2con_RDR tycon)) + (mkHsApps plus_RDR [mkHsVarApps mkInt_RDR [ah_RDR], + mkHsIntLit 1])) + tycon_loc + + pred_enum + = mk_easy_FunMonoBind tycon_loc pred_RDR [a_Pat] [] $ + untag_Expr tycon [(a_RDR, ah_RDR)] $ + HsIf (mkHsApps eq_RDR [mkHsIntLit 0, + mkHsVarApps mkInt_RDR [ah_RDR]]) + (illegal_Expr "pred" occ_nm "tried to take `pred' of first tag in enumeration") + (HsApp (HsVar (tag2con_RDR tycon)) + (mkHsApps plus_RDR [mkHsVarApps mkInt_RDR [ah_RDR], + HsLit (HsInt (-1))])) + tycon_loc + + to_enum + = mk_easy_FunMonoBind tycon_loc toEnum_RDR [a_Pat] [] $ + HsIf (mkHsApps and_RDR + [mkHsApps ge_RDR [HsVar a_RDR, mkHsIntLit 0], + mkHsApps le_RDR [HsVar a_RDR, HsVar (maxtag_RDR tycon)]]) + (mkHsVarApps (tag2con_RDR tycon) [a_RDR]) + (illegal_toEnum_tag occ_nm (maxtag_RDR tycon)) + tycon_loc + enum_from - = mk_easy_FunMonoBind enumFrom_PN [a_Pat] [] ( - untag_Expr tycon [(a_PN, ah_PN)] ( - HsApp (HsApp (HsVar map_PN) (HsVar (tag2con_PN tycon))) ( - enum_from_to_Expr - (HsApp (HsVar mkInt_PN) (HsVar ah_PN)) - (HsVar (maxtag_PN tycon))))) + = mk_easy_FunMonoBind tycon_loc enumFrom_RDR [a_Pat] [] $ + untag_Expr tycon [(a_RDR, ah_RDR)] $ + mkHsApps map_RDR + [HsVar (tag2con_RDR tycon), + HsPar (enum_from_to_Expr + (mkHsVarApps mkInt_RDR [ah_RDR]) + (HsVar (maxtag_RDR tycon)))] enum_from_then - = mk_easy_FunMonoBind enumFromThen_PN [a_Pat, b_Pat] [] ( - untag_Expr tycon [(a_PN, ah_PN), (b_PN, bh_PN)] ( - HsApp (HsApp (HsVar map_PN) (HsVar (tag2con_PN tycon))) ( - enum_from_then_to_Expr - (HsApp (HsVar mkInt_PN) (HsVar ah_PN)) - (HsApp (HsVar mkInt_PN) (HsVar bh_PN)) - (HsVar (maxtag_PN tycon))))) + = mk_easy_FunMonoBind tycon_loc enumFromThen_RDR [a_Pat, b_Pat] [] $ + untag_Expr tycon [(a_RDR, ah_RDR), (b_RDR, bh_RDR)] $ + HsApp (mkHsVarApps map_RDR [tag2con_RDR tycon]) $ + HsPar (enum_from_then_to_Expr + (mkHsVarApps mkInt_RDR [ah_RDR]) + (mkHsVarApps mkInt_RDR [bh_RDR]) + (HsIf (mkHsApps gt_RDR [mkHsVarApps mkInt_RDR [ah_RDR], + mkHsVarApps mkInt_RDR [bh_RDR]]) + (mkHsIntLit 0) + (HsVar (maxtag_RDR tycon)) + tycon_loc)) + + from_enum + = mk_easy_FunMonoBind tycon_loc fromEnum_RDR [a_Pat] [] $ + untag_Expr tycon [(a_RDR, ah_RDR)] $ + (mkHsVarApps mkInt_RDR [ah_RDR]) +\end{code} + +%************************************************************************ +%* * +\subsubsection{Generating @Bounded@ instance declarations} +%* * +%************************************************************************ + +\begin{code} +gen_Bounded_binds tycon + = if isEnumerationTyCon tycon then + min_bound_enum `AndMonoBinds` max_bound_enum + else + ASSERT(isSingleton data_cons) + min_bound_1con `AndMonoBinds` max_bound_1con + where + data_cons = tyConDataCons tycon + tycon_loc = getSrcLoc tycon + + ----- enum-flavored: --------------------------- + min_bound_enum = mkVarMonoBind tycon_loc minBound_RDR (HsVar data_con_1_RDR) + max_bound_enum = mkVarMonoBind tycon_loc maxBound_RDR (HsVar data_con_N_RDR) + + data_con_1 = head data_cons + data_con_N = last data_cons + data_con_1_RDR = getRdrName data_con_1 + data_con_N_RDR = getRdrName data_con_N + + ----- single-constructor-flavored: ------------- + arity = dataConSourceArity data_con_1 + + min_bound_1con = mkVarMonoBind tycon_loc minBound_RDR $ + mkHsVarApps data_con_1_RDR (nOfThem arity minBound_RDR) + max_bound_1con = mkVarMonoBind tycon_loc maxBound_RDR $ + mkHsVarApps data_con_1_RDR (nOfThem arity maxBound_RDR) \end{code} %************************************************************************ %* * -\subsubsection[TcGenDeriv-Ix]{Generating @Ix@ instance declarations} +\subsubsection{Generating @Ix@ instance declarations} %* * %************************************************************************ @@ -499,7 +578,7 @@ instance ... Ix (Foo ...) where False }}} \end{verbatim} -(modulo suitable case-ification to handle the unboxed tags) +(modulo suitable case-ification to handle the unlifted tags) For a single-constructor type (NB: this includes all tuples), e.g., \begin{verbatim} @@ -509,245 +588,537 @@ we follow the scheme given in Figure~19 of the Haskell~1.2 report (p.~147). \begin{code} -gen_Ix_binds :: TyCon -> ProtoNameMonoBinds +gen_Ix_binds :: TyCon -> RdrNameMonoBinds gen_Ix_binds tycon = if isEnumerationTyCon tycon then enum_ixes else single_con_ixes where - tycon_str = _UNPK_ (snd (getOrigName tycon)) + tycon_str = getOccString tycon + tycon_loc = getSrcLoc tycon -------------------------------------------------------------- enum_ixes = enum_range `AndMonoBinds` enum_index `AndMonoBinds` enum_inRange enum_range - = mk_easy_FunMonoBind range_PN [TuplePatIn [a_Pat, b_Pat]] [] ( - untag_Expr tycon [(a_PN, ah_PN)] ( - untag_Expr tycon [(b_PN, bh_PN)] ( - HsApp (HsApp (HsVar map_PN) (HsVar (tag2con_PN tycon))) ( - enum_from_to_Expr - (HsApp (HsVar mkInt_PN) (HsVar ah_PN)) - (HsApp (HsVar mkInt_PN) (HsVar bh_PN)) - )))) + = mk_easy_FunMonoBind tycon_loc range_RDR + [TuplePat [a_Pat, b_Pat] Boxed] [] $ + untag_Expr tycon [(a_RDR, ah_RDR)] $ + untag_Expr tycon [(b_RDR, bh_RDR)] $ + HsApp (mkHsVarApps map_RDR [tag2con_RDR tycon]) $ + HsPar (enum_from_to_Expr + (mkHsVarApps mkInt_RDR [ah_RDR]) + (mkHsVarApps mkInt_RDR [bh_RDR])) enum_index - = mk_easy_FunMonoBind index_PN [AsPatIn c_PN (TuplePatIn [a_Pat, b_Pat]), d_Pat] [] ( - HsIf (HsApp (HsApp (HsVar inRange_PN) c_Expr) d_Expr) ( - untag_Expr tycon [(a_PN, ah_PN)] ( - untag_Expr tycon [(d_PN, dh_PN)] ( + = mk_easy_FunMonoBind tycon_loc index_RDR + [AsPat c_RDR (TuplePat [a_Pat, wildPat] Boxed), + d_Pat] [] ( + HsIf (HsPar (mkHsVarApps inRange_RDR [c_RDR, d_RDR])) ( + untag_Expr tycon [(a_RDR, ah_RDR)] ( + untag_Expr tycon [(d_RDR, dh_RDR)] ( let - grhs = [OtherwiseGRHS (HsApp (HsVar mkInt_PN) (HsVar c_PN)) mkGeneratedSrcLoc] + rhs = mkHsVarApps mkInt_RDR [c_RDR] in HsCase - (OpApp (HsVar dh_PN) (HsVar minusH_PN) (HsVar ah_PN)) - [PatMatch (VarPatIn c_PN) - (GRHSMatch (GRHSsAndBindsIn grhs EmptyBinds))] - mkGeneratedSrcLoc + (genOpApp (HsVar dh_RDR) minusInt_RDR (HsVar ah_RDR)) + [mkSimpleMatch [VarPat c_RDR] rhs placeHolderType tycon_loc] + tycon_loc )) ) {-else-} ( - HsApp (HsVar error_PN) (HsLit (HsString (_PK_ ("Ix."++tycon_str++".index: out of range\n")))) + HsApp (HsVar error_RDR) (HsLit (HsString (mkFastString ("Ix."++tycon_str++".index: out of range\n")))) ) - mkGeneratedSrcLoc) + tycon_loc) enum_inRange - = mk_easy_FunMonoBind inRange_PN [TuplePatIn [a_Pat, b_Pat], c_Pat] [] ( - untag_Expr tycon [(a_PN, ah_PN)] ( - untag_Expr tycon [(b_PN, bh_PN)] ( - untag_Expr tycon [(c_PN, ch_PN)] ( - HsIf (OpApp (HsVar ch_PN) (HsVar geH_PN) (HsVar ah_PN)) ( - (OpApp (HsVar ch_PN) (HsVar leH_PN) (HsVar bh_PN)) + = mk_easy_FunMonoBind tycon_loc inRange_RDR + [TuplePat [a_Pat, b_Pat] Boxed, c_Pat] [] ( + untag_Expr tycon [(a_RDR, ah_RDR)] ( + untag_Expr tycon [(b_RDR, bh_RDR)] ( + untag_Expr tycon [(c_RDR, ch_RDR)] ( + HsIf (genOpApp (HsVar ch_RDR) geInt_RDR (HsVar ah_RDR)) ( + (genOpApp (HsVar ch_RDR) leInt_RDR (HsVar bh_RDR)) ) {-else-} ( false_Expr - ) mkGeneratedSrcLoc)))) + ) tycon_loc)))) -------------------------------------------------------------- - single_con_ixes = single_con_range `AndMonoBinds` - single_con_index `AndMonoBinds` single_con_inRange + single_con_ixes + = single_con_range `AndMonoBinds` + single_con_index `AndMonoBinds` + single_con_inRange data_con = case maybeTyConSingleCon tycon of -- just checking... Nothing -> panic "get_Ix_binds" - Just dc -> let - (_, _, arg_tys, _) = getDataConSig dc - in - if any isPrimType arg_tys then - error ("ERROR: Can't derive Ix for a single-constructor type with primitive argument types: "++tycon_str) - else - dc - - con_arity = getDataConArity data_con - data_con_PN = Prel (WiredInVal data_con) - con_pat xs = ConPatIn data_con_PN (map VarPatIn xs) - con_expr xs = foldl HsApp (HsVar data_con_PN) (map HsVar xs) - - as_needed = take (getDataConArity data_con) as_PNs - bs_needed = take (getDataConArity data_con) bs_PNs - cs_needed = take (getDataConArity data_con) cs_PNs + Just dc | any isUnLiftedType (dataConOrigArgTys dc) + -> pprPanic "Can't derive Ix for a single-constructor type with primitive argument types:" (ppr tycon) + | otherwise -> dc + + con_arity = dataConSourceArity data_con + data_con_RDR = getRdrName data_con + + as_needed = take con_arity as_RDRs + bs_needed = take con_arity bs_RDRs + cs_needed = take con_arity cs_RDRs + + con_pat xs = mkConPat data_con_RDR xs + con_expr = mkHsVarApps data_con_RDR cs_needed -------------------------------------------------------------- single_con_range - = mk_easy_FunMonoBind range_PN [TuplePatIn [con_pat as_needed, con_pat bs_needed]] [] ( - ListComp (con_expr cs_needed) (zipWith3Equal mk_qual as_needed bs_needed cs_needed) - ) + = mk_easy_FunMonoBind tycon_loc range_RDR + [TuplePat [con_pat as_needed, con_pat bs_needed] Boxed] [] $ + mkHsDo ListComp stmts tycon_loc where - mk_qual a b c = GeneratorQual (VarPatIn c) - (HsApp (HsVar range_PN) (ExplicitTuple [HsVar a, HsVar b])) + stmts = zipWith3Equal "single_con_range" mk_qual as_needed bs_needed cs_needed + ++ + [ResultStmt con_expr tycon_loc] + + mk_qual a b c = BindStmt (VarPat c) + (HsApp (HsVar range_RDR) + (ExplicitTuple [HsVar a, HsVar b] Boxed)) + tycon_loc ---------------- single_con_index - = mk_easy_FunMonoBind index_PN [TuplePatIn [con_pat as_needed, con_pat bs_needed], con_pat cs_needed] [range_size] ( - foldl mk_index (HsLit (HsInt 0)) (zip3 as_needed bs_needed cs_needed)) + = mk_easy_FunMonoBind tycon_loc index_RDR + [TuplePat [con_pat as_needed, con_pat bs_needed] Boxed, + con_pat cs_needed] [range_size] ( + foldl mk_index (mkHsIntLit 0) (zip3 as_needed bs_needed cs_needed)) where mk_index multiply_by (l, u, i) - =OpApp ( - (HsApp (HsApp (HsVar index_PN) (ExplicitTuple [HsVar l, HsVar u])) (HsVar i)) - ) (HsVar plus_PN) ( - OpApp ( - (HsApp (HsVar rangeSize_PN) (ExplicitTuple [HsVar l, HsVar u])) - ) (HsVar times_PN) multiply_by + = genOpApp ( + (mkHsApps index_RDR [ExplicitTuple [HsVar l, HsVar u] Boxed, + HsVar i]) + ) plus_RDR ( + genOpApp ( + (HsApp (HsVar rangeSize_RDR) + (ExplicitTuple [HsVar l, HsVar u] Boxed)) + ) times_RDR multiply_by ) range_size - = mk_easy_FunMonoBind rangeSize_PN [TuplePatIn [a_Pat, b_Pat]] [] ( - OpApp ( - (HsApp (HsApp (HsVar index_PN) (ExplicitTuple [a_Expr, b_Expr])) b_Expr) - ) (HsVar plus_PN) (HsLit (HsInt 1))) + = mk_easy_FunMonoBind tycon_loc rangeSize_RDR + [TuplePat [a_Pat, b_Pat] Boxed] [] ( + genOpApp ( + (mkHsApps index_RDR [ExplicitTuple [a_Expr, b_Expr] Boxed, + b_Expr]) + ) plus_RDR (mkHsIntLit 1)) ------------------ single_con_inRange - = mk_easy_FunMonoBind inRange_PN [TuplePatIn [con_pat as_needed, con_pat bs_needed], con_pat cs_needed] [] ( - foldl1 and_Expr (zipWith3Equal in_range as_needed bs_needed cs_needed)) + = mk_easy_FunMonoBind tycon_loc inRange_RDR + [TuplePat [con_pat as_needed, con_pat bs_needed] Boxed, + con_pat cs_needed] + [] ( + foldl1 and_Expr (zipWith3Equal "single_con_inRange" in_range as_needed bs_needed cs_needed)) where - in_range a b c = HsApp (HsApp (HsVar inRange_PN) (ExplicitTuple [HsVar a, HsVar b])) (HsVar c) + in_range a b c = mkHsApps inRange_RDR [ExplicitTuple [HsVar a, HsVar b] Boxed, + HsVar c] \end{code} %************************************************************************ %* * -\subsubsection[TcGenDeriv-Text]{Generating @Show@ and @Read@ instance declarations} +\subsubsection{Generating @Read@ instance declarations} %* * %************************************************************************ -Ignoring all the infix-ery mumbo jumbo (ToDo) +Example + + infix 4 %% + data T = Int %% Int + | T1 { f1 :: Int } + | T2 Int + + +instance Read T where + readPrec = + parens + ( prec 4 ( + do x <- ReadP.step Read.readPrec + Symbol "%%" <- Lex.lex + y <- ReadP.step Read.readPrec + return (x %% y)) + +++ + prec appPrec ( + do Ident "T1" <- Lex.lex + Punc '{' <- Lex.lex + Ident "f1" <- Lex.lex + Punc '=' <- Lex.lex + x <- ReadP.reset Read.readPrec + Punc '}' <- Lex.lex + return (T1 { f1 = x })) + +++ + prec appPrec ( + do Ident "T2" <- Lex.lexP + x <- ReadP.step Read.readPrec + return (T2 x)) + ) + + readListPrec = readListPrecDefault + readList = readListDefault + \begin{code} -gen_Read_binds :: [RenamedFixityDecl] -> TyCon -> ProtoNameMonoBinds -gen_Show_binds :: [RenamedFixityDecl] -> TyCon -> ProtoNameMonoBinds +gen_Read_binds :: FixityEnv -> TyCon -> RdrNameMonoBinds -gen_Read_binds fixities tycon - = reads_prec `AndMonoBinds` read_list +gen_Read_binds get_fixity tycon + = read_prec `AndMonoBinds` default_binds where ----------------------------------------------------------------------- - read_list = mk_easy_FunMonoBind readList_PN [] [] - (HsApp (HsVar _readList_PN) (HsApp (HsVar readsPrec_PN) (HsLit (HsInt 0)))) + default_binds + = mkVarMonoBind loc readList_RDR (HsVar readListDefault_RDR) + `AndMonoBinds` + mkVarMonoBind loc readListPrec_RDR (HsVar readListPrecDefault_RDR) ----------------------------------------------------------------------- - reads_prec - = let - read_con_comprehensions - = map read_con (getTyConDataCons tycon) - in - mk_easy_FunMonoBind readsPrec_PN [a_Pat, b_Pat] [] ( - foldl1 append_Expr read_con_comprehensions - ) + + loc = getSrcLoc tycon + data_cons = tyConDataCons tycon + (nullary_cons, non_nullary_cons) = partition isNullaryDataCon data_cons + + read_prec = mkVarMonoBind loc readPrec_RDR + (HsApp (HsVar parens_RDR) read_cons) + + read_cons = foldr1 mk_alt (read_nullary_cons ++ read_non_nullary_cons) + read_non_nullary_cons = map read_non_nullary_con non_nullary_cons + + read_nullary_cons + = case nullary_cons of + [] -> [] + [con] -> [mkHsDo DoExpr [bindLex (ident_pat (data_con_str con)), + result_stmt con []] loc] + _ -> [HsApp (HsVar choose_RDR) + (ExplicitList placeHolderType (map mk_pair nullary_cons))] + + mk_pair con = ExplicitTuple [HsLit (data_con_str con), + HsApp (HsVar returnM_RDR) (HsVar (getRdrName con))] + Boxed + + read_non_nullary_con data_con + = mkHsApps prec_RDR [mkHsIntLit prec, mkHsDo DoExpr stmts loc] where - read_con data_con -- note: "b" is the string being "read" - = let - data_con_PN = Prel (WiredInVal data_con) - data_con_str= snd (getOrigName data_con) - as_needed = take (getDataConArity data_con) as_PNs - bs_needed = take (getDataConArity data_con) bs_PNs - con_expr = foldl HsApp (HsVar data_con_PN) (map HsVar as_needed) - nullary_con = getDataConArity data_con == 0 - - con_qual - = GeneratorQual - (TuplePatIn [LitPatIn (HsString data_con_str), d_Pat]) - (HsApp (HsVar lex_PN) c_Expr) - - field_quals = snd (mapAccumL mk_qual d_Expr (as_needed `zip` bs_needed)) - - read_paren_arg - = if nullary_con then -- must be False (parens are surely optional) - false_Expr - else -- parens depend on precedence... - OpApp a_Expr (HsVar gt_PN) (HsLit (HsInt 9)) - in - HsApp ( - readParen_Expr read_paren_arg ( - HsLam (mk_easy_Match [c_Pat] [] ( - ListComp (ExplicitTuple [con_expr, - if null bs_needed then d_Expr else HsVar (last bs_needed)]) - (con_qual : field_quals))) - )) (HsVar b_PN) - where - mk_qual draw_from (con_field, str_left) - = (HsVar str_left, -- what to draw from down the line... - GeneratorQual - (TuplePatIn [VarPatIn con_field, VarPatIn str_left]) - (HsApp (HsApp (HsVar readsPrec_PN) (HsLit (HsInt 10))) draw_from)) + stmts | is_infix = infix_stmts + | length labels > 0 = lbl_stmts + | otherwise = prefix_stmts + + prefix_stmts -- T a b c + = [bindLex (ident_pat (data_con_str data_con))] + ++ read_args + ++ [result_stmt data_con as_needed] + + infix_stmts -- a %% b + = [read_a1, + bindLex (symbol_pat (data_con_str data_con)), + read_a2, + result_stmt data_con [a1,a2]] + + lbl_stmts -- T { f1 = a, f2 = b } + = [bindLex (ident_pat (data_con_str data_con)), + read_punc "{"] + ++ concat (intersperse [read_punc ","] field_stmts) + ++ [read_punc "}", result_stmt data_con as_needed] + + field_stmts = zipWithEqual "lbl_stmts" read_field labels as_needed + + con_arity = dataConSourceArity data_con + nullary_con = con_arity == 0 + labels = dataConFieldLabels data_con + lab_fields = length labels + dc_nm = getName data_con + is_infix = isDataSymOcc (getOccName dc_nm) + as_needed = take con_arity as_RDRs + read_args = zipWithEqual "gen_Read_binds" read_arg as_needed (dataConOrigArgTys data_con) + (read_a1:read_a2:_) = read_args + (a1:a2:_) = as_needed + prec = getPrec is_infix get_fixity dc_nm + + ------------------------------------------------------------------------ + -- Helpers + ------------------------------------------------------------------------ + mk_alt e1 e2 = genOpApp e1 alt_RDR e2 + bindLex pat = BindStmt pat (HsVar lexP_RDR) loc + result_stmt c as = ResultStmt (HsApp (HsVar returnM_RDR) (con_app c as)) loc + con_app c as = mkHsVarApps (getRdrName c) as + + punc_pat s = ConPatIn punc_RDR (PrefixCon [LitPat (mkHsString s)]) -- Punc 'c' + ident_pat s = ConPatIn ident_RDR (PrefixCon [LitPat s]) -- Ident "foo" + symbol_pat s = ConPatIn symbol_RDR (PrefixCon [LitPat s]) -- Symbol ">>" + + data_con_str con = mkHsString (occNameUserString (getOccName con)) + + read_punc c = bindLex (punc_pat c) + read_arg a ty + | isUnLiftedType ty = pprPanic "Error in deriving:" (text "Can't read unlifted types yet:" <+> ppr ty) + | otherwise = BindStmt (VarPat a) (mkHsVarApps step_RDR [readPrec_RDR]) loc + + read_field lbl a = read_lbl lbl ++ + [read_punc "=", + BindStmt (VarPat a) (mkHsVarApps reset_RDR [readPrec_RDR]) loc] + + -- When reading field labels we might encounter + -- a = 3 + -- _a = 3 + -- or (#) = 4 + -- Note the parens! + read_lbl lbl | is_id_start (head lbl_str) + = [bindLex (ident_pat lbl_lit)] + | otherwise + = [read_punc "(", + bindLex (symbol_pat lbl_lit), + read_punc ")"] + where + lbl_str = occNameUserString (getOccName (fieldLabelName lbl)) + lbl_lit = mkHsString lbl_str + is_id_start c = isAlpha c || c == '_' +\end{code} + + +%************************************************************************ +%* * +\subsubsection{Generating @Show@ instance declarations} +%* * +%************************************************************************ + +Example + infixr 5 :^: + + data Tree a = Leaf a | Tree a :^: Tree a + + instance (Show a) => Show (Tree a) where + + showsPrec d (Leaf m) = showParen (d > app_prec) showStr + where + showStr = showString "Leaf " . showsPrec (app_prec+1) m + + showsPrec d (u :^: v) = showParen (d > up_prec) showStr + where + showStr = showsPrec (up_prec+1) u . + showString " :^: " . + showsPrec (up_prec+1) v + -- Note: right-associativity of :^: ignored + + up_prec = 5 -- Precedence of :^: + app_prec = 10 -- Application has precedence one more than + -- the most tightly-binding operator + +\begin{code} +gen_Show_binds :: FixityEnv -> TyCon -> RdrNameMonoBinds -gen_Show_binds fixities tycon +gen_Show_binds get_fixity tycon = shows_prec `AndMonoBinds` show_list where + tycon_loc = getSrcLoc tycon ----------------------------------------------------------------------- - show_list = mk_easy_FunMonoBind showList_PN [] [] - (HsApp (HsVar _showList_PN) (HsApp (HsVar showsPrec_PN) (HsLit (HsInt 0)))) + show_list = mkVarMonoBind tycon_loc showList_RDR + (HsApp (HsVar showList___RDR) (HsPar (HsApp (HsVar showsPrec_RDR) (mkHsIntLit 0)))) ----------------------------------------------------------------------- - shows_prec - = mk_FunMonoBind showsPrec_PN (map pats_etc (getTyConDataCons tycon)) + shows_prec = mk_FunMonoBind tycon_loc showsPrec_RDR (map pats_etc (tyConDataCons tycon)) where pats_etc data_con - = let - data_con_PN = Prel (WiredInVal data_con) - bs_needed = take (getDataConArity data_con) bs_PNs - con_pat = ConPatIn data_con_PN (map VarPatIn bs_needed) - nullary_con = getDataConArity data_con == 0 - - show_con - = let (mod, nm) = getOrigName data_con - space_maybe = if nullary_con then _NIL_ else SLIT(" ") - in - HsApp (HsVar showString_PN) (HsLit (HsString (nm _APPEND_ space_maybe))) - - show_thingies = show_con : (spacified real_show_thingies) - - real_show_thingies - = [ HsApp (HsApp (HsVar showsPrec_PN) (HsLit (HsInt 10))) (HsVar b) - | b <- bs_needed ] - in - if nullary_con then -- skip the showParen junk... - ASSERT(null bs_needed) - ([a_Pat, con_pat], show_con) - else - ([a_Pat, con_pat], - showParen_Expr (OpApp a_Expr (HsVar ge_PN) (HsLit (HsInt 10))) - (nested_compose_Expr show_thingies)) - where - spacified [] = [] - spacified [x] = [x] - spacified (x:xs) = (x : (HsVar showSpace_PN) : spacified xs) + | nullary_con = -- skip the showParen junk... + ASSERT(null bs_needed) + ([wildPat, con_pat], mk_showString_app con_str) + | otherwise = + ([a_Pat, con_pat], + showParen_Expr (HsPar (genOpApp a_Expr ge_RDR (HsLit (HsInt con_prec_plus_one)))) + (HsPar (nested_compose_Expr show_thingies))) + where + data_con_RDR = getRdrName data_con + con_arity = dataConSourceArity data_con + bs_needed = take con_arity bs_RDRs + arg_tys = dataConOrigArgTys data_con -- Correspond 1-1 with bs_needed + con_pat = mkConPat data_con_RDR bs_needed + nullary_con = con_arity == 0 + labels = dataConFieldLabels data_con + lab_fields = length labels + record_syntax = lab_fields > 0 + + dc_nm = getName data_con + dc_occ_nm = getOccName data_con + con_str = occNameUserString dc_occ_nm + + show_thingies + | is_infix = [show_arg1, mk_showString_app (" " ++ con_str ++ " "), show_arg2] + | record_syntax = mk_showString_app (con_str ++ " {") : + show_record_args ++ [mk_showString_app "}"] + | otherwise = mk_showString_app (con_str ++ " ") : show_prefix_args + + show_label l = mk_showString_app (the_name ++ " = ") + -- Note the spaces around the "=" sign. If we don't have them + -- then we get Foo { x=-1 } and the "=-" parses as a single + -- lexeme. Only the space after the '=' is necessary, but + -- it seems tidier to have them both sides. + where + occ_nm = getOccName (fieldLabelName l) + nm = occNameUserString occ_nm + is_op = isSymOcc occ_nm -- Legal, but rare. + the_name | is_op = '(':nm ++ ")" + | otherwise = nm + + show_args = zipWith show_arg bs_needed arg_tys + (show_arg1:show_arg2:_) = show_args + show_prefix_args = intersperse (HsVar showSpace_RDR) show_args + + -- Assumption for record syntax: no of fields == no of labelled fields + -- (and in same order) + show_record_args = concat $ + intersperse [mk_showString_app ", "] $ + [ [show_label lbl, arg] + | (lbl,arg) <- zipEqual "gen_Show_binds" + labels show_args ] + + -- Generates (showsPrec p x) for argument x, but it also boxes + -- the argument first if necessary. Note that this prints unboxed + -- things without any '#' decorations; could change that if need be + show_arg b arg_ty = mkHsApps showsPrec_RDR [HsLit (HsInt arg_prec), + box_if_necy "Show" tycon (HsVar b) arg_ty] + + -- Fixity stuff + is_infix = isDataSymOcc dc_occ_nm + con_prec_plus_one = 1 + getPrec is_infix get_fixity dc_nm + arg_prec | record_syntax = 0 -- Record fields don't need parens + | otherwise = con_prec_plus_one + +mk_showString_app str = HsApp (HsVar showString_RDR) (HsLit (mkHsString str)) +\end{code} + +\begin{code} +getPrec :: Bool -> FixityEnv -> Name -> Integer +getPrec is_infix get_fixity nm + | not is_infix = appPrecedence + | otherwise = getPrecedence get_fixity nm + +appPrecedence :: Integer +appPrecedence = fromIntegral maxPrecedence + 1 + -- One more than the precedence of the most + -- tightly-binding operator + +getPrecedence :: FixityEnv -> Name -> Integer +getPrecedence get_fixity nm + = case lookupFixity get_fixity nm of + Fixity x _ -> fromIntegral x + +isLRAssoc :: FixityEnv -> Name -> (Bool, Bool) +isLRAssoc get_fixity nm = + case lookupFixity get_fixity nm of + Fixity _ InfixN -> (False, False) + Fixity _ InfixR -> (False, True) + Fixity _ InfixL -> (True, False) \end{code} + %************************************************************************ %* * -\subsubsection[TcGenDeriv-Binary]{Generating @Binary@ instance declarations} +\subsection{Typeable} %* * %************************************************************************ -ToDo: NOT DONE YET. +From the data type + + data T a b = .... + +we generate + + instance (Typeable a, Typeable b) => Typeable (T a b) where + typeOf _ = mkTypeRep (mkTyConRep "T") + [typeOf (undefined::a), + typeOf (undefined::b)] + +Notice the use of lexically scoped type variables. \begin{code} -gen_Binary_binds :: TyCon -> ProtoNameMonoBinds +gen_Typeable_binds :: TyCon -> RdrNameMonoBinds +gen_Typeable_binds tycon + = mk_easy_FunMonoBind tycon_loc typeOf_RDR [wildPat] [] + (mkHsApps mkTypeRep_RDR [tycon_rep, arg_reps]) + where + tycon_loc = getSrcLoc tycon + tyvars = tyConTyVars tycon + tycon_rep = HsVar mkTyConRep_RDR `HsApp` HsLit (mkHsString (showSDoc (ppr tycon))) + arg_reps = ExplicitList placeHolderType (map mk tyvars) + mk tyvar = HsApp (HsVar typeOf_RDR) + (ExprWithTySig (HsVar undefined_RDR) + (HsTyVar (getRdrName tyvar))) +\end{code} + -gen_Binary_binds tycon - = panic "gen_Binary_binds" + +%************************************************************************ +%* * +\subsection{Data} +%* * +%************************************************************************ + +From the data type + + data T a b = T1 a b | T2 + +we generate + + instance (Data a, Data b) => Data (T a b) where + gfoldl k z (T1 a b) = z T `k` a `k` b + gfoldl k z T2 = z T2 + -- ToDo: add gmapT,Q,M, gfoldr + + gunfold k z (Constr "T1") = k (k (z T1)) + gunfold k z (Constr "T2") = z T2 + + conOf (T1 _ _) = Constr "T1" + conOf T2 = Constr "T2" + + consOf _ = [Constr "T1", Constr "T2"] + +ToDo: generate auxiliary bindings for the Constrs? + +\begin{code} +gen_Data_binds :: TyCon -> RdrNameMonoBinds +gen_Data_binds tycon + = andMonoBindList [gfoldl_bind, gunfold_bind, conOf_bind, consOf_bind] + where + tycon_loc = getSrcLoc tycon + data_cons = tyConDataCons tycon + + ------------ gfoldl + gfoldl_bind = mk_FunMonoBind tycon_loc gfoldl_RDR (map gfoldl_eqn data_cons) + gfoldl_eqn con = ([VarPat k_RDR, VarPat z_RDR, mkConPat con_name as_needed], + foldl mk_k_app (HsVar z_RDR `HsApp` HsVar con_name) as_needed) + where + con_name :: RdrName + con_name = getRdrName con + as_needed = take (dataConSourceArity con) as_RDRs + mk_k_app e v = HsPar (mkHsOpApp e k_RDR (HsVar v)) + + ------------ gunfold + gunfold_bind = mk_FunMonoBind tycon_loc gunfold_RDR (map gunfold_eqn data_cons) + gunfold_eqn con = ([VarPat k_RDR, VarPat z_RDR, + ConPatIn constr_RDR (PrefixCon [LitPat (mk_constr_string con)])], + apN (dataConSourceArity con) + (\e -> HsVar k_RDR `HsApp` e) + (z_Expr `HsApp` HsVar (getRdrName con))) + mk_constr_string con = mkHsString (occNameUserString (getOccName con)) + + ------------ conOf + conOf_bind = mk_FunMonoBind tycon_loc conOf_RDR (map conOf_eqn data_cons) + conOf_eqn con = ([mkWildConPat con], mk_constr con) + + ------------ consOf + consOf_bind = mk_easy_FunMonoBind tycon_loc consOf_RDR [wildPat] [] + (ExplicitList placeHolderType (map mk_constr data_cons)) + mk_constr con = HsVar constr_RDR `HsApp` (HsLit (mk_constr_string con)) + + +apN :: Int -> (a -> a) -> a -> a +apN 0 k z = z +apN n k z = apN (n-1) k (k z) \end{code} %************************************************************************ %* * -\subsection[TcGenDeriv-con2tag-tag2con]{Generating extra binds (@con2tag@ and @tag2con@)} +\subsection{Generating extra binds (@con2tag@ and @tag2con@)} %* * %************************************************************************ @@ -756,7 +1127,7 @@ data Foo ... = ... con2tag_Foo :: Foo ... -> Int# tag2con_Foo :: Int -> Foo ... -- easier if Int, not Int# -maxtag_Foo :: Int -- ditto (NB: not unboxed) +maxtag_Foo :: Int -- ditto (NB: not unlifted) \end{verbatim} The `tags' here start at zero, hence the @fIRST_TAG@ (currently one) @@ -767,45 +1138,60 @@ data TagThingWanted = GenCon2Tag | GenTag2Con | GenMaxTag gen_tag_n_con_monobind - :: (ProtoName, Name, -- (proto)Name for the thing in question + :: (RdrName, -- (proto)Name for the thing in question TyCon, -- tycon in question TagThingWanted) - -> ProtoNameMonoBinds + -> RdrNameMonoBinds -gen_tag_n_con_monobind (pn, _, tycon, GenCon2Tag) - = mk_FunMonoBind pn (map mk_stuff (getTyConDataCons tycon)) - where - mk_stuff :: DataCon -> ([ProtoNamePat], ProtoNameHsExpr) +gen_tag_n_con_monobind (rdr_name, tycon, GenCon2Tag) + | lots_of_constructors + = mk_FunMonoBind loc rdr_name [([], get_tag_rhs)] - mk_stuff var - = ASSERT(isDataCon var) - ([pat], HsLit (HsIntPrim (toInteger ((getDataConTag var) - fIRST_TAG)))) - where - pat = ConPatIn var_PN (nOfThem (getDataConArity var) WildPatIn) - var_PN = Prel (WiredInVal var) + | otherwise + = mk_FunMonoBind loc rdr_name (map mk_stuff (tyConDataCons tycon)) -gen_tag_n_con_monobind (pn, _, tycon, GenTag2Con) - = mk_FunMonoBind pn (map mk_stuff (getTyConDataCons tycon)) where - mk_stuff :: DataCon -> ([ProtoNamePat], ProtoNameHsExpr) - - mk_stuff var - = ASSERT(isDataCon var) - ([lit_pat], HsVar var_PN) - where - lit_pat = ConPatIn mkInt_PN [LitPatIn (HsIntPrim (toInteger ((getDataConTag var) - fIRST_TAG)))] - var_PN = Prel (WiredInVal var) - -gen_tag_n_con_monobind (pn, _, tycon, GenMaxTag) - = mk_easy_FunMonoBind pn [] [] (HsApp (HsVar mkInt_PN) (HsLit (HsIntPrim max_tag))) + loc = getSrcLoc tycon + + -- Give a signature to the bound variable, so + -- that the case expression generated by getTag is + -- monomorphic. In the push-enter model we get better code. + get_tag_rhs = ExprWithTySig + (HsLam (mk_match loc [VarPat a_RDR] + (HsApp getTag_Expr a_Expr) + EmptyBinds)) + (HsForAllTy Nothing [] con2tag_ty) + -- Nothing => implicit quantification + + con2tag_ty = foldl HsAppTy (HsTyVar (getRdrName tycon)) + [HsTyVar (getRdrName tv) | tv <- tyConTyVars tycon] + `HsFunTy` + HsTyVar (getRdrName intPrimTyConName) + + lots_of_constructors = tyConFamilySize tycon > mAX_FAMILY_SIZE_FOR_VEC_RETURNS + + mk_stuff :: DataCon -> ([RdrNamePat], RdrNameHsExpr) + mk_stuff con = ([mkWildConPat con], + HsLit (HsIntPrim (toInteger ((dataConTag con) - fIRST_TAG)))) + +gen_tag_n_con_monobind (rdr_name, tycon, GenTag2Con) + = mk_FunMonoBind (getSrcLoc tycon) rdr_name + [([mkConPat mkInt_RDR [a_RDR]], + ExprWithTySig (HsApp tagToEnum_Expr a_Expr) + (HsTyVar (getRdrName tycon)))] + +gen_tag_n_con_monobind (rdr_name, tycon, GenMaxTag) + = mkVarMonoBind (getSrcLoc tycon) rdr_name + (HsApp (HsVar mkInt_RDR) (HsLit (HsIntPrim max_tag))) where - max_tag = case (getTyConDataCons tycon) of + max_tag = case (tyConDataCons tycon) of data_cons -> toInteger ((length data_cons) - fIRST_TAG) + \end{code} %************************************************************************ %* * -\subsection[TcGenDeriv-bind-utils]{Utility bits for generating bindings} +\subsection{Utility bits for generating bindings} %* * %************************************************************************ @@ -824,291 +1210,310 @@ multi-clause definitions; it generates: \end{verbatim} \begin{code} -mk_easy_FunMonoBind :: ProtoName -> [ProtoNamePat] - -> [ProtoNameMonoBinds] -> ProtoNameHsExpr - -> ProtoNameMonoBinds +mkVarMonoBind :: SrcLoc -> RdrName -> RdrNameHsExpr -> RdrNameMonoBinds +mkVarMonoBind loc var rhs = mk_easy_FunMonoBind loc var [] [] rhs -mk_easy_FunMonoBind fun pats binds expr - = FunMonoBind fun [mk_easy_Match pats binds expr] mkGeneratedSrcLoc +mk_easy_FunMonoBind :: SrcLoc -> RdrName -> [RdrNamePat] + -> [RdrNameMonoBinds] -> RdrNameHsExpr + -> RdrNameMonoBinds -mk_easy_Match pats binds expr - = foldr PatMatch - (GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS expr mkGeneratedSrcLoc] (mkbind binds))) - pats - where - mkbind [] = EmptyBinds - mkbind bs = SingleBind (RecBind (foldr1 AndMonoBinds bs)) +mk_easy_FunMonoBind loc fun pats binds expr + = FunMonoBind fun False{-not infix-} [mk_easy_Match loc pats binds expr] loc + +mk_easy_Match loc pats binds expr + = mk_match loc pats expr (mkMonoBind Recursive (andMonoBindList binds)) -- The renamer expects everything in its input to be a -- "recursive" MonoBinds, and it is its job to sort things out -- from there. -mk_FunMonoBind :: ProtoName - -> [([ProtoNamePat], ProtoNameHsExpr)] - -> ProtoNameMonoBinds +mk_FunMonoBind :: SrcLoc -> RdrName + -> [([RdrNamePat], RdrNameHsExpr)] + -> RdrNameMonoBinds -mk_FunMonoBind fun [] = panic "TcGenDeriv:mk_FunMonoBind" -mk_FunMonoBind fun pats_and_exprs - = FunMonoBind fun (map mk_match pats_and_exprs) mkGeneratedSrcLoc +mk_FunMonoBind loc fun [] = panic "TcGenDeriv:mk_FunMonoBind" +mk_FunMonoBind loc fun pats_and_exprs + = FunMonoBind fun False{-not infix-} + [ mk_match loc p e EmptyBinds | (p,e) <-pats_and_exprs ] + loc + +mk_match loc pats expr binds + = Match (map paren pats) Nothing + (GRHSs (unguardedRHS expr loc) binds placeHolderType) where - mk_match (pats, expr) - = foldr PatMatch - (GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS expr mkGeneratedSrcLoc] EmptyBinds)) - pats + paren p@(VarPat _) = p + paren other_p = ParPat other_p \end{code} \begin{code} -compare_Case, cmp_eq_Expr :: - ProtoNameHsExpr -> ProtoNameHsExpr -> ProtoNameHsExpr - -> ProtoNameHsExpr -> ProtoNameHsExpr - -> ProtoNameHsExpr +mkHsApps f xs = foldl HsApp (HsVar f) xs +mkHsVarApps f xs = foldl HsApp (HsVar f) (map HsVar xs) + +mkHsIntLit n = HsLit (HsInt n) +mkHsString s = HsString (mkFastString s) +mkHsChar c = HsChar (ord c) + +mkConPat con vars = ConPatIn con (PrefixCon (map VarPat vars)) +mkNullaryConPat con = ConPatIn con (PrefixCon []) +mkWildConPat con = ConPatIn (getRdrName con) (PrefixCon (nOfThem (dataConSourceArity con) wildPat)) +\end{code} + +ToDo: Better SrcLocs. + +\begin{code} compare_gen_Case :: - ProtoName - -> ProtoNameHsExpr -> ProtoNameHsExpr -> ProtoNameHsExpr - -> ProtoNameHsExpr -> ProtoNameHsExpr - -> ProtoNameHsExpr + RdrNameHsExpr -- What to do for equality + -> RdrNameHsExpr -> RdrNameHsExpr + -> RdrNameHsExpr careful_compare_Case :: -- checks for primitive types... - Type - -> ProtoNameHsExpr -> ProtoNameHsExpr -> ProtoNameHsExpr - -> ProtoNameHsExpr -> ProtoNameHsExpr - -> ProtoNameHsExpr - -compare_Case = compare_gen_Case compare_PN -cmp_eq_Expr = compare_gen_Case cmp_eq_PN - -compare_gen_Case fun lt eq gt a b - = HsCase (HsApp (HsApp (HsVar fun) a) b) {-of-} - [PatMatch (ConPatIn ltTag_PN []) - (GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS lt mkGeneratedSrcLoc] EmptyBinds)), - - PatMatch (ConPatIn eqTag_PN []) - (GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS eq mkGeneratedSrcLoc] EmptyBinds)), - - PatMatch (ConPatIn gtTag_PN []) - (GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS gt mkGeneratedSrcLoc] EmptyBinds))] - mkGeneratedSrcLoc - -careful_compare_Case ty lt eq gt a b - = if not (isPrimType ty) then - compare_gen_Case compare_PN lt eq gt a b - - else -- we have to do something special for primitive things... - HsIf (OpApp a (HsVar relevant_eq_op) b) - eq - (HsIf (OpApp a (HsVar relevant_lt_op) b) lt gt mkGeneratedSrcLoc) - mkGeneratedSrcLoc + TyCon -- The tycon we are deriving for + -> Type + -> RdrNameHsExpr -- What to do for equality + -> RdrNameHsExpr -> RdrNameHsExpr + -> RdrNameHsExpr + +cmp_eq_Expr a b = HsApp (HsApp (HsVar cmp_eq_RDR) a) b + -- Was: compare_gen_Case cmp_eq_RDR + +compare_gen_Case (HsVar eq_tag) a b | eq_tag == eqTag_RDR + = HsApp (HsApp (HsVar compare_RDR) a) b -- Simple case +compare_gen_Case eq a b -- General case + = HsCase (HsPar (HsApp (HsApp (HsVar compare_RDR) a) b)) {-of-} + [mkSimpleMatch [mkNullaryConPat ltTag_RDR] ltTag_Expr placeHolderType generatedSrcLoc, + mkSimpleMatch [mkNullaryConPat eqTag_RDR] eq placeHolderType generatedSrcLoc, + mkSimpleMatch [mkNullaryConPat gtTag_RDR] gtTag_Expr placeHolderType generatedSrcLoc] + generatedSrcLoc + +careful_compare_Case tycon ty eq a b + | not (isUnLiftedType ty) + = compare_gen_Case eq a b + | otherwise -- We have to do something special for primitive things... + = HsIf (genOpApp a relevant_eq_op b) + eq + (HsIf (genOpApp a relevant_lt_op b) ltTag_Expr gtTag_Expr generatedSrcLoc) + generatedSrcLoc where - relevant_eq_op = assoc_ty_id eq_op_tbl ty - relevant_lt_op = assoc_ty_id lt_op_tbl ty - -assoc_ty_id tyids ty - = if null res then panic "assoc_ty" - else head res + relevant_eq_op = assoc_ty_id "Ord" tycon eq_op_tbl ty + relevant_lt_op = assoc_ty_id "Ord" tycon lt_op_tbl ty + + +box_if_necy :: String -- The class involved + -> TyCon -- The tycon involved + -> RdrNameHsExpr -- The argument + -> Type -- The argument type + -> RdrNameHsExpr -- Boxed version of the arg +box_if_necy cls_str tycon arg arg_ty + | isUnLiftedType arg_ty = HsApp (HsVar box_con) arg + | otherwise = arg where - res = [id | (ty',id) <- tyids, eqTy ty ty'] - -eq_op_tbl = [ - (charPrimTy, Prel (WiredInVal (primOpId CharEqOp))), - (intPrimTy, Prel (WiredInVal (primOpId IntEqOp))), - (wordPrimTy, Prel (WiredInVal (primOpId WordEqOp))), - (addrPrimTy, Prel (WiredInVal (primOpId AddrEqOp))), - (floatPrimTy, Prel (WiredInVal (primOpId FloatEqOp))), - (doublePrimTy, Prel (WiredInVal (primOpId DoubleEqOp))) ] - -lt_op_tbl = [ - (charPrimTy, Prel (WiredInVal (primOpId CharLtOp))), - (intPrimTy, Prel (WiredInVal (primOpId IntLtOp))), - (wordPrimTy, Prel (WiredInVal (primOpId WordLtOp))), - (addrPrimTy, Prel (WiredInVal (primOpId AddrLtOp))), - (floatPrimTy, Prel (WiredInVal (primOpId FloatLtOp))), - (doublePrimTy, Prel (WiredInVal (primOpId DoubleLtOp))) ] + box_con = assoc_ty_id cls_str tycon box_con_tbl arg_ty + +assoc_ty_id :: String -- The class involved + -> TyCon -- The tycon involved + -> [(Type,a)] -- The table + -> Type -- The type + -> a -- The result of the lookup +assoc_ty_id cls_str tycon tbl ty + | null res = pprPanic "Error in deriving:" (text "Can't derive" <+> text cls_str <+> + text "for primitive type" <+> ppr ty) + | otherwise = head res + where + res = [id | (ty',id) <- tbl, ty `tcEqType` ty'] + +eq_op_tbl = + [(charPrimTy, eqChar_RDR) + ,(intPrimTy, eqInt_RDR) + ,(wordPrimTy, eqWord_RDR) + ,(addrPrimTy, eqAddr_RDR) + ,(floatPrimTy, eqFloat_RDR) + ,(doublePrimTy, eqDouble_RDR) + ] + +lt_op_tbl = + [(charPrimTy, ltChar_RDR) + ,(intPrimTy, ltInt_RDR) + ,(wordPrimTy, ltWord_RDR) + ,(addrPrimTy, ltAddr_RDR) + ,(floatPrimTy, ltFloat_RDR) + ,(doublePrimTy, ltDouble_RDR) + ] + +box_con_tbl = + [(charPrimTy, getRdrName charDataCon) + ,(intPrimTy, getRdrName intDataCon) + ,(wordPrimTy, getRdrName wordDataCon) + ,(addrPrimTy, addrDataCon_RDR) + ,(floatPrimTy, getRdrName floatDataCon) + ,(doublePrimTy, getRdrName doubleDataCon) + ] ----------------------------------------------------------------------- -and_Expr, append_Expr :: ProtoNameHsExpr -> ProtoNameHsExpr -> ProtoNameHsExpr +and_Expr, append_Expr :: RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr -and_Expr a b = OpApp a (HsVar and_PN) b -append_Expr a b = OpApp a (HsVar append_PN) b +and_Expr a b = genOpApp a and_RDR b +append_Expr a b = genOpApp a append_RDR b ----------------------------------------------------------------------- -eq_Expr :: Type -> ProtoNameHsExpr -> ProtoNameHsExpr -> ProtoNameHsExpr -eq_Expr ty a b - = if not (isPrimType ty) then - OpApp a (HsVar eq_PN) b - else -- we have to do something special for primitive things... - OpApp a (HsVar relevant_eq_op) b - where - relevant_eq_op = assoc_ty_id eq_op_tbl ty +eq_Expr :: TyCon -> Type -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr +eq_Expr tycon ty a b = genOpApp a eq_op b + where + eq_op + | not (isUnLiftedType ty) = eq_RDR + | otherwise = + -- we have to do something special for primitive things... + assoc_ty_id "Eq" tycon eq_op_tbl ty + \end{code} \begin{code} -untag_Expr :: TyCon -> [(ProtoName, ProtoName)] -> ProtoNameHsExpr -> ProtoNameHsExpr +untag_Expr :: TyCon -> [(RdrName, RdrName)] -> RdrNameHsExpr -> RdrNameHsExpr untag_Expr tycon [] expr = expr untag_Expr tycon ((untag_this, put_tag_here) : more) expr - = HsCase (HsApp (con2tag_Expr tycon) (HsVar untag_this)) {-of-} - [PatMatch (VarPatIn put_tag_here) - (GRHSMatch (GRHSsAndBindsIn grhs EmptyBinds))] - mkGeneratedSrcLoc - where - grhs = [OtherwiseGRHS (untag_Expr tycon more expr) mkGeneratedSrcLoc] + = HsCase (HsPar (HsApp (con2tag_Expr tycon) (HsVar untag_this))) {-of-} + [mkSimpleMatch [VarPat put_tag_here] (untag_Expr tycon more expr) placeHolderType generatedSrcLoc] + generatedSrcLoc -cmp_tags_Expr :: ProtoName -- Comparison op - -> ProtoName -> ProtoName -- Things to compare - -> ProtoNameHsExpr -- What to return if true - -> ProtoNameHsExpr -- What to return if false - -> ProtoNameHsExpr +cmp_tags_Expr :: RdrName -- Comparison op + -> RdrName -> RdrName -- Things to compare + -> RdrNameHsExpr -- What to return if true + -> RdrNameHsExpr -- What to return if false + -> RdrNameHsExpr cmp_tags_Expr op a b true_case false_case - = HsIf (OpApp (HsVar a) (HsVar op) (HsVar b)) true_case false_case mkGeneratedSrcLoc + = HsIf (genOpApp (HsVar a) op (HsVar b)) true_case false_case generatedSrcLoc enum_from_to_Expr - :: ProtoNameHsExpr -> ProtoNameHsExpr - -> ProtoNameHsExpr + :: RdrNameHsExpr -> RdrNameHsExpr + -> RdrNameHsExpr enum_from_then_to_Expr - :: ProtoNameHsExpr -> ProtoNameHsExpr -> ProtoNameHsExpr - -> ProtoNameHsExpr + :: RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr + -> RdrNameHsExpr -enum_from_to_Expr f t2 = HsApp (HsApp (HsVar enumFromTo_PN) f) t2 -enum_from_then_to_Expr f t t2 = HsApp (HsApp (HsApp (HsVar enumFromThenTo_PN) f) t) t2 +enum_from_to_Expr f t2 = HsApp (HsApp (HsVar enumFromTo_RDR) f) t2 +enum_from_then_to_Expr f t t2 = HsApp (HsApp (HsApp (HsVar enumFromThenTo_RDR) f) t) t2 -showParen_Expr, readParen_Expr - :: ProtoNameHsExpr -> ProtoNameHsExpr - -> ProtoNameHsExpr +showParen_Expr + :: RdrNameHsExpr -> RdrNameHsExpr + -> RdrNameHsExpr -showParen_Expr e1 e2 = HsApp (HsApp (HsVar showParen_PN) e1) e2 -readParen_Expr e1 e2 = HsApp (HsApp (HsVar readParen_PN) e1) e2 +showParen_Expr e1 e2 = HsApp (HsApp (HsVar showParen_RDR) e1) e2 -nested_compose_Expr :: [ProtoNameHsExpr] -> ProtoNameHsExpr +nested_compose_Expr :: [RdrNameHsExpr] -> RdrNameHsExpr -nested_compose_Expr [e] = e +nested_compose_Expr [e] = parenify e nested_compose_Expr (e:es) - = HsApp (HsApp (HsVar compose_PN) e) (nested_compose_Expr es) + = HsApp (HsApp (HsVar compose_RDR) (parenify e)) (nested_compose_Expr es) + +-- impossible_Expr is used in case RHSs that should never happen. +-- We generate these to keep the desugarer from complaining that they *might* happen! +impossible_Expr = HsApp (HsVar error_RDR) (HsLit (HsString (mkFastString "Urk! in TcGenDeriv"))) + +-- illegal_Expr is used when signalling error conditions in the RHS of a derived +-- method. It is currently only used by Enum.{succ,pred} +illegal_Expr meth tp msg = + HsApp (HsVar error_RDR) (HsLit (HsString (mkFastString (meth ++ '{':tp ++ "}: " ++ msg)))) + +-- illegal_toEnum_tag is an extended version of illegal_Expr, which also allows you +-- to include the value of a_RDR in the error string. +illegal_toEnum_tag tp maxtag = + HsApp (HsVar error_RDR) + (HsApp (HsApp (HsVar append_RDR) + (HsLit (HsString (mkFastString ("toEnum{" ++ tp ++ "}: tag ("))))) + (HsApp (HsApp (HsApp + (HsVar showsPrec_RDR) + (mkHsIntLit 0)) + (HsVar a_RDR)) + (HsApp (HsApp + (HsVar append_RDR) + (HsLit (HsString (mkFastString ") is outside of enumeration's range (0,")))) + (HsApp (HsApp (HsApp + (HsVar showsPrec_RDR) + (mkHsIntLit 0)) + (HsVar maxtag)) + (HsLit (HsString (mkFastString ")"))))))) + +parenify e@(HsVar _) = e +parenify e = HsPar e + +-- genOpApp wraps brackets round the operator application, so that the +-- renamer won't subsequently try to re-associate it. +-- For some reason the renamer doesn't reassociate it right, and I can't +-- be bothered to find out why just now. + +genOpApp e1 op e2 = mkHsOpApp e1 op e2 \end{code} \begin{code} -a_PN = Unk SLIT("a") -b_PN = Unk SLIT("b") -c_PN = Unk SLIT("c") -d_PN = Unk SLIT("d") -ah_PN = Unk SLIT("a#") -bh_PN = Unk SLIT("b#") -ch_PN = Unk SLIT("c#") -dh_PN = Unk SLIT("d#") -cmp_eq_PN = Unk SLIT("cmp_eq") -rangeSize_PN = Unk SLIT("rangeSize") - -as_PNs = [ Unk (_PK_ ("a"++show i)) | i <- [(1::Int) .. ] ] -bs_PNs = [ Unk (_PK_ ("b"++show i)) | i <- [(1::Int) .. ] ] -cs_PNs = [ Unk (_PK_ ("c"++show i)) | i <- [(1::Int) .. ] ] - -eq_PN = prelude_method SLIT("Eq") SLIT("==") -ne_PN = prelude_method SLIT("Eq") SLIT("/=") -le_PN = prelude_method SLIT("Ord") SLIT("<=") -lt_PN = prelude_method SLIT("Ord") SLIT("<") -ge_PN = prelude_method SLIT("Ord") SLIT(">=") -gt_PN = prelude_method SLIT("Ord") SLIT(">") -max_PN = prelude_method SLIT("Ord") SLIT("max") -min_PN = prelude_method SLIT("Ord") SLIT("min") -compare_PN = prelude_method SLIT("Ord") SLIT("compare") -ltTag_PN = Prel (WiredInVal ltDataCon) -eqTag_PN = Prel (WiredInVal eqDataCon) -gtTag_PN = Prel (WiredInVal gtDataCon) -enumFrom_PN = prelude_method SLIT("Enum") SLIT("enumFrom") -enumFromTo_PN = prelude_method SLIT("Enum") SLIT("enumFromTo") -enumFromThen_PN = prelude_method SLIT("Enum") SLIT("enumFromThen") -enumFromThenTo_PN= prelude_method SLIT("Enum") SLIT("enumFromThenTo") -range_PN = prelude_method SLIT("Ix") SLIT("range") -index_PN = prelude_method SLIT("Ix") SLIT("index") -inRange_PN = prelude_method SLIT("Ix") SLIT("inRange") -readsPrec_PN = prelude_method SLIT("Read") SLIT("readsPrec") -readList_PN = prelude_method SLIT("Read") SLIT("readList") -showsPrec_PN = prelude_method SLIT("Show") SLIT("showsPrec") -showList_PN = prelude_method SLIT("Show") SLIT("showList") -plus_PN = prelude_method SLIT("Num") SLIT("+") -times_PN = prelude_method SLIT("Num") SLIT("*") - -false_PN = Prel (WiredInVal falseDataCon) -true_PN = Prel (WiredInVal trueDataCon) -eqH_PN = Prel (WiredInVal (primOpId IntEqOp)) -geH_PN = Prel (WiredInVal (primOpId IntGeOp)) -leH_PN = Prel (WiredInVal (primOpId IntLeOp)) -ltH_PN = Prel (WiredInVal (primOpId IntLtOp)) -minusH_PN = Prel (WiredInVal (primOpId IntSubOp)) -and_PN = prelude_val pRELUDE SLIT("&&") -not_PN = prelude_val pRELUDE SLIT("not") -append_PN = prelude_val pRELUDE_LIST SLIT("++") -map_PN = prelude_val pRELUDE_LIST SLIT("map") -compose_PN = prelude_val pRELUDE SLIT(".") -mkInt_PN = Prel (WiredInVal intDataCon) -error_PN = Prel (WiredInVal eRROR_ID) -showSpace_PN = prelude_val pRELUDE_TEXT SLIT("showSpace__") -- not quite std -showString_PN = prelude_val pRELUDE_TEXT SLIT("showString") -showParen_PN = prelude_val pRELUDE_TEXT SLIT("showParen") -readParen_PN = prelude_val pRELUDE_TEXT SLIT("readParen") -lex_PN = prelude_val pRELUDE_TEXT SLIT("lex") -_showList_PN = prelude_val pRELUDE_CORE SLIT("_showList") -_readList_PN = prelude_val pRELUDE_CORE SLIT("_readList") - -prelude_val m s = Imp m s [m] s -prelude_method c o = Imp pRELUDE_CORE o [pRELUDE_CORE] o -- class not used... - -a_Expr = HsVar a_PN -b_Expr = HsVar b_PN -c_Expr = HsVar c_PN -d_Expr = HsVar d_PN -ltTag_Expr = HsVar ltTag_PN -eqTag_Expr = HsVar eqTag_PN -gtTag_Expr = HsVar gtTag_PN -false_Expr = HsVar false_PN -true_Expr = HsVar true_PN - -con2tag_Expr tycon = HsVar (con2tag_PN tycon) - -a_Pat = VarPatIn a_PN -b_Pat = VarPatIn b_PN -c_Pat = VarPatIn c_PN -d_Pat = VarPatIn d_PN - - -con2tag_PN, tag2con_PN, maxtag_PN :: TyCon -> ProtoName - -con2tag_PN tycon - = let (mod, nm) = getOrigName tycon - con2tag = SLIT("con2tag_") _APPEND_ nm _APPEND_ SLIT("#") - in - Imp mod con2tag [mod] con2tag - -tag2con_PN tycon - = let (mod, nm) = getOrigName tycon - tag2con = SLIT("tag2con_") _APPEND_ nm _APPEND_ SLIT("#") - in - Imp mod tag2con [mod] tag2con - -maxtag_PN tycon - = let (mod, nm) = getOrigName tycon - maxtag = SLIT("maxtag_") _APPEND_ nm _APPEND_ SLIT("#") - in - Imp mod maxtag [mod] maxtag - - -con2tag_FN, tag2con_FN, maxtag_FN :: TyCon -> FullName - -tag2con_FN tycon - = let (mod, nm) = getOrigName tycon - tag2con = SLIT("tag2con_") _APPEND_ nm _APPEND_ SLIT("#") - in - mkFullName mod tag2con InventedInThisModule NotExported mkGeneratedSrcLoc - -maxtag_FN tycon - = let (mod, nm) = getOrigName tycon - maxtag = SLIT("maxtag_") _APPEND_ nm _APPEND_ SLIT("#") - in - mkFullName mod maxtag InventedInThisModule NotExported mkGeneratedSrcLoc +varUnqual n = mkUnqual OccName.varName n + +zz_a_RDR = varUnqual FSLIT("_a") +a_RDR = varUnqual FSLIT("a") +b_RDR = varUnqual FSLIT("b") +c_RDR = varUnqual FSLIT("c") +d_RDR = varUnqual FSLIT("d") +e_RDR = varUnqual FSLIT("e") +k_RDR = varUnqual FSLIT("k") +z_RDR = varUnqual FSLIT("z") :: RdrName +ah_RDR = varUnqual FSLIT("a#") +bh_RDR = varUnqual FSLIT("b#") +ch_RDR = varUnqual FSLIT("c#") +dh_RDR = varUnqual FSLIT("d#") +cmp_eq_RDR = varUnqual FSLIT("cmp_eq") +rangeSize_RDR = varUnqual FSLIT("rangeSize") + +as_RDRs = [ varUnqual (mkFastString ("a"++show i)) | i <- [(1::Int) .. ] ] +bs_RDRs = [ varUnqual (mkFastString ("b"++show i)) | i <- [(1::Int) .. ] ] +cs_RDRs = [ varUnqual (mkFastString ("c"++show i)) | i <- [(1::Int) .. ] ] + +zz_a_Expr = HsVar zz_a_RDR +a_Expr = HsVar a_RDR +b_Expr = HsVar b_RDR +c_Expr = HsVar c_RDR +d_Expr = HsVar d_RDR +z_Expr = HsVar z_RDR +ltTag_Expr = HsVar ltTag_RDR +eqTag_Expr = HsVar eqTag_RDR +gtTag_Expr = HsVar gtTag_RDR +false_Expr = HsVar false_RDR +true_Expr = HsVar true_RDR + +getTag_Expr = HsVar getTag_RDR +tagToEnum_Expr = HsVar tagToEnum_RDR +con2tag_Expr tycon = HsVar (con2tag_RDR tycon) + +wildPat = WildPat placeHolderType +zz_a_Pat = VarPat zz_a_RDR +a_Pat = VarPat a_RDR +b_Pat = VarPat b_RDR +c_Pat = VarPat c_RDR +d_Pat = VarPat d_RDR + +con2tag_RDR, tag2con_RDR, maxtag_RDR :: TyCon -> RdrName + +con2tag_RDR tycon = varUnqual (mkFastString ("con2tag_" ++ occNameString (getOccName tycon) ++ "#")) +tag2con_RDR tycon = varUnqual (mkFastString ("tag2con_" ++ occNameString (getOccName tycon) ++ "#")) +maxtag_RDR tycon = varUnqual (mkFastString ("maxtag_" ++ occNameString (getOccName tycon) ++ "#")) +\end{code} -con2tag_FN tycon - = let (mod, nm) = getOrigName tycon - con2tag = SLIT("con2tag_") _APPEND_ nm _APPEND_ SLIT("#") - in - mkFullName mod con2tag InventedInThisModule NotExported mkGeneratedSrcLoc +RdrNames for PrimOps. Can't be done in PrelNames, because PrimOp imports +PrelNames, so PrelNames can't import PrimOp. +\begin{code} +minusInt_RDR = nameRdrName minusIntName +eqInt_RDR = nameRdrName eqIntName +ltInt_RDR = nameRdrName ltIntName +geInt_RDR = nameRdrName geIntName +leInt_RDR = nameRdrName leIntName +eqChar_RDR = nameRdrName eqCharName +eqWord_RDR = nameRdrName eqWordName +eqAddr_RDR = nameRdrName eqAddrName +eqFloat_RDR = nameRdrName eqFloatName +eqDouble_RDR = nameRdrName eqDoubleName +ltChar_RDR = nameRdrName ltCharName +ltWord_RDR = nameRdrName ltWordName +ltAddr_RDR = nameRdrName ltAddrName +ltFloat_RDR = nameRdrName ltFloatName +ltDouble_RDR = nameRdrName ltDoubleName +tagToEnum_RDR = nameRdrName tagToEnumName \end{code}