X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2FdeSugar%2FDsUtils.lhs;h=3411ebf2c145fc14866edb4457f80735ab4d77ae;hb=6e5df3a4551b8d8b83e936b3f7b52edfc778ca8a;hp=e289d2439f1a72744bd55df7112569b8f84987f7;hpb=69e14f75a4b031e489b7774914e5a176409cea78;p=ghc-hetmet.git diff --git a/ghc/compiler/deSugar/DsUtils.lhs b/ghc/compiler/deSugar/DsUtils.lhs index e289d24..3411ebf 100644 --- a/ghc/compiler/deSugar/DsUtils.lhs +++ b/ghc/compiler/deSugar/DsUtils.lhs @@ -10,6 +10,8 @@ module DsUtils ( CanItFail(..), EquationInfo(..), MatchResult(..), EqnNo, EqnSet, + tidyLitPat, tidyNPat, + mkDsLet, mkDsLets, cantFailMatchResult, extractMatchResult, @@ -18,9 +20,11 @@ module DsUtils ( mkCoLetsMatchResult, mkGuardedMatchResult, mkCoPrimCaseMatchResult, mkCoAlgCaseMatchResult, - mkErrorAppDs, mkNilExpr, mkConsExpr, + mkErrorAppDs, mkNilExpr, mkConsExpr, mkListExpr, + mkIntExpr, mkCharExpr, + mkStringLit, mkStringLitFS, mkIntegerExpr, - mkSelectorBinds, mkTupleExpr, mkTupleSelector, + mkSelectorBinds, mkTupleExpr, mkTupleSelector, mkCoreTup, selectMatchVar ) where @@ -29,35 +33,82 @@ module DsUtils ( import {-# SOURCE #-} Match ( matchSimply ) -import HsSyn ( OutPat(..) ) -import TcHsSyn ( TypecheckedPat ) -import DsHsSyn ( outPatType, collectTypedPatBinders ) +import HsSyn +import TcHsSyn ( TypecheckedPat, hsPatType ) import CoreSyn import DsMonad -import CoreUtils ( coreExprType ) -import PrelInfo ( iRREFUT_PAT_ERROR_ID ) +import CoreUtils ( exprType, mkIfThenElse, mkCoerce ) +import MkId ( iRREFUT_PAT_ERROR_ID, mkReboxingAlt, mkNewTypeBody ) import Id ( idType, Id, mkWildId ) -import Const ( Literal(..), Con(..) ) +import Literal ( Literal(..), inIntRange, tARGET_MAX_INT ) import TyCon ( isNewTyCon, tyConDataCons ) -import DataCon ( DataCon, StrictnessMark, maybeMarkedUnboxed, dataConStrictMarks, - dataConArgTys, dataConId - ) -import Type ( mkFunTy, isUnLiftedType, splitAlgTyConApp, unUsgTy, - Type - ) -import TysWiredIn ( unitDataCon, tupleCon, stringTy, unitTy, unitDataCon, - nilDataCon, consDataCon - ) +import DataCon ( DataCon, dataConSourceArity ) +import Type ( mkFunTy, isUnLiftedType, Type, splitTyConApp ) +import TcType ( tcTyConAppTyCon, isIntTy, isFloatTy, isDoubleTy ) +import TysPrim ( intPrimTy ) +import TysWiredIn ( nilDataCon, consDataCon, + tupleCon, + unitDataConId, unitTy, + charTy, charDataCon, + intTy, intDataCon, smallIntegerDataCon, + floatDataCon, + doubleDataCon, + stringTy, isPArrFakeCon ) +import BasicTypes ( Boxity(..) ) import UniqSet ( mkUniqSet, minusUniqSet, isEmptyUniqSet, UniqSet ) +import PrelNames ( unpackCStringName, unpackCStringUtf8Name, + plusIntegerName, timesIntegerName, + lengthPName, indexPName ) import Outputable +import UnicodeUtil ( intsToUtf8, stringToUtf8 ) +import Util ( isSingleton, notNull ) +import FastString \end{code} + %************************************************************************ %* * -%* Building lets +\subsection{Tidying lit pats} +%* * +%************************************************************************ + +\begin{code} +tidyLitPat :: HsLit -> TypecheckedPat -> TypecheckedPat +tidyLitPat (HsChar c) pat = mkCharLitPat c +tidyLitPat lit pat = pat + +tidyNPat :: HsLit -> Type -> TypecheckedPat -> TypecheckedPat +tidyNPat (HsString s) _ pat + | lengthFS s <= 1 -- Short string literals only + = foldr (\c pat -> mkPrefixConPat consDataCon [mkCharLitPat c,pat] stringTy) + (mkNilPat stringTy) (unpackIntFS s) + -- The stringTy is the type of the whole pattern, not + -- the type to instantiate (:) or [] with! + where + +tidyNPat lit lit_ty default_pat + | isIntTy lit_ty = mkPrefixConPat intDataCon [LitPat (mk_int lit)] lit_ty + | isFloatTy lit_ty = mkPrefixConPat floatDataCon [LitPat (mk_float lit)] lit_ty + | isDoubleTy lit_ty = mkPrefixConPat doubleDataCon [LitPat (mk_double lit)] lit_ty + | otherwise = default_pat + + where + mk_int (HsInteger i) = HsIntPrim i + + mk_float (HsInteger i) = HsFloatPrim (fromInteger i) + mk_float (HsRat f _) = HsFloatPrim f + + mk_double (HsInteger i) = HsDoublePrim (fromInteger i) + mk_double (HsRat f _) = HsDoublePrim f +\end{code} + + +%************************************************************************ +%* * +\subsection{Building lets} %* * %************************************************************************ @@ -78,7 +129,7 @@ mkDsLets binds body = foldr mkDsLet body binds %************************************************************************ %* * -%* Selecting match variables +\subsection{ Selecting match variables} %* * %************************************************************************ @@ -92,7 +143,7 @@ selectMatchVar :: TypecheckedPat -> DsM Id selectMatchVar (VarPat var) = returnDs var selectMatchVar (AsPat var pat) = returnDs var selectMatchVar (LazyPat pat) = selectMatchVar pat -selectMatchVar other_pat = newSysLocalDs (outPatType other_pat) -- OK, better make up one... +selectMatchVar other_pat = newSysLocalDs (hsPatType other_pat) -- OK, better make up one... \end{code} @@ -199,10 +250,10 @@ mkCoPrimCaseMatchResult var match_alts where mk_case fail = mapDs (mk_alt fail) match_alts `thenDs` \ alts -> - returnDs (Case (Var var) var (alts ++ [(DEFAULT, [], fail)])) + returnDs (Case (Var var) var ((DEFAULT, [], fail) : alts)) mk_alt fail (lit, MatchResult _ body_fn) = body_fn fail `thenDs` \ body -> - returnDs (Literal lit, [], body) + returnDs (LitAlt lit, [], body) mkCoAlgCaseMatchResult :: Id -- Scrutinee @@ -211,26 +262,27 @@ mkCoAlgCaseMatchResult :: Id -- Scrutinee mkCoAlgCaseMatchResult var match_alts | isNewTyCon tycon -- Newtype case; use a let - = ASSERT( newtype_sanity ) - mkCoLetsMatchResult [coercion_bind] match_result + = ASSERT( null (tail match_alts) && null (tail arg_ids) ) + mkCoLetsMatchResult [NonRec arg_id newtype_rhs] match_result + + | isPArrFakeAlts match_alts -- Sugared parallel array; use a literal case + = MatchResult CanFail mk_parrCase | otherwise -- Datatype case; use a case = MatchResult fail_flag mk_case where -- Common stuff scrut_ty = idType var - (tycon, tycon_arg_tys, _) = splitAlgTyConApp scrut_ty + tycon = tcTyConAppTyCon scrut_ty -- Newtypes must be opaque here -- Stuff for newtype - (con_id, arg_ids, match_result) = head match_alts - arg_id = head arg_ids - coercion_bind = NonRec arg_id (Note (Coerce (idType arg_id) scrut_ty) (Var var)) - newtype_sanity = null (tail match_alts) && null (tail arg_ids) - + (_, arg_ids, match_result) = head match_alts + arg_id = head arg_ids + newtype_rhs = mkNewTypeBody tycon (idType arg_id) (Var var) + -- Stuff for data types - data_cons = tyConDataCons tycon - - match_results = [match_result | (_,_,match_result) <- match_alts] + data_cons = tyConDataCons tycon + match_results = [match_result | (_,_,match_result) <- match_alts] fail_flag | exhaustive_case = foldr1 orFail [can_it_fail | MatchResult can_it_fail _ <- match_results] @@ -239,13 +291,12 @@ mkCoAlgCaseMatchResult var match_alts wild_var = mkWildId (idType var) mk_case fail = mapDs (mk_alt fail) match_alts `thenDs` \ alts -> - returnDs (Case (Var var) wild_var (alts ++ mk_default fail)) + returnDs (Case (Var var) wild_var (mk_default fail ++ alts)) mk_alt fail (con, args, MatchResult _ body_fn) - = body_fn fail `thenDs` \ body -> - rebuildConArgs con args (dataConStrictMarks con) body - `thenDs` \ (body', real_args) -> - returnDs (DataCon con, real_args, body') + = body_fn fail `thenDs` \ body -> + getUniquesDs `thenDs` \ us -> + returnDs (mkReboxingAlt us con args body) mk_default fail | exhaustive_case = [] | otherwise = [(DEFAULT, [], fail)] @@ -254,37 +305,73 @@ mkCoAlgCaseMatchResult var match_alts = mkUniqSet data_cons `minusUniqSet` mkUniqSet [ con | (con, _, _) <- match_alts] exhaustive_case = isEmptyUniqSet un_mentioned_constructors --- for each constructor we match on, we might need to re-pack some --- of the strict fields if they are unpacked in the constructor. - -rebuildConArgs - :: DataCon -- the con we're matching on - -> [Id] -- the source-level args - -> [StrictnessMark] -- the strictness annotations (per-arg) - -> CoreExpr -- the body - -> DsM (CoreExpr, [Id]) - -rebuildConArgs con [] stricts body = returnDs (body, []) -rebuildConArgs con (arg:args) stricts body | isTyVar arg - = rebuildConArgs con args stricts body `thenDs` \ (body', args') -> - returnDs (body',arg:args') -rebuildConArgs con (arg:args) (str:stricts) body - = rebuildConArgs con args stricts body `thenDs` \ (body', real_args) -> - case maybeMarkedUnboxed str of - Just (pack_con, tys) -> - let id_tys = dataConArgTys pack_con ty_args in - newSysLocalsDs id_tys `thenDs` \ unpacked_args -> - returnDs ( - mkDsLet (NonRec arg (Con (DataCon pack_con) - (map Type ty_args ++ - map Var unpacked_args))) body', - unpacked_args ++ real_args - ) - _ -> returnDs (body', arg:real_args) - - where ty_args = case splitAlgTyConApp (idType arg) of { (_,args,_) -> args } + -- Stuff for parallel arrays + -- + -- * the following is to desugar cases over fake constructors for + -- parallel arrays, which are introduced by `tidy1' in the `PArrPat' + -- case + -- + -- Concerning `isPArrFakeAlts': + -- + -- * it is *not* sufficient to just check the type of the type + -- constructor, as we have to be careful not to confuse the real + -- representation of parallel arrays with the fake constructors; + -- moreover, a list of alternatives must not mix fake and real + -- constructors (this is checked earlier on) + -- + -- FIXME: We actually go through the whole list and make sure that + -- either all or none of the constructors are fake parallel + -- array constructors. This is to spot equations that mix fake + -- constructors with the real representation defined in + -- `PrelPArr'. It would be nicer to spot this situation + -- earlier and raise a proper error message, but it can really + -- only happen in `PrelPArr' anyway. + -- + isPArrFakeAlts [(dcon, _, _)] = isPArrFakeCon dcon + isPArrFakeAlts ((dcon, _, _):alts) = + case (isPArrFakeCon dcon, isPArrFakeAlts alts) of + (True , True ) -> True + (False, False) -> False + _ -> + panic "DsUtils: You may not mix `[:...:]' with `PArr' patterns" + -- + mk_parrCase fail = + dsLookupGlobalId lengthPName `thenDs` \lengthP -> + unboxAlt `thenDs` \alt -> + returnDs (Case (len lengthP) (mkWildId intTy) [alt]) + where + elemTy = case splitTyConApp (idType var) of + (_, [elemTy]) -> elemTy + _ -> panic panicMsg + panicMsg = "DsUtils.mkCoAlgCaseMatchResult: not a parallel array?" + len lengthP = mkApps (Var lengthP) [Type elemTy, Var var] + -- + unboxAlt = + newSysLocalDs intPrimTy `thenDs` \l -> + dsLookupGlobalId indexPName `thenDs` \indexP -> + mapDs (mkAlt indexP) match_alts `thenDs` \alts -> + returnDs (DataAlt intDataCon, [l], (Case (Var l) wild (dft : alts))) + where + wild = mkWildId intPrimTy + dft = (DEFAULT, [], fail) + -- + -- each alternative matches one array length (corresponding to one + -- fake array constructor), so the match is on a literal; each + -- alternative's body is extended by a local binding for each + -- constructor argument, which are bound to array elements starting + -- with the first + -- + mkAlt indexP (con, args, MatchResult _ bodyFun) = + bodyFun fail `thenDs` \body -> + returnDs (LitAlt lit, [], mkDsLets binds body) + where + lit = MachInt $ toInteger (dataConSourceArity con) + binds = [NonRec arg (indexExpr i) | (i, arg) <- zip [1..] args] + -- + indexExpr i = mkApps (Var indexP) [Type elemTy, Var var, mkIntExpr i] \end{code} + %************************************************************************ %* * \subsection{Desugarer's versions of some Core functions} @@ -301,11 +388,84 @@ mkErrorAppDs err_id ty msg = getSrcLocDs `thenDs` \ src_loc -> let full_msg = showSDoc (hcat [ppr src_loc, text "|", text msg]) + core_msg = Lit (MachStr (mkFastString (stringToUtf8 full_msg))) in - returnDs (mkApps (Var err_id) [(Type . unUsgTy) ty, mkStringLit full_msg]) - -- unUsgTy *required* -- KSW 1999-04-07 + returnDs (mkApps (Var err_id) [Type ty, core_msg]) \end{code} + +************************************************************* +%* * +\subsection{Making literals} +%* * +%************************************************************************ + +\begin{code} +mkCharExpr :: Int -> CoreExpr -- Returns C# c :: Int +mkIntExpr :: Integer -> CoreExpr -- Returns I# i :: Int +mkIntegerExpr :: Integer -> DsM CoreExpr -- Result :: Integer +mkStringLit :: String -> DsM CoreExpr -- Result :: String +mkStringLitFS :: FastString -> DsM CoreExpr -- Result :: String + +mkIntExpr i = mkConApp intDataCon [mkIntLit i] +mkCharExpr c = mkConApp charDataCon [mkLit (MachChar c)] + +mkIntegerExpr i + | inIntRange i -- Small enough, so start from an Int + = returnDs (mkSmallIntegerLit i) + +-- Special case for integral literals with a large magnitude: +-- They are transformed into an expression involving only smaller +-- integral literals. This improves constant folding. + + | otherwise -- Big, so start from a string + = dsLookupGlobalId plusIntegerName `thenDs` \ plus_id -> + dsLookupGlobalId timesIntegerName `thenDs` \ times_id -> + let + plus a b = Var plus_id `App` a `App` b + times a b = Var times_id `App` a `App` b + + -- Transform i into (x1 + (x2 + (x3 + (...) * b) * b) * b) with abs xi <= b + horner :: Integer -> Integer -> CoreExpr + horner b i | abs q <= 1 = if r == 0 || r == i + then mkSmallIntegerLit i + else mkSmallIntegerLit r `plus` mkSmallIntegerLit (i-r) + | r == 0 = horner b q `times` mkSmallIntegerLit b + | otherwise = mkSmallIntegerLit r `plus` (horner b q `times` mkSmallIntegerLit b) + where + (q,r) = i `quotRem` b + + in + returnDs (horner tARGET_MAX_INT i) + +mkSmallIntegerLit i = mkConApp smallIntegerDataCon [mkIntLit i] + +mkStringLit str = mkStringLitFS (mkFastString str) + +mkStringLitFS str + | nullFastString str + = returnDs (mkNilExpr charTy) + + | lengthFS str == 1 + = let + the_char = mkCharExpr (headIntFS str) + in + returnDs (mkConsExpr charTy the_char (mkNilExpr charTy)) + + | all safeChar int_chars + = dsLookupGlobalId unpackCStringName `thenDs` \ unpack_id -> + returnDs (App (Var unpack_id) (Lit (MachStr str))) + + | otherwise + = dsLookupGlobalId unpackCStringUtf8Name `thenDs` \ unpack_id -> + returnDs (App (Var unpack_id) (Lit (MachStr (mkFastString (intsToUtf8 int_chars))))) + + where + int_chars = unpackIntFS str + safeChar c = c >= 1 && c <= 0xFF +\end{code} + + %************************************************************************ %* * \subsection[mkSelectorBind]{Make a selector bind} @@ -314,10 +474,10 @@ mkErrorAppDs err_id ty msg This is used in various places to do with lazy patterns. For each binder $b$ in the pattern, we create a binding: - +\begin{verbatim} b = case v of pat' -> b' - -where pat' is pat with each binder b cloned into b'. +\end{verbatim} +where @pat'@ is @pat@ with each binder @b@ cloned into @b'@. ToDo: making these bindings should really depend on whether there's much work to be done per binding. If the pattern is complex, it @@ -337,69 +497,97 @@ mkSelectorBinds (VarPat v) val_expr = returnDs [(v, val_expr)] mkSelectorBinds pat val_expr - | length binders == 1 || is_simple_pat pat - = newSysLocalDs (coreExprType val_expr) `thenDs` \ val_var -> - - -- For the error message we don't use mkErrorAppDs to avoid - -- duplicating the string literal each time - newSysLocalDs stringTy `thenDs` \ msg_var -> - getSrcLocDs `thenDs` \ src_loc -> - let - full_msg = showSDoc (hcat [ppr src_loc, text "|", ppr pat]) - in - mapDs (mk_bind val_var msg_var) binders `thenDs` \ binds -> + | isSingleton binders || is_simple_pat pat + = -- Given p = e, where p binds x,y + -- we are going to make + -- v = p (where v is fresh) + -- x = case v of p -> x + -- y = case v of p -> x + + -- Make up 'v' + -- NB: give it the type of *pattern* p, not the type of the *rhs* e. + -- This does not matter after desugaring, but there's a subtle + -- issue with implicit parameters. Consider + -- (x,y) = ?i + -- Then, ?i is given type {?i :: Int}, a SourceType, which is opaque + -- to the desugarer. (Why opaque? Because newtypes have to be. Why + -- does it get that type? So that when we abstract over it we get the + -- right top-level type (?i::Int) => ...) + -- + -- So to get the type of 'v', use the pattern not the rhs. Often more + -- efficient too. + newSysLocalDs (hsPatType pat) `thenDs` \ val_var -> + + -- For the error message we make one error-app, to avoid duplication. + -- But we need it at different types... so we use coerce for that + mkErrorAppDs iRREFUT_PAT_ERROR_ID + unitTy (showSDoc (ppr pat)) `thenDs` \ err_expr -> + newSysLocalDs unitTy `thenDs` \ err_var -> + mapDs (mk_bind val_var err_var) binders `thenDs` \ binds -> returnDs ( (val_var, val_expr) : - (msg_var, mkStringLit full_msg) : + (err_var, err_expr) : binds ) | otherwise - = mkErrorAppDs iRREFUT_PAT_ERROR_ID tuple_ty (showSDoc (ppr pat)) `thenDs` \ error_expr -> - matchSimply val_expr LetMatch pat local_tuple error_expr `thenDs` \ tuple_expr -> + = mkErrorAppDs iRREFUT_PAT_ERROR_ID + tuple_ty (showSDoc (ppr pat)) `thenDs` \ error_expr -> + matchSimply val_expr PatBindRhs pat local_tuple error_expr `thenDs` \ tuple_expr -> newSysLocalDs tuple_ty `thenDs` \ tuple_var -> let - mk_tup_bind binder = (binder, mkTupleSelector binders binder tuple_var (Var tuple_var)) + mk_tup_bind binder + = (binder, mkTupleSelector binders binder tuple_var (Var tuple_var)) in returnDs ( (tuple_var, tuple_expr) : map mk_tup_bind binders ) where - binders = collectTypedPatBinders pat + binders = collectPatBinders pat local_tuple = mkTupleExpr binders - tuple_ty = coreExprType local_tuple + tuple_ty = exprType local_tuple - mk_bind scrut_var msg_var bndr_var - -- (mk_bind sv bv) generates - -- bv = case sv of { pat -> bv; other -> error-msg } + mk_bind scrut_var err_var bndr_var + -- (mk_bind sv err_var) generates + -- bv = case sv of { pat -> bv; other -> coerce (type-of-bv) err_var } -- Remember, pat binds bv - = matchSimply (Var scrut_var) LetMatch pat + = matchSimply (Var scrut_var) PatBindRhs pat (Var bndr_var) error_expr `thenDs` \ rhs_expr -> returnDs (bndr_var, rhs_expr) where - binder_ty = idType bndr_var - error_expr = mkApps (Var iRREFUT_PAT_ERROR_ID) [Type binder_ty, Var msg_var] + error_expr = mkCoerce (idType bndr_var) (Var err_var) - is_simple_pat (TuplePat ps True{-boxed-}) = all is_triv_pat ps - is_simple_pat (ConPat _ _ _ _ ps) = all is_triv_pat ps - is_simple_pat (VarPat _) = True - is_simple_pat (RecPat _ _ _ _ ps) = and [is_triv_pat p | (_,p,_) <- ps] - is_simple_pat other = False + is_simple_pat (TuplePat ps Boxed) = all is_triv_pat ps + is_simple_pat (ConPatOut _ ps _ _ _) = all is_triv_pat (hsConArgs ps) + is_simple_pat (VarPat _) = True + is_simple_pat (ParPat p) = is_simple_pat p + is_simple_pat other = False is_triv_pat (VarPat v) = True is_triv_pat (WildPat _) = True + is_triv_pat (ParPat p) = is_triv_pat p is_triv_pat other = False \end{code} @mkTupleExpr@ builds a tuple; the inverse to @mkTupleSelector@. If it -has only one element, it is the identity function. Notice we must -throw out any usage annotation on the outside of an Id. +has only one element, it is the identity function. \begin{code} mkTupleExpr :: [Id] -> CoreExpr -mkTupleExpr [] = mkConApp unitDataCon [] +{- This code has been replaced by mkCoreTup below +mkTupleExpr [] = Var unitDataConId mkTupleExpr [id] = Var id -mkTupleExpr ids = mkConApp (tupleCon (length ids)) - (map (Type . unUsgTy . idType) ids ++ [ Var i | i <- ids ]) +mkTupleExpr ids = mkConApp (tupleCon Boxed (length ids)) + (map (Type . idType) ids ++ [ Var i | i <-ids]) +-} + +mkTupleExpr ids = mkCoreTup(map Var ids) + +mkCoreTup :: [CoreExpr] -> CoreExpr +mkCoreTup [] = Var unitDataConId +mkCoreTup [c] = c +mkCoreTup cs = mkConApp (tupleCon Boxed (length cs)) + (map (Type . exprType) cs ++ cs) + \end{code} @@ -413,10 +601,10 @@ If there is just one id in the ``tuple'', then the selector is just the identity. \begin{code} -mkTupleSelector :: [Id] -- The tuple args - -> Id -- The selected one - -> Id -- A variable of the same type as the scrutinee - -> CoreExpr -- Scrutinee +mkTupleSelector :: [Id] -- The tuple args + -> Id -- The selected one + -> Id -- A variable of the same type as the scrutinee + -> CoreExpr -- Scrutinee -> CoreExpr mkTupleSelector [var] should_be_the_same_var scrut_var scrut @@ -424,8 +612,8 @@ mkTupleSelector [var] should_be_the_same_var scrut_var scrut scrut mkTupleSelector vars the_var scrut_var scrut - = ASSERT( not (null vars) ) - Case scrut scrut_var [(DataCon (tupleCon (length vars)), vars, Var the_var)] + = ASSERT( notNull vars ) + Case scrut scrut_var [(DataAlt (tupleCon Boxed (length vars)), vars, Var the_var)] \end{code} @@ -440,10 +628,14 @@ interact well with rules. \begin{code} mkNilExpr :: Type -> CoreExpr -mkNilExpr ty = App (Var (dataConId nilDataCon)) (Type ty) +mkNilExpr ty = mkConApp nilDataCon [Type ty] mkConsExpr :: Type -> CoreExpr -> CoreExpr -> CoreExpr -mkConsExpr ty hd tl = mkApps (Var (dataConId consDataCon)) [Type ty, hd, tl] +mkConsExpr ty hd tl = mkConApp consDataCon [Type ty, hd, tl] + +mkListExpr :: Type -> [CoreExpr] -> CoreExpr +mkListExpr ty xs = foldr (mkConsExpr ty) (mkNilExpr ty) xs + \end{code} @@ -467,7 +659,7 @@ fail-variable, and use that variable if the thing fails: Then \begin{itemize} \item -If the case can't fail, then there'll be no mention of fail.33, and the +If the case can't fail, then there'll be no mention of @fail.33@, and the simplifier will later discard it. \item @@ -478,7 +670,7 @@ Only if it is used more than once will the let-binding remain. \end{itemize} There's a problem when the result of the case expression is of -unboxed type. Then the type of fail.33 is unboxed too, and +unboxed type. Then the type of @fail.33@ is unboxed too, and there is every chance that someone will change the let into a case: \begin{verbatim} case error "Help" of @@ -499,7 +691,7 @@ for the primitive case: p4 -> ... \end{verbatim} -Now fail.33 is a function, so it can be let-bound. +Now @fail.33@ is a function, so it can be let-bound. \begin{code} mkFailurePair :: CoreExpr -- Result type of the whole case expression @@ -512,14 +704,13 @@ mkFailurePair expr = newFailLocalDs (unitTy `mkFunTy` ty) `thenDs` \ fail_fun_var -> newSysLocalDs unitTy `thenDs` \ fail_fun_arg -> returnDs (NonRec fail_fun_var (Lam fail_fun_arg expr), - App (Var fail_fun_var) (mkConApp unitDataCon [])) + App (Var fail_fun_var) (Var unitDataConId)) | otherwise = newFailLocalDs ty `thenDs` \ fail_var -> returnDs (NonRec fail_var expr, Var fail_var) where - ty = coreExprType expr + ty = exprType expr \end{code} -