gen_Ord_binds,
gen_Read_binds,
gen_Show_binds,
+ gen_Data_binds,
+ gen_Typeable_binds,
gen_tag_n_con_monobind,
con2tag_RDR, tag2con_RDR, maxtag_RDR,
#include "HsVersions.h"
-import HsSyn ( InPat(..), HsExpr(..), MonoBinds(..),
+import HsSyn ( Pat(..), HsConDetails(..), HsExpr(..), MonoBinds(..),
Match(..), GRHSs(..), Stmt(..), HsLit(..),
- HsBinds(..), HsType(..), HsDoContext(..),
+ HsBinds(..), HsType(..), HsStmtContext(..),
unguardedRHS, mkSimpleMatch, mkMonoBind, andMonoBindList, placeHolderType
)
-import RdrHsSyn ( mkHsOpApp, RdrNameMonoBinds, RdrNameHsExpr, RdrNamePat )
-import RdrName ( RdrName, mkUnqual )
+import RdrName ( RdrName, mkUnqual, nameRdrName, getRdrName )
+import RdrHsSyn ( mkHsOpApp, RdrNameMonoBinds, RdrNameHsExpr, RdrNamePat, mkHsDo )
import BasicTypes ( RecFlag(..), Fixity(..), FixityDirection(..)
, maxPrecedence
, Boxity(..)
)
-import FieldLabel ( FieldLabel, fieldLabelName )
+import FieldLabel ( fieldLabelName )
import DataCon ( isNullaryDataCon, dataConTag,
dataConOrigArgTys, dataConSourceArity, fIRST_TAG,
DataCon,
dataConFieldLabels )
import Name ( getOccString, getOccName, getSrcLoc, occNameString,
- occNameUserString, nameRdrName, varName,
+ occNameUserString, varName,
Name, NamedThing(..),
isDataSymOcc, isSymOcc
)
import HscTypes ( FixityEnv, lookupFixity )
-import PrelInfo -- Lots of RdrNames
+import PrelNames -- Lots of Names
+import PrimOp -- Lots of Names
import SrcLoc ( generatedSrcLoc, SrcLoc )
import TyCon ( TyCon, isNewTyCon, tyConDataCons, isEnumerationTyCon,
- maybeTyConSingleCon, tyConFamilySize
+ maybeTyConSingleCon, tyConFamilySize, tyConTyVars
)
import TcType ( isUnLiftedType, tcEqType, Type )
-import TysPrim ( charPrimTy, intPrimTy, wordPrimTy, addrPrimTy,
- floatPrimTy, doublePrimTy
- )
-import Util ( mapAccumL, zipEqual, zipWithEqual, isSingleton,
- zipWith3Equal, nOfThem )
+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 Maybes ( maybeToBool )
-import Char ( ord )
+import Char ( ord, isAlpha )
import Constants
import List ( partition, intersperse )
+import Outputable
+import FastString
+import OccName
\end{code}
%************************************************************************
else -- calc. and compare the tags
[([a_Pat, b_Pat],
untag_Expr tycon [(a_RDR,ah_RDR), (b_RDR,bh_RDR)]
- (genOpApp (HsVar ah_RDR) eqH_Int_RDR (HsVar bh_RDR)))]
+ (genOpApp (HsVar ah_RDR) eqInt_RDR (HsVar bh_RDR)))]
in
mk_FunMonoBind tycon_loc eq_RDR ((map pats_etc nonnullary_cons) ++ rest)
`AndMonoBinds`
------------------------------------------------------------------
pats_etc data_con
= let
- con1_pat = ConPatIn data_con_RDR (map VarPatIn as_needed)
- con2_pat = ConPatIn data_con_RDR (map VarPatIn bs_needed)
+ con1_pat = mkConPat data_con_RDR as_needed
+ con2_pat = mkConPat data_con_RDR bs_needed
- data_con_RDR = qual_orig_name data_con
+ 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
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 ty (HsVar a) (HsVar b))
+ nested_eq ty a b = HsPar (eq_Expr tycon ty (HsVar a) (HsVar b))
\end{code}
%************************************************************************
tycon_loc = getSrcLoc tycon
--------------------------------------------------------------------
compare = mk_easy_FunMonoBind tycon_loc compare_RDR
- [a_Pat, b_Pat]
- [cmp_eq]
- (if maybeToBool (maybeTyConSingleCon tycon) then
-
--- cmp_eq_Expr ltTag_Expr eqTag_Expr gtTag_Expr a_Expr b_Expr
--- Weird. Was: case (cmp a b) of { LT -> LT; EQ -> EQ; GT -> GT }
-
- cmp_eq_Expr a_Expr b_Expr
- else
- untag_Expr tycon [(a_RDR, ah_RDR), (b_RDR, bh_RDR)]
- (cmp_tags_Expr eqH_Int_RDR ah_RDR bh_RDR
- -- 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
--- Ditto
- cmp_eq_Expr a_Expr b_Expr
- )
+ [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_Int_RDR ah_RDR bh_RDR 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)
| isNewTyCon tycon = ([], tyConDataCons tycon)
| otherwise = partition isNullaryDataCon tycon_data_cons
- cmp_eq =
- mk_FunMonoBind tycon_loc
- cmp_eq_RDR
- (if null nonnullary_cons && isSingleton nullary_cons then
- -- catch this specially to avoid warnings
- -- about overlapping patterns from the desugarer.
- let
- data_con = head nullary_cons
- data_con_RDR = qual_orig_name data_con
- pat = ConPatIn data_con_RDR []
- in
- [([pat,pat], eqTag_Expr)]
- else
- map pats_etc nonnullary_cons ++
- -- leave out wildcards to silence desugarer.
- (if isSingleton tycon_data_cons then
- []
- else
- [([WildPatIn, WildPatIn], default_rhs)]))
+ 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)])
+
where
pats_etc data_con
= ([con1_pat, con2_pat],
nested_compare_expr tys_needed as_needed bs_needed)
where
- con1_pat = ConPatIn data_con_RDR (map VarPatIn as_needed)
- con2_pat = ConPatIn data_con_RDR (map VarPatIn bs_needed)
+ con1_pat = mkConPat data_con_RDR as_needed
+ con2_pat = mkConPat data_con_RDR bs_needed
- data_con_RDR = qual_orig_name data_con
+ 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)
+ in careful_compare_Case tycon ty eq_expr (HsVar a) (HsVar b)
default_rhs | null nullary_cons = impossible_Expr -- Keep desugarer from complaining about
-- inexhaustive patterns
tycon_loc = getSrcLoc tycon
----- enum-flavored: ---------------------------
- min_bound_enum = mk_easy_FunMonoBind tycon_loc minBound_RDR [] [] (HsVar data_con_1_RDR)
- max_bound_enum = mk_easy_FunMonoBind tycon_loc maxBound_RDR [] [] (HsVar data_con_N_RDR)
+ 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 = qual_orig_name data_con_1
- data_con_N_RDR = qual_orig_name data_con_N
+ 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 = mk_easy_FunMonoBind tycon_loc minBound_RDR [] [] $
+ min_bound_1con = mkVarMonoBind tycon_loc minBound_RDR $
mkHsVarApps data_con_1_RDR (nOfThem arity minBound_RDR)
- max_bound_1con = mk_easy_FunMonoBind tycon_loc maxBound_RDR [] [] $
+ max_bound_1con = mkVarMonoBind tycon_loc maxBound_RDR $
mkHsVarApps data_con_1_RDR (nOfThem arity maxBound_RDR)
\end{code}
enum_range
= mk_easy_FunMonoBind tycon_loc range_RDR
- [TuplePatIn [a_Pat, b_Pat] Boxed] [] $
+ [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]) $
enum_index
= mk_easy_FunMonoBind tycon_loc index_RDR
- [AsPatIn c_RDR (TuplePatIn [a_Pat, wildPat] Boxed),
+ [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)] (
rhs = mkHsVarApps mkInt_RDR [c_RDR]
in
HsCase
- (genOpApp (HsVar dh_RDR) minusH_RDR (HsVar ah_RDR))
- [mkSimpleMatch [VarPatIn c_RDR] rhs placeHolderType tycon_loc]
+ (genOpApp (HsVar dh_RDR) minusInt_RDR (HsVar ah_RDR))
+ [mkSimpleMatch [VarPat c_RDR] rhs placeHolderType tycon_loc]
tycon_loc
))
) {-else-} (
- HsApp (HsVar error_RDR) (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"))))
)
tycon_loc)
enum_inRange
= mk_easy_FunMonoBind tycon_loc inRange_RDR
- [TuplePatIn [a_Pat, b_Pat] Boxed, c_Pat] [] (
+ [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) geH_RDR (HsVar ah_RDR)) (
- (genOpApp (HsVar ch_RDR) leH_RDR (HsVar bh_RDR))
+ HsIf (genOpApp (HsVar ch_RDR) geInt_RDR (HsVar ah_RDR)) (
+ (genOpApp (HsVar ch_RDR) leInt_RDR (HsVar bh_RDR))
) {-else-} (
false_Expr
) tycon_loc))))
data_con
= case maybeTyConSingleCon tycon of -- just checking...
Nothing -> panic "get_Ix_binds"
- Just dc -> if (any isUnLiftedType (dataConOrigArgTys dc)) then
- error ("ERROR: Can't derive Ix for a single-constructor type with primitive argument types: "++tycon_str)
- else
- dc
+ 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 = qual_orig_name 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 = ConPatIn data_con_RDR (map VarPatIn xs)
+ con_pat xs = mkConPat data_con_RDR xs
con_expr = mkHsVarApps data_con_RDR cs_needed
--------------------------------------------------------------
single_con_range
= mk_easy_FunMonoBind tycon_loc range_RDR
- [TuplePatIn [con_pat as_needed, con_pat bs_needed] Boxed] [] $
- HsDo ListComp stmts tycon_loc
+ [TuplePat [con_pat as_needed, con_pat bs_needed] Boxed] [] $
+ mkHsDo ListComp stmts tycon_loc
where
stmts = zipWith3Equal "single_con_range" mk_qual as_needed bs_needed cs_needed
++
[ResultStmt con_expr tycon_loc]
- mk_qual a b c = BindStmt (VarPatIn c)
+ 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 tycon_loc index_RDR
- [TuplePatIn [con_pat as_needed, con_pat bs_needed] Boxed,
+ [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
range_size
= mk_easy_FunMonoBind tycon_loc rangeSize_RDR
- [TuplePatIn [a_Pat, b_Pat] Boxed] [] (
+ [TuplePat [a_Pat, b_Pat] Boxed] [] (
genOpApp (
(mkHsApps index_RDR [ExplicitTuple [a_Expr, b_Expr] Boxed,
b_Expr])
------------------
single_con_inRange
= mk_easy_FunMonoBind tycon_loc inRange_RDR
- [TuplePatIn [con_pat as_needed, con_pat bs_needed] Boxed,
+ [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))
instance Read T where
readPrec =
- block
+ parens
( prec 4 (
do x <- ReadP.step Read.readPrec
Symbol "%%" <- Lex.lex
+++
prec appPrec (
do Ident "T1" <- Lex.lex
- Single '{' <- Lex.lex
+ Punc '{' <- Lex.lex
Ident "f1" <- Lex.lex
- Single '=' <- Lex.lex
+ Punc '=' <- Lex.lex
x <- ReadP.reset Read.readPrec
- Single '}' <- Lex.lex
+ Punc '}' <- Lex.lex
return (T1 { f1 = x }))
+++
prec appPrec (
where
-----------------------------------------------------------------------
default_binds
- = mk_easy_FunMonoBind loc readList_RDR [] [] (HsVar readListDefault_RDR)
+ = mkVarMonoBind loc readList_RDR (HsVar readListDefault_RDR)
`AndMonoBinds`
- mk_easy_FunMonoBind loc readListPrec_RDR [] [] (HsVar readListPrecDefault_RDR)
+ mkVarMonoBind loc readListPrec_RDR (HsVar readListPrecDefault_RDR)
-----------------------------------------------------------------------
loc = getSrcLoc tycon
data_cons = tyConDataCons tycon
(nullary_cons, non_nullary_cons) = partition isNullaryDataCon data_cons
- read_prec = mk_easy_FunMonoBind loc readPrec_RDR [] []
- (HsApp (HsVar parens_RDR) read_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] -> [HsDo DoExpr [BindStmt (ident_pat (data_con_str con)) lex loc,
- result_stmt con []] loc]
+ [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 (qual_orig_name con))]
+ HsApp (HsVar returnM_RDR) (HsVar (getRdrName con))]
Boxed
read_non_nullary_con data_con
- = mkHsApps prec_RDR [mkHsIntLit prec, HsDo DoExpr stmts loc]
+ = mkHsApps prec_RDR [mkHsIntLit prec, mkHsDo DoExpr stmts loc]
where
stmts | is_infix = infix_stmts
| length labels > 0 = lbl_stmts
| otherwise = prefix_stmts
prefix_stmts -- T a b c
- = [BindStmt (ident_pat (data_con_str data_con)) lex loc]
- ++ map read_arg as_needed
+ = [bindLex (ident_pat (data_con_str data_con))]
+ ++ read_args
++ [result_stmt data_con as_needed]
infix_stmts -- a %% b
- = [read_arg a1,
- BindStmt (symbol_pat (data_con_str data_con)) lex loc,
- read_arg a2,
+ = [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 }
- = [BindStmt (ident_pat (data_con_str data_con)) lex loc,
- read_punc '{']
- ++ concat (intersperse [read_punc ','] field_stmts)
- ++ [read_punc '}', result_stmt data_con as_needed]
+ = [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
nullary_con = con_arity == 0
labels = dataConFieldLabels data_con
lab_fields = length labels
- dc_nm = getName data_con
+ dc_nm = getName data_con
is_infix = isDataSymOcc (getOccName dc_nm)
as_needed = take con_arity as_RDRs
- (a1:a2:_) = as_needed
-
- prec | not is_infix = appPrecedence
- | otherwise = getPrecedence get_fixity dc_nm
+ 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 (qual_orig_name c) as
+ con_app c as = mkHsVarApps (getRdrName c) as
- lex = HsVar lexP_RDR
- single_pat c = ConPatIn single_RDR [LitPatIn (mkHsChar c)] -- Single 'x'
- ident_pat s = ConPatIn ident_RDR [LitPatIn s] -- Ident "foo"
- symbol_pat s = ConPatIn symbol_RDR [LitPatIn s] -- Symbol ">>"
+ 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 ">>"
- lbl_str :: FieldLabel -> HsLit
- lbl_str lbl = mkHsString (occNameUserString (getOccName (fieldLabelName lbl)))
data_con_str con = mkHsString (occNameUserString (getOccName con))
- read_punc c = BindStmt (single_pat c) lex loc
- read_arg a = BindStmt (VarPatIn a) (mkHsVarApps step_RDR [readPrec_RDR]) loc
+ 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 = [BindStmt (ident_pat (lbl_str lbl)) lex loc,
- read_punc '=',
- BindStmt (VarPatIn a) (mkHsVarApps reset_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}
%* *
%************************************************************************
+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
where
tycon_loc = getSrcLoc tycon
-----------------------------------------------------------------------
- show_list = mk_easy_FunMonoBind tycon_loc showList_RDR [] []
+ show_list = mkVarMonoBind tycon_loc showList_RDR
(HsApp (HsVar showList___RDR) (HsPar (HsApp (HsVar showsPrec_RDR) (mkHsIntLit 0))))
-----------------------------------------------------------------------
shows_prec = mk_FunMonoBind tycon_loc showsPrec_RDR (map pats_etc (tyConDataCons tycon))
pats_etc data_con
| nullary_con = -- skip the showParen junk...
ASSERT(null bs_needed)
- ([wildPat, con_pat], show_con)
+ ([wildPat, con_pat], mk_showString_app con_str)
| otherwise =
([a_Pat, con_pat],
- showParen_Expr (HsPar (genOpApp a_Expr ge_RDR (HsLit (HsInt paren_prec_limit))))
+ showParen_Expr (HsPar (genOpApp a_Expr ge_RDR (HsLit (HsInt con_prec_plus_one))))
(HsPar (nested_compose_Expr show_thingies)))
where
- data_con_RDR = qual_orig_name data_con
- con_arity = dataConSourceArity data_con
- bs_needed = take con_arity bs_RDRs
- con_pat = ConPatIn data_con_RDR (map VarPatIn bs_needed)
- nullary_con = con_arity == 0
- labels = dataConFieldLabels data_con
- lab_fields = length labels
+ 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
- dc_occ_nm_str = occNameUserString dc_occ_nm
-
- is_infix = isDataSymOcc dc_occ_nm
+ con_str = occNameUserString dc_occ_nm
-
- show_con
- | is_infix = mk_showString_app (' ':dc_occ_nm_str)
- | otherwise = mk_showString_app (dc_occ_nm_str ++ space_ocurly_maybe)
- where
- space_ocurly_maybe
- | nullary_con = ""
- | lab_fields == 0 = " "
- | otherwise = "{"
-
-
- show_all con fs@(x:xs)
- | is_infix = x:con:xs
- | otherwise =
- let
- ccurly_maybe
- | lab_fields > 0 = [mk_showString_app "}"]
- | otherwise = []
- in
- con:fs ++ ccurly_maybe
-
- show_thingies = show_all show_con real_show_thingies_with_labs
+ 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 ++ "=")
+ 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)
- -- legal, but rare.
- is_op = isSymOcc occ_nm
- the_name
- | is_op = '(':nm ++ ")"
- | otherwise = nm
-
nm = occNameUserString occ_nm
-
-
- mk_showString_app str = HsApp (HsVar showString_RDR)
- (HsLit (mkHsString str))
-
- prec_cons = getLRPrecs is_infix get_fixity dc_nm
-
- real_show_thingies
- | is_infix =
- [ mkHsApps showsPrec_RDR [HsLit (HsInt p), HsVar b]
- | (p,b) <- zip prec_cons bs_needed ]
- | otherwise =
- [ mkHsApps showsPrec_RDR [mkHsIntLit 10, HsVar b]
- | b <- bs_needed ]
-
- real_show_thingies_with_labs
- | lab_fields == 0 = intersperse (HsVar showSpace_RDR) real_show_thingies
- | otherwise = --Assumption: no of fields == no of labelled fields
- -- (and in same order)
- concat $
- intersperse ([mk_showString_app ","]) $ -- Using SLIT()s containing ,s spells trouble.
- zipWithEqual "gen_Show_binds"
- (\ a b -> [a,b])
- (map show_label labels)
- real_show_thingies
+ 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 ]
- {-
- c.f. Figure 16 and 17 in Haskell 1.1 report
- -}
- paren_prec_limit
- | not is_infix = appPrecedence + 1
- | otherwise = getPrecedence get_fixity dc_nm + 1
-
+ -- 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}
-getLRPrecs :: Bool -> FixityEnv -> Name -> [Integer]
-getLRPrecs is_infix get_fixity nm = [lp, rp]
- where
- {-
- Figuring out the fixities of the arguments to a constructor,
- cf. Figures 16-18 in Haskell 1.1 report.
- -}
- (con_left_assoc, con_right_assoc) = isLRAssoc get_fixity nm
- paren_con_prec = getPrecedence get_fixity nm
-
- lp
- | not is_infix = appPrecedence + 1
- | con_left_assoc = paren_con_prec
- | otherwise = paren_con_prec + 1
-
- rp
- | not is_infix = appPrecedence + 1
- | con_right_assoc = paren_con_prec
- | otherwise = paren_con_prec + 1
+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
+appPrecedence = fromIntegral maxPrecedence + 1
+ -- One more than the precedence of the most
+ -- tightly-binding operator
getPrecedence :: FixityEnv -> Name -> Integer
getPrecedence get_fixity nm
%************************************************************************
%* *
+\subsection{Typeable}
+%* *
+%************************************************************************
+
+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_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}
+
+
+
+%************************************************************************
+%* *
+\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{Generating extra binds (@con2tag@ and @tag2con@)}
%* *
%************************************************************************
gen_tag_n_con_monobind (rdr_name, tycon, GenCon2Tag)
| lots_of_constructors
- = mk_FunMonoBind (getSrcLoc tycon) rdr_name
- [([VarPatIn a_RDR], HsApp getTag_Expr a_Expr)]
+ = mk_FunMonoBind loc rdr_name [([], get_tag_rhs)]
| otherwise
- = mk_FunMonoBind (getSrcLoc tycon) rdr_name (map mk_stuff (tyConDataCons tycon))
+ = mk_FunMonoBind loc rdr_name (map mk_stuff (tyConDataCons tycon))
where
+ 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 var
- = ([pat], HsLit (HsIntPrim (toInteger ((dataConTag var) - fIRST_TAG))))
- where
- pat = ConPatIn var_RDR (nOfThem (dataConSourceArity var) WildPatIn)
- var_RDR = qual_orig_name var
+ 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
- [([ConPatIn mkInt_RDR [VarPatIn a_RDR]],
+ [([mkConPat mkInt_RDR [a_RDR]],
ExprWithTySig (HsApp tagToEnum_Expr a_Expr)
- (HsTyVar (qual_orig_name tycon)))]
+ (HsTyVar (getRdrName tycon)))]
gen_tag_n_con_monobind (rdr_name, tycon, GenMaxTag)
- = mk_easy_FunMonoBind (getSrcLoc tycon)
- rdr_name [] [] (HsApp (HsVar mkInt_RDR) (HsLit (HsIntPrim max_tag)))
+ = mkVarMonoBind (getSrcLoc tycon) rdr_name
+ (HsApp (HsVar mkInt_RDR) (HsLit (HsIntPrim max_tag)))
where
max_tag = case (tyConDataCons tycon) of
data_cons -> toInteger ((length data_cons) - fIRST_TAG)
\end{verbatim}
\begin{code}
+mkVarMonoBind :: SrcLoc -> RdrName -> RdrNameHsExpr -> RdrNameMonoBinds
+mkVarMonoBind loc var rhs = mk_easy_FunMonoBind loc var [] [] rhs
+
mk_easy_FunMonoBind :: SrcLoc -> RdrName -> [RdrNamePat]
-> [RdrNameMonoBinds] -> RdrNameHsExpr
-> RdrNameMonoBinds
= 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 (andMonoBindList binds) [] Recursive)
+ = 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.
= Match (map paren pats) Nothing
(GRHSs (unguardedRHS expr loc) binds placeHolderType)
where
- paren p@(VarPatIn _) = p
- paren other_p = ParPatIn other_p
+ paren p@(VarPat _) = p
+ paren other_p = ParPat other_p
\end{code}
\begin{code}
mkHsVarApps f xs = foldl HsApp (HsVar f) (map HsVar xs)
mkHsIntLit n = HsLit (HsInt n)
-mkHsString s = HsString (_PK_ s)
+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 ::
- RdrName
- -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr
+ RdrNameHsExpr -- What to do for equality
-> RdrNameHsExpr -> RdrNameHsExpr
-> RdrNameHsExpr
careful_compare_Case :: -- checks for primitive types...
- Type
- -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr
+ 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 fun lt eq gt a b
- = HsCase (HsPar (HsApp (HsApp (HsVar fun) a) b)) {-of-}
- [mkSimpleMatch [ConPatIn ltTag_RDR []] lt placeHolderType generatedSrcLoc,
- mkSimpleMatch [ConPatIn eqTag_RDR []] eq placeHolderType generatedSrcLoc,
- mkSimpleMatch [ConPatIn gtTag_RDR []] gt placeHolderType generatedSrcLoc]
+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 ty lt eq gt a b
- | not (isUnLiftedType ty) =
- compare_gen_Case compare_RDR lt eq gt 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) lt gt 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
+ 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) <- tyids, ty `tcEqType` ty']
+ res = [id | (ty',id) <- tbl, ty `tcEqType` ty']
eq_op_tbl =
- [(charPrimTy, eqH_Char_RDR)
- ,(intPrimTy, eqH_Int_RDR)
- ,(wordPrimTy, eqH_Word_RDR)
- ,(addrPrimTy, eqH_Addr_RDR)
- ,(floatPrimTy, eqH_Float_RDR)
- ,(doublePrimTy, eqH_Double_RDR)
+ [(charPrimTy, eqChar_RDR)
+ ,(intPrimTy, eqInt_RDR)
+ ,(wordPrimTy, eqWord_RDR)
+ ,(addrPrimTy, eqAddr_RDR)
+ ,(floatPrimTy, eqFloat_RDR)
+ ,(doublePrimTy, eqDouble_RDR)
]
lt_op_tbl =
- [(charPrimTy, ltH_Char_RDR)
- ,(intPrimTy, ltH_Int_RDR)
- ,(wordPrimTy, ltH_Word_RDR)
- ,(addrPrimTy, ltH_Addr_RDR)
- ,(floatPrimTy, ltH_Float_RDR)
- ,(doublePrimTy, ltH_Double_RDR)
+ [(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)
]
-----------------------------------------------------------------------
-----------------------------------------------------------------------
-eq_Expr :: Type -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr
-eq_Expr ty a b = genOpApp a eq_op b
+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_op_tbl ty
+ assoc_ty_id "Eq" tycon eq_op_tbl ty
\end{code}
untag_Expr tycon [] expr = expr
untag_Expr tycon ((untag_this, put_tag_here) : more) expr
= HsCase (HsPar (HsApp (con2tag_Expr tycon) (HsVar untag_this))) {-of-}
- [mkSimpleMatch [VarPatIn put_tag_here] (untag_Expr tycon more expr) placeHolderType generatedSrcLoc]
+ [mkSimpleMatch [VarPat put_tag_here] (untag_Expr tycon more expr) placeHolderType generatedSrcLoc]
generatedSrcLoc
cmp_tags_Expr :: RdrName -- Comparison op
-- 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 (_PK_ "Urk! in TcGenDeriv")))
+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 (_PK_ (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 (_PK_ ("toEnum{" ++ tp ++ "}: tag (")))))
+ (HsLit (HsString (mkFastString ("toEnum{" ++ tp ++ "}: tag (")))))
(HsApp (HsApp (HsApp
(HsVar showsPrec_RDR)
(mkHsIntLit 0))
(HsVar a_RDR))
(HsApp (HsApp
(HsVar append_RDR)
- (HsLit (HsString (_PK_ ") is outside of enumeration's range (0,"))))
+ (HsLit (HsString (mkFastString ") is outside of enumeration's range (0,"))))
(HsApp (HsApp (HsApp
(HsVar showsPrec_RDR)
(mkHsIntLit 0))
(HsVar maxtag))
- (HsLit (HsString (_PK_ ")")))))))
+ (HsLit (HsString (mkFastString ")")))))))
parenify e@(HsVar _) = e
parenify e = HsPar e
\end{code}
\begin{code}
-qual_orig_name n = nameRdrName (getName n)
-varUnqual n = mkUnqual varName n
+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#")
cmp_eq_RDR = varUnqual FSLIT("cmp_eq")
rangeSize_RDR = varUnqual FSLIT("rangeSize")
-as_RDRs = [ varUnqual (_PK_ ("a"++show i)) | i <- [(1::Int) .. ] ]
-bs_RDRs = [ varUnqual (_PK_ ("b"++show i)) | i <- [(1::Int) .. ] ]
-cs_RDRs = [ varUnqual (_PK_ ("c"++show i)) | i <- [(1::Int) .. ] ]
+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
true_Expr = HsVar true_RDR
getTag_Expr = HsVar getTag_RDR
-tagToEnum_Expr = HsVar tagToEnumH_RDR
+tagToEnum_Expr = HsVar tagToEnum_RDR
con2tag_Expr tycon = HsVar (con2tag_RDR tycon)
-wildPat = WildPatIn
-zz_a_Pat = VarPatIn zz_a_RDR
-a_Pat = VarPatIn a_RDR
-b_Pat = VarPatIn b_RDR
-c_Pat = VarPatIn c_RDR
-d_Pat = VarPatIn d_RDR
+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 (_PK_ ("con2tag_" ++ occNameString (getOccName tycon) ++ "#"))
-tag2con_RDR tycon = varUnqual (_PK_ ("tag2con_" ++ occNameString (getOccName tycon) ++ "#"))
-maxtag_RDR tycon = varUnqual (_PK_ ("maxtag_" ++ occNameString (getOccName tycon) ++ "#"))
+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}
+
+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}
projects / ghc-hetmet.git / blobdiff