import VarSet
import BasicTypes
import Util
+import MonadUtils
import Outputable
+
import List( nub )
\end{code}
Bool -- True <=> There is something interesting about
-- the context, and hence the inliner
-- should be a bit keener (see interestingCallContext)
- -- Two cases:
- -- (a) This is the RHS of a thunk whose type suggests
- -- that update-in-place would be possible
- -- (b) This is an argument of a function that has RULES
+ -- Specifically:
+ -- This is an argument of a function that has RULES
-- Inlining the call might allow the rule to fire
| CoerceIt -- C `cast` co
mkBoringStop ty = Stop ty AnArg False
mkLazyArgStop :: OutType -> Bool -> SimplCont
-mkLazyArgStop ty has_rules = Stop ty AnArg (canUpdateInPlace ty || has_rules)
+mkLazyArgStop ty has_rules = Stop ty AnArg has_rules
mkRhsStop :: OutType -> SimplCont
-mkRhsStop ty = Stop ty AnRhs (canUpdateInPlace ty)
+mkRhsStop ty = Stop ty AnRhs False
-------------------
contIsRhsOrArg (Stop {}) = True
go (StrictBind {}) = False -- ??
go (CoerceIt _ c) = go c
go (Stop _ _ interesting) = interesting
-
--------------------
-canUpdateInPlace :: Type -> Bool
--- Consider let x = <wurble> in ...
--- If <wurble> returns an explicit constructor, we might be able
--- to do update in place. So we treat even a thunk RHS context
--- as interesting if update in place is possible. We approximate
--- this by seeing if the type has a single constructor with a
--- small arity. But arity zero isn't good -- we share the single copy
--- for that case, so no point in sharing.
-
-canUpdateInPlace ty
- | not opt_UF_UpdateInPlace = False
- | otherwise
- = case splitTyConApp_maybe ty of
- Nothing -> False
- Just (tycon, _) -> case tyConDataCons_maybe tycon of
- Just [dc] -> arity == 1 || arity == 2
- where
- arity = dataConRepArity dc
- other -> False
\end{code}
; return (mkLams bndrs body') }
| otherwise
- = returnSmpl (mkLams bndrs body)
+ = return (mkLams bndrs body)
\end{code}
Note [Casts and lambdas]
-- if this is indeed a right-hand side; otherwise
-- we end up floating the thing out, only for float-in
-- to float it right back in again!
- = tryRhsTyLam env bndrs body `thenSmpl` \ (floats, body') ->
- returnSmpl (floats, mkLams bndrs body')
+ = do (floats, body') <- tryRhsTyLam env bndrs body
+ return (floats, mkLams bndrs body')
-}
\begin{code}
tryEtaExpansion :: DynFlags -> OutExpr -> SimplM OutExpr
-- There is at least one runtime binder in the binders
-tryEtaExpansion dflags body
- = getUniquesSmpl `thenSmpl` \ us ->
- returnSmpl (etaExpand fun_arity us body (exprType body))
+tryEtaExpansion dflags body = do
+ us <- getUniquesM
+ return (etaExpand fun_arity us body (exprType body))
where
fun_arity = exprEtaExpandArity dflags body
\end{code}
abstractFloats :: [OutTyVar] -> SimplEnv -> OutExpr -> SimplM ([OutBind], OutExpr)
abstractFloats main_tvs body_env body
= ASSERT( notNull body_floats )
- do { (subst, float_binds) <- mapAccumLSmpl abstract empty_subst body_floats
+ do { (subst, float_binds) <- mapAccumLM abstract empty_subst body_floats
; return (float_binds, CoreSubst.substExpr subst body) }
where
main_tv_set = mkVarSet main_tvs
-- gives rise to problems. SLPJ June 98
abstract subst (Rec prs)
- = do { (poly_ids, poly_apps) <- mapAndUnzipSmpl (mk_poly tvs_here) ids
+ = do { (poly_ids, poly_apps) <- mapAndUnzipM (mk_poly tvs_here) ids
; let subst' = CoreSubst.extendSubstList subst (ids `zip` poly_apps)
poly_rhss = [mkLams tvs_here (CoreSubst.substExpr subst' rhs) | rhs <- rhss]
; return (subst', Rec (poly_ids `zip` poly_rhss)) }
tvs_here = main_tvs
mk_poly tvs_here var
- = do { uniq <- getUniqueSmpl
+ = do { uniq <- getUniqueM
; let poly_name = setNameUnique (idName var) uniq -- Keep same name
poly_ty = mkForAllTys tvs_here (idType var) -- But new type of course
poly_id = mkLocalId poly_name poly_ty
[con] -> -- It matches exactly one constructor, so fill it in
do { tick (FillInCaseDefault case_bndr)
- ; us <- getUniquesSmpl
+ ; us <- getUniquesM
; let (ex_tvs, co_tvs, arg_ids) =
dataConRepInstPat us con inst_tys
; return [(DataAlt con, ex_tvs ++ co_tvs ++ arg_ids, deflt_rhs)] }
mkCase scrut case_bndr ty alts -- Identity case
| all identity_alt alts
- = tick (CaseIdentity case_bndr) `thenSmpl_`
- returnSmpl (re_cast scrut)
+ = do tick (CaseIdentity case_bndr)
+ return (re_cast scrut)
where
identity_alt (con, args, rhs) = check_eq con args (de_cast rhs)
--------------------------------------------------
-- Catch-all
--------------------------------------------------
-mkCase scrut bndr ty alts = returnSmpl (Case scrut bndr ty alts)
+mkCase scrut bndr ty alts = return (Case scrut bndr ty alts)
\end{code}