%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1995
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
\section[TcGenDeriv]{Generating derived instance declarations}
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}
%* *
%************************************************************************
(==) (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
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}
%* *
%************************************************************************
We do all the other @Ord@ methods with calls to @compare@:
\begin{verbatim}
instance ... (Ord <wurble> <wurble>) 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}
\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
}
\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
\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}
%* *
%************************************************************************
\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...
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}
%* *
%************************************************************************
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}
(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@)}
%* *
%************************************************************************
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)
= 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}
%* *
%************************************************************************
\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}