%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1995
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
%
\section[TcGenDeriv]{Generating derived instance declarations}
d_PN,
d_Pat,
dh_PN,
- eqH_PN,
- eq_TAG_Expr,
- eq_TAG_PN,
+ eqH_Int_PN,
+ eqTag_Expr,
+ eq_PN,
error_PN,
false_Expr,
false_PN,
geH_PN,
- gen_Binary_binds,
+ gen_Bounded_binds,
gen_Enum_binds,
+ gen_Eval_binds,
gen_Eq_binds,
gen_Ix_binds,
gen_Ord_binds,
- gen_Text_binds,
+ gen_Read_binds,
+ gen_Show_binds,
gen_tag_n_con_monobind,
- gt_TAG_Expr,
- gt_TAG_PN,
+ gtTag_Expr,
+ gt_PN,
leH_PN,
- ltH_PN,
- lt_TAG_Expr,
- lt_TAG_PN,
+ ltH_Int_PN,
+ ltTag_Expr,
+ lt_PN,
minusH_PN,
mkInt_PN,
rangeSize_PN,
true_Expr,
- true_PN
- ) where
+ true_PN,
-IMPORT_Trace -- ToDo:rm debugging
-import Outputable
-import Pretty
+ con2tag_PN, tag2con_PN, maxtag_PN,
-import AbsSyn -- the stuff being typechecked
+ TagThingWanted(..)
+ ) where
-import AbsPrel {-( trueDataCon, falseDataCon, intDataCon, eRROR_ID,
- ltPrimDataCon, eqPrimDataCon, gtPrimDataCon,
- charPrimTy, intPrimTy, wordPrimTy, addrPrimTy,
- floatPrimTy, doublePrimTy
- )-}
-import PrimOps -- *********** ditto
-
-import AbsUniType ( getTyConDataCons, isEnumerationTyCon,
- maybeSingleConstructorTyCon, --UNUSED: preludeClassDerivedFor,
- -- UNUSED: isEnumerationTyConMostly,
- isPrimType, UniType,
- TauType(..), TyVarTemplate, ThetaType(..)
- IF_ATTACK_PRAGMAS(COMMA cmpUniType)
- )
-import Id ( getDataConArity, getDataConTag,
- getDataConSig, isNullaryDataCon, fIRST_TAG,
- isDataCon, DataCon(..), ConTag(..), Id
- )
-import Maybes ( maybeToBool, Maybe(..) )
-import Name ( Name(..) )
-import ProtoName ( ProtoName(..) )
-import RenameAuxFuns -- why not? take all of it...
-import RenameMonad4 -- initRn4, etc.
+IMP_Ubiq()
+IMPORT_1_3(List(partition))
+
+import HsSyn ( HsBinds(..), Bind(..), MonoBinds(..), Match(..), GRHSsAndBinds(..),
+ GRHS(..), HsExpr(..), HsLit(..), InPat(..), Qualifier(..), Stmt,
+ ArithSeqInfo, Sig, PolyType, FixityDecl, Fake )
+import RdrHsSyn ( SYN_IE(RdrNameMonoBinds), SYN_IE(RdrNameHsExpr), SYN_IE(RdrNamePat) )
+import RnHsSyn ( RenamedFixityDecl(..) )
+--import RnUtils
+
+import Id ( GenId, dataConNumFields, isNullaryDataCon, dataConTag,
+ dataConRawArgTys, fIRST_TAG,
+ isDataCon, SYN_IE(DataCon), SYN_IE(ConTag) )
+import IdUtils ( primOpId )
+import Maybes ( maybeToBool )
+import Name ( origName, preludeQual, nameOf, RdrName(..), OrigName(..) )
+import PrelMods ( pRELUDE, gHC__, iX )
+import PrelVals ( eRROR_ID )
+
+import PrimOp ( PrimOp(..) )
import SrcLoc ( mkGeneratedSrcLoc )
-import TcDeriv ( con2tag_PN, tag2con_PN, maxtag_PN,
- TagThingWanted(..), DerivEqn(..)
+import TyCon ( TyCon, tyConDataCons, isEnumerationTyCon, maybeTyConSingleCon )
+import Type ( eqTy, isPrimType )
+import TysPrim ( charPrimTy, intPrimTy, wordPrimTy, addrPrimTy,
+ floatPrimTy, doublePrimTy
)
-import Unique -- some ClassKey stuff
-import Util
+import TysWiredIn ( falseDataCon, trueDataCon, intDataCon )
+--import Unique
+import Util ( mapAccumL, zipEqual, zipWith3Equal, nOfThem, panic, assertPanic )
\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}
%* *
%************************************************************************
tycon, we generate:
\begin{verbatim}
instance ... Eq (Foo ...) where
- (==) a b = case (tagCmp a b) of { _LT -> False; _EQ -> True ; _GT -> False}
- (/=) a b = case (tagCmp a b) of { _LT -> True ; _EQ -> False; _GT -> True }
+ (==) a b = case (compare a b) of { _LT -> False; _EQ -> True ; _GT -> False}
+ (/=) a b = case (compare a b) of { _LT -> True ; _EQ -> False; _GT -> True }
\begin{verbatim}
However, that requires that \tr{Ord <whatever>} was put in the context
for the instance decl, which it probably wasn't, so the decls
\end{itemize}
\begin{code}
-gen_Eq_binds :: TyCon -> ProtoNameMonoBinds
+gen_Eq_binds :: TyCon -> RdrNameMonoBinds
gen_Eq_binds tycon
- = case (partition isNullaryDataCon (getTyConDataCons tycon))
- of { (nullary_cons, nonnullary_cons) ->
- let
+ = let
+ (nullary_cons, nonnullary_cons)
+ = partition isNullaryDataCon (tyConDataCons tycon)
+
rest
- = if null nullary_cons then
- case maybeSingleConstructorTyCon tycon of
+ = if (null nullary_cons) then
+ case maybeTyConSingleCon tycon of
Just _ -> []
Nothing -> -- if cons don't match, then False
[([a_Pat, b_Pat], false_Expr)]
else -- calc. and compare the tags
- [([a_Pat, b_Pat],
+ [([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))]
+ (cmp_tags_Expr eqH_Int_PN ah_PN bh_PN true_Expr false_Expr))]
in
mk_FunMonoBind eq_PN ((map pats_etc nonnullary_cons) ++ rest)
`AndMonoBinds` boring_ne_method
- }
- where
+ 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
- in
+ data_con_PN = qual_orig_name data_con
+ con_arity = length tys_needed
+ as_needed = take con_arity as_PNs
+ bs_needed = take con_arity bs_PNs
+ tys_needed = dataConRawArgTys 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 (Var a) (Var 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 (Var a) (Var b)) rest_expr
+ nested_eq_expr [] [] [] = true_Expr
+ nested_eq_expr tys as bs
+ = foldr1 and_Expr (zipWith3Equal "nested_eq" nested_eq tys as bs)
+ where
+ nested_eq ty a b = HsPar (eq_Expr ty (HsVar a) (HsVar b))
boring_ne_method
- = mk_easy_FunMonoBind ne_PN [a_Pat, b_Pat] [] (
- App (Var not_PN) (App (App (Var eq_PN) a_Expr) b_Expr)
- )
+ = mk_easy_FunMonoBind ne_PN [a_Pat, b_Pat] [] $
+ HsApp (HsVar not_PN) (HsPar (mk_easy_App eq_PN [a_PN, b_PN]))
\end{code}
%************************************************************************
%* *
-\subsubsection[TcGenDeriv-Ord]{Generating @Ord@ instance declarations}
+\subsubsection{Generating @Ord@ instance declarations}
%* *
%************************************************************************
-For a derived @Ord@, we concentrate our attentions on the non-standard
-@_tagCmp@ method, which type:
+For a derived @Ord@, we concentrate our attentions on @compare@
\begin{verbatim}
-_tagCmp :: a -> a -> _CMP_TAG
-
--- and the builtin tag type is:
-
-data _CMP_TAG = _LT | _EQ | _GT deriving ()
+compare :: a -> a -> Ordering
+data Ordering = LT | EQ | GT deriving ()
\end{verbatim}
-(All this @_tagCmp@ stuff is due to the sterling analysis by Julian
-Seward.)
-
We will use the same example data type as above:
\begin{verbatim}
data Foo ... = N1 | N2 ... | Nn | O1 a b | O2 Int | O3 Double b b | ...
\begin{itemize}
\item
- We do all the other @Ord@ methods with calls to @_tagCmp@:
+ We do all the other @Ord@ methods with calls to @compare@:
\begin{verbatim}
instance ... (Ord <wurble> <wurble>) where
- a < b = case _tagCmp a b of { _LT -> True; _EQ -> False; _GT -> False }
- a <= b = case _tagCmp a b of { _LT -> True; _EQ -> True; _GT -> False }
- a >= b = case _tagCmp a b of { _LT -> False; _EQ -> True; _GT -> True }
- a > b = case _tagCmp 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 _tagCmp a b of { _LT -> b; _EQ -> a; _GT -> a }
- min a b = case _tagCmp a b of { _LT -> a; _EQ -> a; _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 }
- -- _tagCmp to come...
+ -- compare to come...
\end{verbatim}
\item
- @_tagCmp@ always has two parts. First, we use the compared
+ @compare@ always has two parts. First, we use the compared
data-constructors' tags to deal with the case of different
constructors:
\begin{verbatim}
-_tagCmp a b = case (con2tag_Foo a) of { a# ->
- case (con2tag_Foo b) of { b# ->
- case (a# ==# b#) of {
+compare a b = case (con2tag_Foo a) of { a# ->
+ case (con2tag_Foo b) of { b# ->
+ case (a# ==# b#) of {
True -> cmp_eq a b
False -> case (a# <# b#) of
True -> _LT
False -> _GT
- }}}
+ }}}
where
cmp_eq = ... to come ...
\end{verbatim}
comparing data constructors with the same tag.
For the ordinary constructors (if any), we emit the sorta-obvious
- tagCmp-style stuff; for our example:
+ compare-style stuff; for our example:
\begin{verbatim}
cmp_eq (O1 a1 b1) (O1 a2 b2)
- = case (_tagCmp a1 a2) of { _LT -> _LT; _EQ -> _tagCmp b1 b2; _GT -> _GT }
+ = case (compare a1 a2) of { LT -> LT; EQ -> compare b1 b2; GT -> GT }
cmp_eq (O2 a1) (O2 a2)
- = _tagCmp a1 a2
+ = compare a1 a2
cmp_eq (O3 a1 b1 c1) (O3 a2 b2 c2)
- = case (_tagCmp a1 a2) of {
- _LT -> _LT;
- _GT -> _GT;
- _EQ -> case _tagCmp b1 b2 of {
- _LT -> _LT;
- _GT -> _GT;
- _EQ -> _tagCmp c1 c2
- }
+ = case (compare a1 a2) of {
+ LT -> LT;
+ GT -> GT;
+ EQ -> case compare b1 b2 of {
+ LT -> LT;
+ GT -> GT;
+ EQ -> compare c1 c2
+ }
}
\end{verbatim}
generate:
\begin{verbatim}
cmp_eq lt eq gt (O2 a1) (O2 a2)
- = tagCmpInt# a1 a2
+ = compareInt# a1 a2
-- or maybe the unfolded equivalent
\end{verbatim}
For the remaining nullary constructors, we already know that the
tags are equal so:
\begin{verbatim}
-cmp_eq _ _ = _EQ
+cmp_eq _ _ = EQ
\end{verbatim}
\end{itemize}
\begin{code}
-gen_Ord_binds :: TyCon -> ProtoNameMonoBinds
+gen_Ord_binds :: TyCon -> RdrNameMonoBinds
gen_Ord_binds tycon
- = defaulted `AndMonoBinds` tagCmp
+ = defaulted `AndMonoBinds` compare
where
--------------------------------------------------------------------
- tagCmp = mk_easy_FunMonoBind tagCmp_PN
+ compare = mk_easy_FunMonoBind compare_PN
[a_Pat, b_Pat]
[cmp_eq]
- (if maybeToBool (maybeSingleConstructorTyCon tycon) then
- cmp_eq_Expr lt_TAG_Expr eq_TAG_Expr gt_TAG_Expr a_Expr b_Expr
+ (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
+ (cmp_tags_Expr eqH_Int_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
- eq_TAG_Expr
+ eqTag_Expr
else
- cmp_eq_Expr lt_TAG_Expr eq_TAG_Expr gt_TAG_Expr a_Expr b_Expr
+ cmp_eq_Expr ltTag_Expr eqTag_Expr gtTag_Expr a_Expr b_Expr
)
-- 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 lt_TAG_Expr gt_TAG_Expr)))
+ (cmp_tags_Expr ltH_Int_PN ah_PN bh_PN ltTag_Expr gtTag_Expr)))
(nullary_cons, nonnullary_cons)
- = partition isNullaryDataCon (getTyConDataCons tycon)
+ = partition isNullaryDataCon (tyConDataCons tycon)
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_tagCmp_expr tys_needed as_needed bs_needed)
+ 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)
- 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_PN = qual_orig_name data_con
+ con_arity = length tys_needed
+ as_needed = take con_arity as_PNs
+ bs_needed = take con_arity bs_PNs
+ tys_needed = dataConRawArgTys data_con
- nested_tagCmp_expr [ty] [a] [b]
- = careful_tagCmp_Case ty lt_TAG_Expr eq_TAG_Expr gt_TAG_Expr (Var a) (Var b)
+ nested_compare_expr [ty] [a] [b]
+ = careful_compare_Case ty ltTag_Expr eqTag_Expr gtTag_Expr (HsVar a) (HsVar b)
- nested_tagCmp_expr (ty:tys) (a:as) (b:bs)
- = let eq_expr = nested_tagCmp_expr tys as bs
- in careful_tagCmp_Case ty lt_TAG_Expr eq_expr gt_TAG_Expr (Var a) (Var 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], eq_TAG_Expr)]
+ else [([a_Pat, b_Pat], eqTag_Expr)]
--------------------------------------------------------------------
defaulted = foldr1 AndMonoBinds [lt, le, ge, gt, max_, min_]
lt = mk_easy_FunMonoBind lt_PN [a_Pat, b_Pat] [] (
- tagCmp_Case true_Expr false_Expr false_Expr a_Expr b_Expr)
+ compare_Case true_Expr false_Expr false_Expr a_Expr b_Expr)
le = mk_easy_FunMonoBind le_PN [a_Pat, b_Pat] [] (
- tagCmp_Case true_Expr true_Expr false_Expr a_Expr b_Expr)
+ compare_Case true_Expr true_Expr false_Expr a_Expr b_Expr)
ge = mk_easy_FunMonoBind ge_PN [a_Pat, b_Pat] [] (
- tagCmp_Case false_Expr true_Expr true_Expr a_Expr b_Expr)
+ compare_Case false_Expr true_Expr true_Expr a_Expr b_Expr)
gt = mk_easy_FunMonoBind gt_PN [a_Pat, b_Pat] [] (
- tagCmp_Case false_Expr false_Expr true_Expr a_Expr b_Expr)
+ compare_Case false_Expr false_Expr true_Expr a_Expr b_Expr)
max_ = mk_easy_FunMonoBind max_PN [a_Pat, b_Pat] [] (
- tagCmp_Case b_Expr a_Expr a_Expr a_Expr b_Expr)
+ compare_Case b_Expr a_Expr a_Expr a_Expr b_Expr)
min_ = mk_easy_FunMonoBind min_PN [a_Pat, b_Pat] [] (
- tagCmp_Case a_Expr a_Expr b_Expr a_Expr b_Expr)
+ compare_Case a_Expr b_Expr b_Expr a_Expr b_Expr)
\end{code}
%************************************************************************
%* *
-\subsubsection[TcGenDeriv-Enum]{Generating @Enum@ instance declarations}
+\subsubsection{Generating @Enum@ instance declarations}
%* *
%************************************************************************
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
where
enum_from
- = mk_easy_FunMonoBind enumFrom_PN [a_Pat] [] (
- untag_Expr tycon [(a_PN, ah_PN)] (
- App (App (Var map_PN) (Var (tag2con_PN tycon))) (
- enum_from_to_Expr
- (App (Var mkInt_PN) (Var ah_PN))
- (Var (maxtag_PN tycon)))))
+ = mk_easy_FunMonoBind enumFrom_PN [a_Pat] [] $
+ untag_Expr tycon [(a_PN, ah_PN)] $
+ HsApp (mk_easy_App map_PN [tag2con_PN tycon]) $
+ HsPar (enum_from_to_Expr
+ (mk_easy_App mkInt_PN [ah_PN])
+ (HsVar (maxtag_PN tycon)))
enum_from_then
- = mk_easy_FunMonoBind enumFromThen_PN [a_Pat, b_Pat] [] (
- untag_Expr tycon [(a_PN, ah_PN), (b_PN, bh_PN)] (
- App (App (Var map_PN) (Var (tag2con_PN tycon))) (
- enum_from_then_to_Expr
- (App (Var mkInt_PN) (Var ah_PN))
- (App (Var mkInt_PN) (Var bh_PN))
- (Var (maxtag_PN tycon)))))
+ = mk_easy_FunMonoBind enumFromThen_PN [a_Pat, b_Pat] [] $
+ untag_Expr tycon [(a_PN, ah_PN), (b_PN, bh_PN)] $
+ HsApp (mk_easy_App map_PN [tag2con_PN tycon]) $
+ HsPar (enum_from_then_to_Expr
+ (mk_easy_App mkInt_PN [ah_PN])
+ (mk_easy_App mkInt_PN [bh_PN])
+ (HsVar (maxtag_PN tycon)))
\end{code}
%************************************************************************
%* *
-\subsubsection[TcGenDeriv-Ix]{Generating @Ix@ instance declarations}
+\subsubsection{Generating @Eval@ instance declarations}
+%* *
+%************************************************************************
+
+\begin{code}
+gen_Eval_binds tycon = EmptyMonoBinds
+\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(length data_cons == 1)
+ min_bound_1con `AndMonoBinds` max_bound_1con
+ where
+ data_cons = tyConDataCons tycon
+
+ ----- enum-flavored: ---------------------------
+ min_bound_enum = mk_easy_FunMonoBind minBound_PN [] [] (HsVar data_con_1_PN)
+ max_bound_enum = mk_easy_FunMonoBind maxBound_PN [] [] (HsVar data_con_N_PN)
+
+ data_con_1 = head data_cons
+ data_con_N = last data_cons
+ data_con_1_PN = qual_orig_name data_con_1
+ data_con_N_PN = qual_orig_name data_con_N
+
+ ----- single-constructor-flavored: -------------
+ arity = dataConNumFields data_con_1
+
+ min_bound_1con = mk_easy_FunMonoBind minBound_PN [] [] $
+ mk_easy_App data_con_1_PN (nOfThem arity minBound_PN)
+ max_bound_1con = mk_easy_FunMonoBind maxBound_PN [] [] $
+ mk_easy_App data_con_1_PN (nOfThem arity maxBound_PN)
+\end{code}
+
+%************************************************************************
+%* *
+\subsubsection{Generating @Ix@ instance declarations}
%* *
%************************************************************************
-- or, really...
range (a, b)
= case (con2tag_Foo a) of { a# ->
- case (con2tag_Foo b) of { b# ->
+ case (con2tag_Foo b) of { b# ->
map tag2con_Foo (enumFromTo (I# a#) (I# b#))
}}
(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 = _UNPK_ (nameOf (origName "gen_Ix_binds" 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)] (
- App (App (Var map_PN) (Var (tag2con_PN tycon))) (
- enum_from_to_Expr
- (App (Var mkInt_PN) (Var ah_PN))
- (App (Var mkInt_PN) (Var bh_PN))
- ))))
+ = 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 (mk_easy_App map_PN [tag2con_PN tycon]) $
+ HsPar (enum_from_to_Expr
+ (mk_easy_App mkInt_PN [ah_PN])
+ (mk_easy_App mkInt_PN [bh_PN]))
enum_index
= mk_easy_FunMonoBind index_PN [AsPatIn c_PN (TuplePatIn [a_Pat, b_Pat]), d_Pat] [] (
- If (App (App (Var inRange_PN) c_Expr) d_Expr) (
+ HsIf (HsPar (mk_easy_App inRange_PN [c_PN, d_PN])) (
untag_Expr tycon [(a_PN, ah_PN)] (
untag_Expr tycon [(d_PN, dh_PN)] (
let
- grhs = [OtherwiseGRHS (App (Var mkInt_PN) (Var c_PN)) mkGeneratedSrcLoc]
+ grhs = [OtherwiseGRHS (mk_easy_App mkInt_PN [c_PN]) mkGeneratedSrcLoc]
in
- Case (OpApp (Var dh_PN) (Var minusH_PN) (Var ah_PN)) {-of-}
+ HsCase
+ (HsPar (OpApp (HsVar dh_PN) (HsVar minusH_PN) (HsVar ah_PN)))
[PatMatch (VarPatIn c_PN)
(GRHSMatch (GRHSsAndBindsIn grhs EmptyBinds))]
+ mkGeneratedSrcLoc
))
) {-else-} (
- App (Var error_PN) (Lit (StringLit (_PK_ ("Ix."++tycon_str++".index: out of range\n"))))
- )
+ HsApp (HsVar error_PN) (HsLit (HsString (_PK_ ("Ix."++tycon_str++".index: out of range\n"))))
)
+ mkGeneratedSrcLoc)
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)] (
- If (OpApp (Var ch_PN) (Var geH_PN) (Var ah_PN)) (
- (OpApp (Var ch_PN) (Var leH_PN) (Var bh_PN))
+ HsIf (HsPar (OpApp (HsVar ch_PN) (HsVar geH_PN) (HsVar ah_PN))) (
+ (OpApp (HsVar ch_PN) (HsVar leH_PN) (HsVar bh_PN))
) {-else-} (
false_Expr
- )))))
+ ) mkGeneratedSrcLoc))))
--------------------------------------------------------------
single_con_ixes = single_con_range `AndMonoBinds`
single_con_index `AndMonoBinds` single_con_inRange
data_con
- = case maybeSingleConstructorTyCon tycon of -- just checking...
+ = 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
+ Just dc -> if (any isPrimType (dataConRawArgTys dc)) 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_arity = dataConNumFields data_con
+ data_con_PN = qual_orig_name data_con
con_pat xs = ConPatIn data_con_PN (map VarPatIn xs)
- con_expr xs = foldl App (Var data_con_PN) (map Var xs)
+ con_expr xs = mk_easy_App data_con_PN 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
+ as_needed = take con_arity as_PNs
+ bs_needed = take con_arity bs_PNs
+ cs_needed = take con_arity cs_PNs
--------------------------------------------------------------
single_con_range
= mk_easy_FunMonoBind range_PN [TuplePatIn [con_pat as_needed, con_pat bs_needed]] [] (
- ListComp (con_expr cs_needed) (zipWith3 mk_qual as_needed bs_needed cs_needed)
+ ListComp (con_expr cs_needed) (zipWith3Equal "single_con_range" mk_qual as_needed bs_needed cs_needed)
)
where
mk_qual a b c = GeneratorQual (VarPatIn c)
- (App (Var range_PN) (ExplicitTuple [Var a, Var b]))
+ (HsApp (HsVar range_PN) (ExplicitTuple [HsVar a, HsVar b]))
----------------
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 (Lit (IntLit 0)) (zip3 as_needed bs_needed cs_needed))
+ foldl mk_index (HsLit (HsInt 0)) (zip3 as_needed bs_needed cs_needed))
where
mk_index multiply_by (l, u, i)
=OpApp (
- (App (App (Var index_PN) (ExplicitTuple [Var l, Var u])) (Var i))
- ) (Var plus_PN) (
+ (HsApp (HsApp (HsVar index_PN) (ExplicitTuple [HsVar l, HsVar u])) (HsVar i))
+ ) (HsVar plus_PN) (
OpApp (
- (App (Var rangeSize_PN) (ExplicitTuple [Var l, Var u]))
- ) (Var times_PN) multiply_by
+ (HsApp (HsVar rangeSize_PN) (ExplicitTuple [HsVar l, HsVar u]))
+ ) (HsVar times_PN) multiply_by
)
range_size
= mk_easy_FunMonoBind rangeSize_PN [TuplePatIn [a_Pat, b_Pat]] [] (
OpApp (
- (App (App (Var index_PN) (ExplicitTuple [a_Expr, b_Expr])) b_Expr)
- ) (Var plus_PN) (Lit (IntLit 1)))
+ (HsApp (HsApp (HsVar index_PN) (ExplicitTuple [a_Expr, b_Expr])) b_Expr)
+ ) (HsVar plus_PN) (HsLit (HsInt 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 (zipWith3 in_range as_needed bs_needed cs_needed))
+ foldl1 and_Expr (zipWith3Equal "single_con_inRange" in_range as_needed bs_needed cs_needed))
where
- in_range a b c = App (App (Var inRange_PN) (ExplicitTuple [Var a, Var b])) (Var c)
+ in_range a b c = HsApp (HsApp (HsVar inRange_PN) (ExplicitTuple [HsVar a, HsVar b])) (HsVar c)
\end{code}
%************************************************************************
%* *
-\subsubsection[TcGenDeriv-Text]{Generating @Text@ instance declarations}
+\subsubsection{Generating @Read@ instance declarations}
%* *
%************************************************************************
-Deriving @Text@ is a pain. @show@ is commonly used; @read@ is rarely
-used---but we're supposed to generate massive amounts of code for it
-anyway. We provide a command-line flag to say ``Don't bother''
-(@OmitDerivedRead@).
-
-We just use the default methods for @showList@ and @readList@.
-
-Also: ignoring all the infix-ery mumbo jumbo (ToDo)
-
-The part of the Haskell report that deals with this (pages~147--151,
-1.2~version) is an adequate guide to what needs to be done. Note that
-this is where we may (eventually) use the fixity info that's been
-passed around.
+Ignoring all the infix-ery mumbo jumbo (ToDo)
\begin{code}
-gen_Text_binds :: [RenamedFixityDecl] -> Bool -> TyCon -> ProtoNameMonoBinds
+gen_Read_binds :: [RenamedFixityDecl] -> TyCon -> RdrNameMonoBinds
-gen_Text_binds fixities omit_derived_read tycon
- = if omit_derived_read
- then shows_prec
- else shows_prec `AndMonoBinds` reads_prec
+gen_Read_binds fixities tycon
+ = reads_prec `AndMonoBinds` read_list
where
-----------------------------------------------------------------------
- shows_prec
- = mk_FunMonoBind showsPrec_PN (map pats_etc (getTyConDataCons 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)
-
- show_con
- = let (mod, nm) = getOrigName data_con
- space_maybe = if isNullaryDataCon data_con then _NIL_ else SLIT(" ")
- in
- App (Var showString_PN) (Lit (StringLit (nm _APPEND_ space_maybe)))
-
- show_thingies = show_con : (spacified real_show_thingies)
-
- real_show_thingies
- = [ App (App (Var showsPrec_PN) (Lit (IntLit 10))) (Var b)
- | b <- bs_needed ]
- in
- ([a_Pat, con_pat],
- showParen_Expr (OpApp a_Expr (Var ge_PN) (Lit (IntLit 10)))
- (nested_compose_Expr show_thingies))
- where
- spacified [] = []
- spacified [x] = [x]
- spacified (x:xs) = (x : (Var showSpace_PN) : spacified xs)
-
+ read_list = mk_easy_FunMonoBind readList_PN [] []
+ (HsApp (HsVar readList___PN) (HsPar (HsApp (HsVar readsPrec_PN) (HsLit (HsInt 0)))))
-----------------------------------------------------------------------
- reads_prec -- ignore the infix game altogether
+ reads_prec
= let
read_con_comprehensions
- = map read_con (getTyConDataCons tycon)
+ = map read_con (tyConDataCons tycon)
in
- mk_easy_FunMonoBind readsPrec_PN [a_Pat] [] (
- readParen_Expr (OpApp a_Expr (Var gt_PN) (Lit (IntLit 9))) (
- Lam (mk_easy_Match [b_Pat] [] (
+ mk_easy_FunMonoBind readsPrec_PN [a_Pat, b_Pat] [] (
foldl1 append_Expr read_con_comprehensions
- ))))
+ )
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 App (Var data_con_PN) (map Var as_needed)
+ data_con_PN = qual_orig_name data_con
+ data_con_str= nameOf (origName "gen_Read_binds" data_con)
+ con_arity = dataConNumFields data_con
+ as_needed = take con_arity as_PNs
+ bs_needed = take con_arity bs_PNs
+ con_expr = mk_easy_App data_con_PN as_needed
+ nullary_con = isNullaryDataCon data_con
con_qual
= GeneratorQual
- (TuplePatIn [LitPatIn (StringLit data_con_str), c_Pat])
- (App (Var lex_PN) b_Expr)
+ (TuplePatIn [LitPatIn (HsString data_con_str), d_Pat])
+ (HsApp (HsVar lex_PN) c_Expr)
- field_quals = snd (mapAccumL mk_qual c_Expr (as_needed `zip` bs_needed))
+ field_quals = snd (mapAccumL mk_qual d_Expr (zipEqual "as_needed" as_needed bs_needed))
+
+ read_paren_arg
+ = if nullary_con then -- must be False (parens are surely optional)
+ false_Expr
+ else -- parens depend on precedence...
+ HsPar (OpApp a_Expr (HsVar gt_PN) (HsLit (HsInt 9)))
in
- ListComp (ExplicitTuple [con_expr,
- if null bs_needed then c_Expr else Var (last bs_needed)])
- (con_qual : field_quals)
+ HsApp (
+ readParen_Expr read_paren_arg $ HsPar $
+ 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)
- = (Var str_left, -- what to draw from down the line...
+ = (HsVar str_left, -- what to draw from down the line...
GeneratorQual
(TuplePatIn [VarPatIn con_field, VarPatIn str_left])
- (App (App (Var readsPrec_PN) (Lit (IntLit 10))) draw_from))
+ (HsApp (HsApp (HsVar readsPrec_PN) (HsLit (HsInt 10))) draw_from))
\end{code}
%************************************************************************
%* *
-\subsubsection[TcGenDeriv-Binary]{Generating @Binary@ instance declarations}
+\subsubsection{Generating @Show@ instance declarations}
%* *
%************************************************************************
-ToDo: NOT DONE YET.
+Ignoring all the infix-ery mumbo jumbo (ToDo)
\begin{code}
-gen_Binary_binds :: TyCon -> ProtoNameMonoBinds
+gen_Show_binds :: [RenamedFixityDecl] -> TyCon -> RdrNameMonoBinds
-gen_Binary_binds tycon
- = panic "gen_Binary_binds"
+gen_Show_binds fixities tycon
+ = shows_prec `AndMonoBinds` show_list
+ where
+ -----------------------------------------------------------------------
+ show_list = mk_easy_FunMonoBind showList_PN [] []
+ (HsApp (HsVar showList___PN) (HsPar (HsApp (HsVar showsPrec_PN) (HsLit (HsInt 0)))))
+ -----------------------------------------------------------------------
+ shows_prec
+ = mk_FunMonoBind showsPrec_PN (map pats_etc (tyConDataCons tycon))
+ where
+ pats_etc data_con
+ = let
+ data_con_PN = qual_orig_name data_con
+ con_arity = dataConNumFields data_con
+ bs_needed = take con_arity bs_PNs
+ con_pat = ConPatIn data_con_PN (map VarPatIn bs_needed)
+ nullary_con = isNullaryDataCon data_con
+
+ show_con
+ = let (OrigName mod nm) = origName "gen_Show_binds" 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 (HsPar (OpApp a_Expr (HsVar ge_PN) (HsLit (HsInt 10))))
+ (HsPar (nested_compose_Expr show_thingies)))
+ where
+ spacified [] = []
+ spacified [x] = [x]
+ spacified (x:xs) = (x : (HsVar showSpace_PN) : spacified xs)
\end{code}
%************************************************************************
%* *
-\subsection[TcGenDeriv-con2tag-tag2con]{Generating extra binds (@con2tag@ and @tag2con@)}
+\subsection{Generating extra binds (@con2tag@ and @tag2con@)}
%* *
%************************************************************************
fiddling around.
\begin{code}
+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))
+gen_tag_n_con_monobind (pn, tycon, GenCon2Tag)
+ = mk_FunMonoBind pn (map mk_stuff (tyConDataCons tycon))
where
- mk_stuff :: DataCon -> ([ProtoNamePat], ProtoNameExpr)
+ mk_stuff :: DataCon -> ([RdrNamePat], RdrNameHsExpr)
mk_stuff var
= ASSERT(isDataCon var)
- ([pat], Lit (IntPrimLit (toInteger ((getDataConTag var) - fIRST_TAG))))
+ ([pat], HsLit (HsIntPrim (toInteger ((dataConTag var) - fIRST_TAG))))
where
- pat = ConPatIn var_PN (nOfThem (getDataConArity var) WildPatIn)
- var_PN = Prel (WiredInVal var)
+ pat = ConPatIn var_PN (nOfThem (dataConNumFields var) WildPatIn)
+ var_PN = qual_orig_name var
-gen_tag_n_con_monobind (pn, _, tycon, GenTag2Con)
- = mk_FunMonoBind pn (map mk_stuff (getTyConDataCons tycon))
+gen_tag_n_con_monobind (pn, tycon, GenTag2Con)
+ = mk_FunMonoBind pn (map mk_stuff (tyConDataCons tycon))
where
- mk_stuff :: DataCon -> ([ProtoNamePat], ProtoNameExpr)
+ mk_stuff :: DataCon -> ([RdrNamePat], RdrNameHsExpr)
mk_stuff var
= ASSERT(isDataCon var)
- ([lit_pat], Var var_PN)
+ ([lit_pat], HsVar var_PN)
where
- lit_pat = ConPatIn mkInt_PN [LitPatIn (IntPrimLit (toInteger ((getDataConTag var) - fIRST_TAG)))]
- var_PN = Prel (WiredInVal var)
+ lit_pat = ConPatIn mkInt_PN [LitPatIn (HsIntPrim (toInteger ((dataConTag var) - fIRST_TAG)))]
+ var_PN = qual_orig_name var
-gen_tag_n_con_monobind (pn, _, tycon, GenMaxTag)
- = mk_easy_FunMonoBind pn [] [] (App (Var mkInt_PN) (Lit (IntPrimLit max_tag)))
+gen_tag_n_con_monobind (pn, tycon, GenMaxTag)
+ = mk_easy_FunMonoBind pn [] [] (HsApp (HsVar mkInt_PN) (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] -> ProtoNameExpr
- -> ProtoNameMonoBinds
+mk_easy_FunMonoBind :: RdrName -> [RdrNamePat]
+ -> [RdrNameMonoBinds] -> RdrNameHsExpr
+ -> RdrNameMonoBinds
mk_easy_FunMonoBind fun pats binds expr
- = FunMonoBind fun [mk_easy_Match pats binds expr] mkGeneratedSrcLoc
+ = FunMonoBind fun False{-not infix-} [mk_easy_Match pats binds expr] mkGeneratedSrcLoc
mk_easy_Match pats binds expr
- = foldr PatMatch
- (GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS expr mkGeneratedSrcLoc] (mkbind binds)))
- pats
+ = mk_match pats expr (mkbind binds)
where
- mkbind [] = EmptyBinds
+ mkbind [] = EmptyBinds
mkbind bs = SingleBind (RecBind (foldr1 AndMonoBinds bs))
-- 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], ProtoNameExpr)]
- -> ProtoNameMonoBinds
+mk_FunMonoBind :: 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
+ = FunMonoBind fun False{-not infix-}
+ [ mk_match p e EmptyBinds | (p,e) <-pats_and_exprs ]
+ mkGeneratedSrcLoc
+
+mk_match pats expr binds
+ = foldr PatMatch
+ (GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS expr mkGeneratedSrcLoc] binds))
+ (map paren pats)
where
- mk_match (pats, expr)
- = foldr PatMatch
- (GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS expr mkGeneratedSrcLoc] EmptyBinds))
- pats
+ paren p@(VarPatIn _) = p
+ paren other_p = ParPatIn other_p
+\end{code}
+
+\begin{code}
+mk_easy_App f xs = foldl HsApp (HsVar f) (map HsVar xs)
\end{code}
\begin{code}
-tagCmp_Case, cmp_eq_Expr ::
- ProtoNameExpr -> ProtoNameExpr -> ProtoNameExpr
- -> ProtoNameExpr -> ProtoNameExpr
- -> ProtoNameExpr
-tagCmp_gen_Case ::
- ProtoName
- -> ProtoNameExpr -> ProtoNameExpr -> ProtoNameExpr
- -> ProtoNameExpr -> ProtoNameExpr
- -> ProtoNameExpr
-careful_tagCmp_Case :: -- checks for primitive types...
- UniType
- -> ProtoNameExpr -> ProtoNameExpr -> ProtoNameExpr
- -> ProtoNameExpr -> ProtoNameExpr
- -> ProtoNameExpr
-
-tagCmp_Case = tagCmp_gen_Case tagCmp_PN
-cmp_eq_Expr = tagCmp_gen_Case cmp_eq_PN
-
-tagCmp_gen_Case fun lt eq gt a b
- = Case (App (App (Var fun) a) b) {-of-}
- [PatMatch (ConPatIn lt_TAG_PN [])
+compare_Case, cmp_eq_Expr ::
+ RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr
+ -> RdrNameHsExpr -> RdrNameHsExpr
+ -> RdrNameHsExpr
+compare_gen_Case ::
+ RdrName
+ -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr
+ -> RdrNameHsExpr -> RdrNameHsExpr
+ -> RdrNameHsExpr
+careful_compare_Case :: -- checks for primitive types...
+ Type
+ -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr
+ -> RdrNameHsExpr -> RdrNameHsExpr
+ -> RdrNameHsExpr
+
+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 (HsPar (HsApp (HsApp (HsVar fun) a) b)) {-of-}
+ [PatMatch (ConPatIn ltTag_PN [])
(GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS lt mkGeneratedSrcLoc] EmptyBinds)),
- PatMatch (ConPatIn eq_TAG_PN [])
+ PatMatch (ConPatIn eqTag_PN [])
(GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS eq mkGeneratedSrcLoc] EmptyBinds)),
- PatMatch (ConPatIn gt_TAG_PN [])
+ PatMatch (ConPatIn gtTag_PN [])
(GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS gt mkGeneratedSrcLoc] EmptyBinds))]
+ mkGeneratedSrcLoc
-careful_tagCmp_Case ty lt eq gt a b
+careful_compare_Case ty lt eq gt a b
= if not (isPrimType ty) then
- tagCmp_gen_Case tagCmp_PN lt eq gt a b
+ compare_gen_Case compare_PN lt eq gt a b
else -- we have to do something special for primitive things...
- If (OpApp a (Var relevant_eq_op) b)
- eq
- (If (OpApp a (Var relevant_lt_op) b) lt gt)
+ HsIf (HsPar (OpApp a (HsVar relevant_eq_op) b))
+ eq
+ (HsIf (HsPar (OpApp a (HsVar relevant_lt_op) b)) lt gt mkGeneratedSrcLoc)
+ mkGeneratedSrcLoc
+ 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
where
- relevant_eq_op = assoc "careful_tagCmp_Case" eq_op_tbl ty
- relevant_lt_op = assoc "careful_tagCmp_Case" lt_op_tbl 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))) ]
+ res = [id | (ty',id) <- tyids, eqTy ty ty']
+
+eq_op_tbl =
+ [(charPrimTy, eqH_Char_PN)
+ ,(intPrimTy, eqH_Int_PN)
+ ,(wordPrimTy, eqH_Word_PN)
+ ,(addrPrimTy, eqH_Addr_PN)
+ ,(floatPrimTy, eqH_Float_PN)
+ ,(doublePrimTy, eqH_Double_PN)
+ ]
+
+lt_op_tbl =
+ [(charPrimTy, ltH_Char_PN)
+ ,(intPrimTy, ltH_Int_PN)
+ ,(wordPrimTy, ltH_Word_PN)
+ ,(addrPrimTy, ltH_Addr_PN)
+ ,(floatPrimTy, ltH_Float_PN)
+ ,(doublePrimTy, ltH_Double_PN)
+ ]
-----------------------------------------------------------------------
-and_Expr, append_Expr :: ProtoNameExpr -> ProtoNameExpr -> ProtoNameExpr
+and_Expr, append_Expr :: RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr
-and_Expr a b = OpApp a (Var and_PN) b
-append_Expr a b = OpApp a (Var append_PN) b
+and_Expr a b = OpApp a (HsVar and_PN) b
+append_Expr a b = OpApp a (HsVar append_PN) b
-----------------------------------------------------------------------
-eq_Expr :: UniType -> ProtoNameExpr -> ProtoNameExpr -> ProtoNameExpr
+eq_Expr :: Type -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr
eq_Expr ty a b
= if not (isPrimType ty) then
- OpApp a (Var eq_PN) b
+ OpApp a (HsVar eq_PN) b
else -- we have to do something special for primitive things...
- OpApp a (Var relevant_eq_op) b
+ OpApp a (HsVar relevant_eq_op) b
where
- relevant_eq_op = assoc "eq_Expr" eq_op_tbl ty
+ relevant_eq_op = assoc_ty_id eq_op_tbl ty
\end{code}
\begin{code}
-untag_Expr :: TyCon -> [(ProtoName, ProtoName)] -> ProtoNameExpr -> ProtoNameExpr
+untag_Expr :: TyCon -> [(RdrName, RdrName)] -> RdrNameHsExpr -> RdrNameHsExpr
untag_Expr tycon [] expr = expr
untag_Expr tycon ((untag_this, put_tag_here) : more) expr
- = Case (App (con2tag_Expr tycon) (Var untag_this)) {-of-}
+ = HsCase (HsPar (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]
-cmp_tags_Expr :: ProtoName -- Comparison op
- -> ProtoName -> ProtoName -- Things to compare
- -> ProtoNameExpr -- What to return if true
- -> ProtoNameExpr -- What to return if false
- -> ProtoNameExpr
+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
- = If (OpApp (Var a) (Var op) (Var b)) true_case false_case
+cmp_tags_Expr op a b true_case false_case
+ = HsIf (HsPar (OpApp (HsVar a) (HsVar op) (HsVar b))) true_case false_case mkGeneratedSrcLoc
enum_from_to_Expr
- :: ProtoNameExpr -> ProtoNameExpr
- -> ProtoNameExpr
+ :: RdrNameHsExpr -> RdrNameHsExpr
+ -> RdrNameHsExpr
enum_from_then_to_Expr
- :: ProtoNameExpr -> ProtoNameExpr -> ProtoNameExpr
- -> ProtoNameExpr
+ :: RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr
+ -> RdrNameHsExpr
-enum_from_to_Expr f t2 = App (App (Var enumFromTo_PN) f) t2
-enum_from_then_to_Expr f t t2 = App (App (App (Var enumFromThenTo_PN) f) t) t2
+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
showParen_Expr, readParen_Expr
- :: ProtoNameExpr -> ProtoNameExpr
- -> ProtoNameExpr
+ :: RdrNameHsExpr -> RdrNameHsExpr
+ -> RdrNameHsExpr
-showParen_Expr e1 e2 = App (App (Var showParen_PN) e1) e2
-readParen_Expr e1 e2 = App (App (Var readParen_PN) e1) e2
+showParen_Expr e1 e2 = HsApp (HsApp (HsVar showParen_PN) e1) e2
+readParen_Expr e1 e2 = HsApp (HsApp (HsVar readParen_PN) e1) e2
-nested_compose_Expr :: [ProtoNameExpr] -> ProtoNameExpr
+nested_compose_Expr :: [RdrNameHsExpr] -> RdrNameHsExpr
-nested_compose_Expr [e] = e
+nested_compose_Expr [e] = parenify e
nested_compose_Expr (e:es)
- = App (App (Var compose_PN) e) (nested_compose_Expr es)
+ = HsApp (HsApp (HsVar compose_PN) (parenify e)) (nested_compose_Expr es)
+
+parenify e@(HsVar _) = e
+parenify e = HsPar e
\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")
-tagCmp_PN = prelude_method SLIT("Ord") SLIT("_tagCmp")
-lt_TAG_PN = Prel (WiredInVal ltPrimDataCon)
-eq_TAG_PN = Prel (WiredInVal eqPrimDataCon)
-gt_TAG_PN = Prel (WiredInVal gtPrimDataCon)
-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("Text") SLIT("readsPrec")
-showsPrec_PN = prelude_method SLIT("Text") SLIT("showsPrec")
-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")
-
-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 = Var a_PN
-b_Expr = Var b_PN
-c_Expr = Var c_PN
-d_Expr = Var d_PN
-lt_TAG_Expr = Var lt_TAG_PN
-eq_TAG_Expr = Var eq_TAG_PN
-gt_TAG_Expr = Var gt_TAG_PN
-false_Expr = Var false_PN
-true_Expr = Var true_PN
-
-con2tag_Expr tycon = Var (con2tag_PN tycon)
+qual_orig_name n = case (origName "qual_orig_name" n) of { OrigName m n -> Qual m n }
+
+a_PN = Unqual SLIT("a")
+b_PN = Unqual SLIT("b")
+c_PN = Unqual SLIT("c")
+d_PN = Unqual SLIT("d")
+ah_PN = Unqual SLIT("a#")
+bh_PN = Unqual SLIT("b#")
+ch_PN = Unqual SLIT("c#")
+dh_PN = Unqual SLIT("d#")
+cmp_eq_PN = Unqual SLIT("cmp_eq")
+rangeSize_PN = Qual iX SLIT("rangeSize")
+
+as_PNs = [ Unqual (_PK_ ("a"++show i)) | i <- [(1::Int) .. ] ]
+bs_PNs = [ Unqual (_PK_ ("b"++show i)) | i <- [(1::Int) .. ] ]
+cs_PNs = [ Unqual (_PK_ ("c"++show i)) | i <- [(1::Int) .. ] ]
+
+eq_PN = preludeQual {-SLIT("Eq")-} SLIT("==")
+ne_PN = preludeQual {-SLIT("Eq")-} SLIT("/=")
+le_PN = preludeQual {-SLIT("Ord")-} SLIT("<=")
+lt_PN = preludeQual {-SLIT("Ord")-} SLIT("<")
+ge_PN = preludeQual {-SLIT("Ord")-} SLIT(">=")
+gt_PN = preludeQual {-SLIT("Ord")-} SLIT(">")
+max_PN = preludeQual {-SLIT("Ord")-} SLIT("max")
+min_PN = preludeQual {-SLIT("Ord")-} SLIT("min")
+compare_PN = preludeQual {-SLIT("Ord")-} SLIT("compare")
+minBound_PN = preludeQual {-SLIT("Bounded")-} SLIT("minBound")
+maxBound_PN = preludeQual {-SLIT("Bounded")-} SLIT("maxBound")
+enumFrom_PN = preludeQual {-SLIT("Enum")-} SLIT("enumFrom")
+enumFromTo_PN = preludeQual {-SLIT("Enum")-} SLIT("enumFromTo")
+enumFromThen_PN = preludeQual {-SLIT("Enum")-} SLIT("enumFromThen")
+enumFromThenTo_PN= preludeQual {-SLIT("Enum")-} SLIT("enumFromThenTo")
+range_PN = Qual iX SLIT("range")
+index_PN = Qual iX SLIT("index")
+inRange_PN = Qual iX SLIT("inRange")
+readsPrec_PN = preludeQual {-SLIT("Read")-} SLIT("readsPrec")
+readList_PN = preludeQual {-SLIT("Read")-} SLIT("readList")
+showsPrec_PN = preludeQual {-SLIT("Show")-} SLIT("showsPrec")
+showList_PN = preludeQual {-SLIT("Show")-} SLIT("showList")
+plus_PN = preludeQual {-SLIT("Num")-} SLIT("+")
+times_PN = preludeQual {-SLIT("Num")-} SLIT("*")
+ltTag_PN = preludeQual SLIT("LT")
+eqTag_PN = preludeQual SLIT("EQ")
+gtTag_PN = preludeQual SLIT("GT")
+
+eqH_Char_PN = prelude_primop CharEqOp
+ltH_Char_PN = prelude_primop CharLtOp
+eqH_Word_PN = prelude_primop WordEqOp
+ltH_Word_PN = prelude_primop WordLtOp
+eqH_Addr_PN = prelude_primop AddrEqOp
+ltH_Addr_PN = prelude_primop AddrLtOp
+eqH_Float_PN = prelude_primop FloatEqOp
+ltH_Float_PN = prelude_primop FloatLtOp
+eqH_Double_PN = prelude_primop DoubleEqOp
+ltH_Double_PN = prelude_primop DoubleLtOp
+eqH_Int_PN = prelude_primop IntEqOp
+ltH_Int_PN = prelude_primop IntLtOp
+geH_PN = prelude_primop IntGeOp
+leH_PN = prelude_primop IntLeOp
+minusH_PN = prelude_primop IntSubOp
+
+prelude_primop o = case (origName "prelude_primop" (primOpId o)) of { OrigName m n -> Qual m n }
+
+false_PN = preludeQual SLIT("False")
+true_PN = preludeQual SLIT("True")
+and_PN = preludeQual SLIT("&&")
+not_PN = preludeQual SLIT("not")
+append_PN = preludeQual SLIT("++")
+map_PN = preludeQual SLIT("map")
+compose_PN = preludeQual SLIT(".")
+mkInt_PN = preludeQual SLIT("I#")
+error_PN = preludeQual SLIT("error")
+showString_PN = preludeQual SLIT("showString")
+showParen_PN = preludeQual SLIT("showParen")
+readParen_PN = preludeQual SLIT("readParen")
+lex_PN = Qual gHC__ SLIT("lex")
+showSpace_PN = Qual gHC__ SLIT("showSpace")
+showList___PN = Qual gHC__ SLIT("showList__")
+readList___PN = Qual gHC__ SLIT("readList__")
+
+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
-\end{code}
-%************************************************************************
-%* *
-\subsection[TcGenDeriv-misc-utils]{Miscellaneous utility bits for deriving}
-%* *
-%************************************************************************
+con2tag_PN, tag2con_PN, maxtag_PN :: TyCon -> RdrName
-\begin{code}
-{- UNUSED:
-hasCon2TagFun :: TyCon -> Bool
-hasCon2TagFun tycon
- = preludeClassDerivedFor ordClassKey tycon
- || isEnumerationTyConMostly tycon
-
-hasTag2ConFun :: TyCon -> Bool
-hasTag2ConFun tycon
- = isEnumerationTyCon tycon
- && (preludeClassDerivedFor ixClassKey tycon
- || preludeClassDerivedFor enumClassKey tycon)
--}
+con2tag_PN tycon
+ = let (OrigName mod nm) = origName "con2tag_PN" tycon
+ con2tag = SLIT("con2tag_") _APPEND_ nm _APPEND_ SLIT("#")
+ in
+ Qual mod con2tag
+
+tag2con_PN tycon
+ = let (OrigName mod nm) = origName "tag2con_PN" tycon
+ tag2con = SLIT("tag2con_") _APPEND_ nm _APPEND_ SLIT("#")
+ in
+ Qual mod tag2con
+
+maxtag_PN tycon
+ = let (OrigName mod nm) = origName "maxtag_PN" tycon
+ maxtag = SLIT("maxtag_") _APPEND_ nm _APPEND_ SLIT("#")
+ in
+ Qual mod maxtag
\end{code}
projects / ghc-hetmet.git / blobdiff