simplOutExpr env expr cont

   = case fun of

       Var v                    -> simplOutId env v cont'

       _                        -> rebuild_go env expr cont

   where

     cont' = pushArgs env Simplified (expType fun) args cont

 ---------------------------------------------------------

 simplOutId :: SimplEnvIS -> OutId -> SimplCont -> SimplM (SimplFloats, OutExpr)

 tryRules :: SimplEnv -> [CoreRule]

          -> OutId -> [OutExpr]

 tryRules env rules fn args

   -- Fire a rule for the function

   = do { logger <- getLogger

        ; checkedTick (RuleFired (ruleName rule))

        ; dump logger rule rule_rhs

   | otherwise  -- No rule fires

   = do { logger <- getLogger

         -- The continuation type

         SimplCont(..), DupFlag(..), FromWhat(..), StaticEnv,

         contIsDupable, contResultType, contHoleType, contHoleScaling,

         contIsTrivial, contArgs, contIsRhs,

         countArgs, contOutArgs, dropContArgs,

         ArgInfo(..), ArgSpec(..), mkArgInfo,

         addValArgTo, addTyArgTo,

         argInfoExpr, argSpecArg,

         isStrictArgInfo, lazyArgContext,

         abstractFloats,

   = cont

 pushArgs env dup fun_ty (arg:args) cont

   | Type ty <- arg

   | otherwise

   = ApplyToVal { sc_dup = dup, sc_hole_ty = fun_ty

                , sc_arg = arg, sc_env = env

 pushArgSpecs :: SimplEnvIS  -- Barely needed, since sc_dup = Simplified

              -> [ArgSpec]   -- In normal, forward order

 contIsRhs (CastIt { sc_cont = k })    = contIsRhs k   -- For f = e |> co, treat e as Rhs context

 contIsRhs _                           = Nothing

 -------------------

 contIsStop :: SimplCont -> Bool

 contIsStop (Stop {}) = True

              (CP { cp_qvars = vs2, cp_args = as2 })

   | equalLength as1 as2

   = case matchExprs ise vs1 as1 as2 of

   | otherwise -- We must handle patterns of unequal length separately (#24282)

   = False  -- For the pattern with more args, the last arg is "interesting"

 alreadyCovered env bndrs fn args is_active rules

   = case specLookupRule env fn args is_active rules of

       Nothing             -> False

         | isAutoRule rule -> -- Discard identical rules

                              -- We know that (fn args) is an instance of RULE

                              -- Check if RULE is an instance of (fn args)

   | null rules

   = Nothing    -- Saves building a few thunks in the common case

   | otherwise

   where

     dflags       = se_dflags env

     in_scope     = substInScopeSet (se_subst env)

 -- The 'CoreRule' datatype itself is declared elsewhere.

 module GHC.Core.Rules (

         -- ** Looking up rules

         -- ** RuleBase, RuleEnv

         RuleBase, RuleEnv(..), mkRuleEnv, emptyRuleEnv,

 ************************************************************************

 -}

 -- | The main rule matching function. Attempts to apply all (active)

 -- supplied rules to this instance of an application in a given

 -- context, returning the rule applied and the resulting expression if

            -> Id -- Function head

            -> [CoreExpr] -- Args

            -> [CoreRule] -- Rules

 -- See Note [Extra args in the target]

 -- See comments on matchRule

   where

     rough_args = map roughTopName args

     -- this matters for performance tests.

     args' = map (stripTicksTopE tickishFloatable) args

     ticks = concatMap (stripTicksTopT tickishFloatable) args

     go ms [] = ms

     go ms (r:rs)

       | otherwise

       = -- pprTrace "match failed" (ppr r $$ ppr args $$

         --   ppr [ (arg_id, maybeUnfoldingTemplate unf)

         --       , isCheapUnfolding unf] )

         go ms rs

 -- All these pairs matched the expression

 -- Return the pair the most specific rule

 -- The (fn,args) is just for overlap reporting

                       = ifPprDebug (ppr rule)

                                    (doubleQuotes (ftext (ruleName rule)))

                 in pprTrace "Rules.findBest: rule overlap (Rule 1 wins)"

                          (vcat [ whenPprDebug $

                                  text "Expression to match:" <+> ppr fn

                                  <+> sep (map ppr args)

   where

     (fn,args) = target

 -- The call (rule1 `ruleIsMoreSpecific` rule2)

 -- sees if rule2 can be instantiated to look like rule1

 -- See Note [ruleIsMoreSpecific]

   = case rule1 of

        BuiltinRule {} -> False

        Rule { ru_bndrs = bndrs1, ru_args = args1 }

 matchRule :: HasDebugCallStack

           => RuleOpts -> InScopeEnv -> (ActivationGhc -> Bool)

           -> Id -> [CoreExpr] -> [Maybe Name]

 -- If (matchRule rule args) returns Just (name,rhs)

 -- then (f args) matches the rule, and the corresponding

 --

 -- NB: The 'surplus' argument e4 in the input is simply dropped.

 -- See Note [Extra args in the target]

 -- For a given match template and context, find bindings to wrap around

 -- the entire result and what should be substituted for each template variable.

 --

 -- trailing ones, returning the result of applying the rule to a prefix

 -- of the actual arguments.

 matchExprs :: HasDebugCallStack

            => InScopeEnv -> [Var] -> [CoreExpr] -> [CoreExpr]

 matchExprs (ISE in_scope id_unf) tmpl_vars tmpl_es target_es

   = do  { rule_subst <- match_exprs init_menv emptyRuleSubst tmpl_es target_es

         ; let (_, matched_es) = mapAccumL (lookup_tmpl rule_subst)

                                           (mkEmptySubst in_scope) $

                                 tmpl_vars `zip` tmpl_vars1

   where

     (init_rn_env, tmpl_vars1) = mapAccumL rnBndrL (mkRnEnv2 in_scope) tmpl_vars

                   -- See Note [Cloning the template binders]

 rdrName2String :: RdrName -> String

 rdrName2String r =

     Just n  -> name2String n

     Nothing ->

       case r of